Added object files missing from last rebuild

git-svn-id: https://svn-dept.inf.ethz.ch/svn/lecturers/a2/trunk@8715 8c9fc860-2736-0410-a75d-ab315db34111

Linux32/bin/AdaptiveHuffman.SymU

@@ -0,0 +1,81 @@
+MODULE AdaptiveHuffman;
+	IMPORT Streams;
+CONST 
+	AlphabetSize = 256; 
+	BlockSize* = (8 * 1024); 
+	ScaleLimit = (4 * 1024); 
+	Encode = 0; 
+	Decode = 1; 
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	HuffmanCoder = OBJECT 
+	TYPE 
+		Index = INTEGER; 
+
+		Pattern = INTEGER; 
+
+		Node = RECORD 
+			weight: INTEGER; 
+			pattern: Pattern; 
+			up: Index; 
+			down: Index; 
+		END; 
+	VAR 
+		mode: SHORTINT; 
+		in: BitReader; 
+		out: BitWriter; 
+		esc: Index; 
+		root: Index; 
+		map: ARRAY AlphabetSize OF Index; 
+		table: ARRAY ((2 * AlphabetSize) + 2) OF Node; 
+
+		PROCEDURE ^  & New(m: SHORTINT; input: Streams.Reader; output: Streams.Writer); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Finish; 
+		PROCEDURE ^ GetPattern(): Pattern; 
+		PROCEDURE ^ PutPattern(patt: Pattern); 
+		PROCEDURE ^ AddPattern(patt: Pattern): Index; 
+		PROCEDURE ^ GroupLeader(node: Index): Index; 
+		PROCEDURE ^ SlideNode(node: Index): Index; 
+		PROCEDURE ^ IncrementWeight(node: Index); 
+		PROCEDURE ^ Scale; 
+		PROCEDURE ^ EncodeByte(ch: CHAR); 
+		PROCEDURE ^ ExtractByte(): CHAR; 
+	END HuffmanCoder; 
+
+	Encoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Writer); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Reader); 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+BEGIN
+END AdaptiveHuffman.

Linux32/bin/BorrowsWheeler.SymU

@@ -0,0 +1,57 @@
+MODULE BorrowsWheeler;
+CONST 
+	BlockSize* = (8 * 1024); 
+TYPE 
+	MTF = OBJECT 
+	TYPE 
+		Node = POINTER TO RECORD 
+			byte: CHAR; 
+			next: Node; 
+		END; 
+	VAR 
+		alpha: Node; 
+
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Encode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+		PROCEDURE ^ Decode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END MTF; 
+
+	Encoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		length: LONGINT; 
+		sbuf: ARRAY (2 * BlockSize) OF CHAR; 
+		rotation: ARRAY BlockSize OF Index; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ Less(a, b: Index): BOOLEAN; 
+		PROCEDURE ^ Swap(a, b: Index); 
+		PROCEDURE ^ InsertSort(lo, hi: Index); 
+		PROCEDURE ^ SortR(lo, hi: LONGINT); 
+		PROCEDURE ^ EncodeBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT): LONGINT; 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		f, l: ARRAY BlockSize OF CHAR; 
+		lc, fc: ARRAY BlockSize OF INTEGER; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE  - Swap(a, b: Index);
+		VAR 
+			tmp: CHAR; 
+		BEGIN
+			tmp := f[a]; 
+			f[a] := f[b]; 
+			f[b] := tmp
+		END Swap; 
+		PROCEDURE ^ SortF(lo, hi: Index); 
+		PROCEDURE ^ DecodeBlock*(VAR buf: ARRAY OF CHAR; len, index: LONGINT); 
+	END Decoder; 
+BEGIN
+END BorrowsWheeler.

Linux32/bin/DNS.SymU

@@ -8,8 +8,8 @@ CONST
 TYPE 
 	Name* = ARRAY 128 OF CHAR; 
 
-	Hostent = POINTER TO RECORD 
-		name: ADDRESS; 
+	Hostent = POINTER {UNSAFE, UNTRACED} TO RECORD 
+		name: POINTER {UNSAFE, UNTRACED} TO Name; 
 		aliases: ADDRESS; 
 		addrtype: LONGINT; 
 		length: LONGINT; 

Linux32/bin/FoxInterpreter.SymU

@@ -0,0 +1,205 @@
+MODULE FoxInterpreter;
+	IMPORT Scanner := FoxScanner, FoxParser, SyntaxTree := FoxSyntaxTree, Printout := FoxPrintout, Commands, Diagnostics, StringPool, InterpreterSymbols := FoxInterpreterSymbols, D := Debugging, Strings, Streams, Modules, PersistentObjects, Basic := FoxBasic, SYSTEM, Machine, Global := FoxGlobal, Heaps;
+CONST 
+	EnableTrace = FALSE; 
+	MaxIndex = 8; 
+TYPE 
+	Result* = InterpreterSymbols.Result; 
+
+	Value* = InterpreterSymbols.Value; 
+
+	Integer* = InterpreterSymbols.IntegerValue; 
+
+	Real* = InterpreterSymbols.RealValue; 
+
+	String* = InterpreterSymbols.StringValue; 
+
+	Boolean* = InterpreterSymbols.BooleanValue; 
+
+	Set* = InterpreterSymbols.SetValue; 
+
+	Range* = InterpreterSymbols.RangeValue; 
+
+	Char* = InterpreterSymbols.CharValue; 
+
+	Any* = InterpreterSymbols.AnyValue; 
+
+	MathArrayValue* = InterpreterSymbols.MathArrayValue; 
+
+	Scope* = InterpreterSymbols.Scope; 
+
+	Container* = InterpreterSymbols.Container; 
+
+	Builtin* = OBJECT (InterpreterSymbols.Object)
+	VAR 
+		id: LONGINT; 
+	END Builtin; 
+
+	Item* = RECORD 
+		object*: InterpreterSymbols.Item; 
+		in*: InterpreterSymbols.Item; 
+		name*: StringPool.Index; 
+		i*: ARRAY MaxIndex OF LONGINT; 
+	END; 
+
+	CommandStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		command: Strings.String; 
+
+		PROCEDURE ^  & InitCommandStatement(s: Strings.String); 
+	END CommandStatement; 
+
+	PrintStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		expression: SyntaxTree.Expression; 
+
+		PROCEDURE ^  & InitPrintStatement(e: SyntaxTree.Expression); 
+	END PrintStatement; 
+
+	Parser* = OBJECT (FoxParser.Parser)
+
+		PROCEDURE ^ Statement*(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement): BOOLEAN; 
+		PROCEDURE ^ Cmd(): SyntaxTree.Statement; 
+		PROCEDURE ^ Print(): SyntaxTree.Statement; 
+	END Parser; 
+
+	Interpreter* = OBJECT (SyntaxTree.Visitor)
+	VAR 
+		value: BOOLEAN; 
+		item-: Item; 
+		module-: Modules.Module; 
+		typeDesc-: Modules.TypeDesc; 
+		scope-: Scope; 
+		exit: BOOLEAN; 
+		error-: BOOLEAN; 
+		diagnostics: Diagnostics.Diagnostics; 
+		context-: Commands.Context; 
+
+		PROCEDURE ^  & Init*(scope: Scope; diagnostics: Diagnostics.Diagnostics; context: Commands.Context); 
+		PROCEDURE ^ SetScope*(s: Scope); 
+		PROCEDURE ^ Reset*; 
+		PROCEDURE ^ Error(CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ErrorSS(CONST msg: ARRAY OF CHAR; id: StringPool.Index); 
+		PROCEDURE ^ VisitSet*(x: SyntaxTree.Set); 
+		PROCEDURE ^ VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression); 
+		PROCEDURE ^ NewInt(i: HUGEINT); 
+		PROCEDURE ^ NewReal(i: LONGREAL); 
+		PROCEDURE ^ NewBool(b: BOOLEAN); 
+		PROCEDURE ^ NewSet(s: SET); 
+		PROCEDURE ^ NewString(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ NewRange(r: RANGE); 
+		PROCEDURE ^ NewChar(c: CHAR); 
+		PROCEDURE ^ VisitUnaryExpression*(x: SyntaxTree.UnaryExpression); 
+		PROCEDURE ^ VisitBinaryExpression*(x: SyntaxTree.BinaryExpression); 
+		PROCEDURE ^ VisitRangeExpression*(x: SyntaxTree.RangeExpression); 
+		PROCEDURE ^ VisitTensorRangeExpression*(x: SyntaxTree.TensorRangeExpression); 
+		PROCEDURE ^ VisitConversion*(x: SyntaxTree.Conversion); 
+		PROCEDURE ^ VisitDesignator*(x: SyntaxTree.Designator); 
+		PROCEDURE ^ VisitQualifiedType*(x: SyntaxTree.QualifiedType); 
+		PROCEDURE ^ VisitIdentifierDesignator*(x: SyntaxTree.IdentifierDesignator); 
+		PROCEDURE ^ VisitSelectorDesignator*(x: SyntaxTree.SelectorDesignator); 
+		PROCEDURE ^ VisitParameterDesignator*(x: SyntaxTree.ParameterDesignator); 
+		PROCEDURE ^ VisitArrowDesignator*(x: SyntaxTree.ArrowDesignator); 
+		PROCEDURE ^ VisitBracketDesignator*(x: SyntaxTree.BracketDesignator); 
+		PROCEDURE ^ VisitSymbolDesignator*(x: SyntaxTree.SymbolDesignator); 
+		PROCEDURE ^ VisitIndexDesignator*(x: SyntaxTree.IndexDesignator); 
+		PROCEDURE ^ VisitProcedureCallDesignator*(x: SyntaxTree.ProcedureCallDesignator); 
+		PROCEDURE ^ SystemTrace(x: SyntaxTree.ExpressionList); 
+		PROCEDURE ^ FindType(type: SyntaxTree.Type): Result; 
+		PROCEDURE ^ VisitBuiltinCallDesignator*(x: SyntaxTree.BuiltinCallDesignator); 
+		PROCEDURE ^ VisitTypeGuardDesignator*(x: SyntaxTree.TypeGuardDesignator); 
+		PROCEDURE ^ VisitDereferenceDesignator*(x: SyntaxTree.DereferenceDesignator); 
+		PROCEDURE ^ VisitSupercallDesignator*(x: SyntaxTree.SupercallDesignator); 
+		PROCEDURE ^ VisitSelfDesignator*(x: SyntaxTree.SelfDesignator); 
+		PROCEDURE ^ VisitResultDesignator*(x: SyntaxTree.ResultDesignator); 
+		PROCEDURE ^ VisitValue*(x: SyntaxTree.Value); 
+		PROCEDURE ^ VisitBooleanValue*(x: SyntaxTree.BooleanValue); 
+		PROCEDURE ^ VisitIntegerValue*(x: SyntaxTree.IntegerValue); 
+		PROCEDURE ^ VisitCharacterValue*(x: SyntaxTree.CharacterValue); 
+		PROCEDURE ^ VisitSetValue*(x: SyntaxTree.SetValue); 
+		PROCEDURE ^ VisitMathArrayValue*(x: SyntaxTree.MathArrayValue); 
+		PROCEDURE ^ VisitRealValue*(x: SyntaxTree.RealValue); 
+		PROCEDURE ^ VisitComplexValue*(x: SyntaxTree.ComplexValue); 
+		PROCEDURE ^ VisitStringValue*(x: SyntaxTree.StringValue); 
+		PROCEDURE ^ VisitNilValue*(x: SyntaxTree.NilValue); 
+		PROCEDURE ^ VisitEnumerationValue*(x: SyntaxTree.EnumerationValue); 
+		PROCEDURE ^ VisitSymbol*(x: SyntaxTree.Symbol); 
+		PROCEDURE ^ VisitTypeDeclaration*(x: SyntaxTree.TypeDeclaration); 
+		PROCEDURE ^ VisitConstant*(x: SyntaxTree.Constant); 
+		PROCEDURE ^ VisitVariable*(x: SyntaxTree.Variable); 
+		PROCEDURE ^ VisitParameter*(x: SyntaxTree.Parameter); 
+		PROCEDURE ^ VisitProcedure*(x: SyntaxTree.Procedure); 
+		PROCEDURE ^ VisitBuiltin*(x: SyntaxTree.Builtin); 
+		PROCEDURE ^ VisitOperator*(x: SyntaxTree.Operator); 
+		PROCEDURE ^ VisitImport*(x: SyntaxTree.Import); 
+		PROCEDURE ^ TranslateString*(cmd: CHAR; CONST str: ARRAY OF CHAR; VAR dest: Strings.String): BOOLEAN; 
+		PROCEDURE ^ VisitCommandStatement(x: CommandStatement); 
+		PROCEDURE ^ VisitPrintStatement(x: PrintStatement); 
+		PROCEDURE ^ VisitStatement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ VisitProcedureCallStatement*(x: SyntaxTree.ProcedureCallStatement); 
+		PROCEDURE ^ LoadValue; 
+		PROCEDURE ^ GetValue*(x: SyntaxTree.Expression; VAR w: Value): BOOLEAN; 
+		PROCEDURE ^ Designate(x: SyntaxTree.Expression): Result; 
+		PROCEDURE ^ Evaluate(x: SyntaxTree.Expression): Value; 
+		PROCEDURE ^ GetInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ ExpectInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ GetBoolean(x: SyntaxTree.Expression; VAR i: Boolean): BOOLEAN; 
+		PROCEDURE ^ ExpectBoolean(x: SyntaxTree.Expression; VAR b: Boolean): BOOLEAN; 
+		PROCEDURE ^ PutValue(x: SyntaxTree.Designator; v: Value); 
+		PROCEDURE ^ VisitAssignment*(x: SyntaxTree.Assignment); 
+		PROCEDURE ^ IfPart(ifPart: SyntaxTree.IfPart): BOOLEAN; 
+		PROCEDURE ^ VisitIfStatement*(x: SyntaxTree.IfStatement); 
+		PROCEDURE ^ VisitWithStatement*(x: SyntaxTree.WithStatement); 
+		PROCEDURE ^ CasePart(x: SyntaxTree.CasePart; b: SyntaxTree.BinaryExpression): BOOLEAN; 
+		PROCEDURE ^ VisitCaseStatement*(x: SyntaxTree.CaseStatement); 
+		PROCEDURE ^ VisitWhileStatement*(x: SyntaxTree.WhileStatement); 
+		PROCEDURE ^ VisitRepeatStatement*(x: SyntaxTree.RepeatStatement); 
+		PROCEDURE ^ VisitForStatement*(x: SyntaxTree.ForStatement); 
+		PROCEDURE ^ VisitLoopStatement*(x: SyntaxTree.LoopStatement); 
+		PROCEDURE ^ VisitExitStatement*(x: SyntaxTree.ExitStatement); 
+		PROCEDURE ^ VisitReturnStatement*(x: SyntaxTree.ReturnStatement); 
+		PROCEDURE ^ VisitAwaitStatement*(x: SyntaxTree.AwaitStatement); 
+		PROCEDURE ^ VisitStatementBlock*(x: SyntaxTree.StatementBlock); 
+		PROCEDURE ^ VisitCode*(x: SyntaxTree.Code); 
+		PROCEDURE ^ Expression(x: SyntaxTree.Expression); 
+		PROCEDURE ^ Statement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ StatementSequence*(x: SyntaxTree.StatementSequence); 
+	END Interpreter; 
+
+	Resolver* = OBJECT 
+	VAR 
+		interpreter: Interpreter; 
+		content: PersistentObjects.Content; 
+		resolved: Basic.HashTable; 
+		current: Scope; 
+		changed: BOOLEAN; 
+
+		PROCEDURE ^  & InitResolver*; 
+		PROCEDURE ^ Traverse(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ DoResolve*(scope: Scope); 
+		PROCEDURE ^ Resolve*(scope: Scope); 
+	END Resolver; 
+
+	TestO = OBJECT 
+	VAR 
+		i: LONGINT; 
+
+		PROCEDURE ^  & P(s: SHORTINT); 
+	END TestO; 
+
+	; 
+VAR 
+	global-: Scope; 
+	c: LONGINT; 
+	d: RECORD 
+		e: LONGINT; 
+	END; 
+
+	PROCEDURE ^ Statements*(context: Commands.Context); 
+	PROCEDURE ^ Expression*(context: Commands.Context); 
+	PROCEDURE ^ TranslateString*(context: Commands.Context); 
+	PROCEDURE ^ InitGlobalScope; 
+	PROCEDURE ^ Getter(): LONGINT; 
+	PROCEDURE ^ Setter(a: LONGINT): LONGINT; 
+BEGIN
+END FoxInterpreter.

Linux32/bin/FoxInterpreterSymbols.SymU

@@ -0,0 +1,351 @@
+MODULE FoxInterpreterSymbols;
+	IMPORT Strings, Basic := FoxBasic, StringPool, Streams, Commands, PersistentObjects, Modules, Machine, SyntaxTree := FoxSyntaxTree, SYSTEM, Reflection;
+CONST 
+	TAB = 9X; 
+	StrValue = \"value"\; 
+TYPE 
+	Item* = PersistentObjects.Object; 
+
+	Object* = PersistentObjects.Object; 
+
+	Content* = PersistentObjects.Content; 
+
+	Name* = ARRAY 128 OF CHAR; 
+
+	Meta* = RECORD 
+		module*: Modules.Module; 
+		refs*: Modules.Bytes; 
+		offset*: SIZE; 
+	END; 
+
+	Result* = OBJECT (Item)
+
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Trace*; 
+	END Result; 
+
+	SymbolResult* = OBJECT (Result)
+	VAR 
+		name: ARRAY 32 OF CHAR; 
+
+		PROCEDURE ^ InitSymbol(CONST n: ARRAY OF CHAR); 
+	END SymbolResult; 
+
+	TypeResult* = OBJECT (SymbolResult)
+	VAR 
+		type-: Meta; 
+		address: ADDRESS; 
+
+		PROCEDURE ^  & InitType(CONST name: ARRAY OF CHAR; t: Meta); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Constructor*(): ProcedureResult; 
+	END TypeResult; 
+
+	ModuleResult* = OBJECT (SymbolResult)
+	VAR 
+		self: Meta; 
+
+		PROCEDURE ^  & InitModule(CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END ModuleResult; 
+
+	Callstack = OBJECT 
+	VAR 
+		data: ARRAY 1024 OF CHAR; 
+		pos: SIZE; 
+		size: SIZE; 
+		H: HUGEINT; 
+		pPos: LONGINT; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Next(s: SIZE): ADDRESS; 
+		PROCEDURE ^ PushH(h: HUGEINT); 
+		PROCEDURE ^ PushL(i: LONGINT); 
+		PROCEDURE ^ PushI(i: INTEGER); 
+		PROCEDURE ^ PushS(i: SHORTINT); 
+		PROCEDURE ^ PushB(b: BOOLEAN); 
+		PROCEDURE ^ PushC(c: CHAR); 
+		PROCEDURE ^ PushSet(set: SET); 
+		PROCEDURE ^ PushR(r: REAL); 
+		PROCEDURE ^ PushX(x: LONGREAL); 
+		PROCEDURE ^ PushA(a: ADDRESS); 
+		PROCEDURE ^ PushSz(s: SIZE); 
+		PROCEDURE ^ Call(adr: ADDRESS); 
+		PROCEDURE ^ CallH(adr: ADDRESS): HUGEINT; 
+		PROCEDURE ^ CallR(adr: ADDRESS): REAL; 
+		PROCEDURE ^ CallX(adr: ADDRESS): LONGREAL; 
+	END Callstack; 
+
+	ProcedureResult* = OBJECT (SymbolResult)
+	VAR 
+		meta: Meta; 
+		address: ADDRESS; 
+		stack: Callstack; 
+		index: LONGINT; 
+		caller-: Result; 
+		parameters: Meta; 
+		flags: SET; 
+
+		PROCEDURE ^ Parameters(): Meta; 
+		PROCEDURE ^ ReturnType(): Meta; 
+		PROCEDURE ^ ReturnsPointer*(): BOOLEAN; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^  & InitProcedure(c: Result; CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Pars*; 
+		PROCEDURE ^ PushAddress*(adr: ADDRESS); 
+		PROCEDURE ^ PushTyped*(o: Result; mode: CHAR; refs: Modules.Bytes; VAR offset: SIZE): BOOLEAN; 
+		PROCEDURE ^ Push*(o: Result): BOOLEAN; 
+		PROCEDURE ^ Check*(): BOOLEAN; 
+		PROCEDURE ^ Evaluate*(): Value; 
+	END ProcedureResult; 
+
+	FieldResult* = OBJECT (SymbolResult)
+	VAR 
+		address: ADDRESS; 
+		meta: Meta; 
+
+		PROCEDURE ^  & InitField(CONST name: ARRAY OF CHAR; meta: Meta; base: ADDRESS); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END FieldResult; 
+
+	Value* = OBJECT (Result)
+
+		PROCEDURE ^  & InitValue; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ GetInt*(VAR h: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ GetChar*(VAR x: CHAR): BOOLEAN; 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ GetString*(VAR w: ARRAY OF CHAR); 
+	END Value; 
+
+	AnyValue* = OBJECT (Value)
+	VAR 
+		value*: ANY; 
+
+		PROCEDURE ^  & InitAny*(value: ANY); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END AnyValue; 
+
+	AddressValue* = OBJECT (Value)
+	VAR 
+		value*: ADDRESS; 
+
+		PROCEDURE ^  & InitAny*(value: ADDRESS); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END AddressValue; 
+
+	IntegerValue* = OBJECT (Value)
+	VAR 
+		value*: HUGEINT; 
+
+		PROCEDURE ^  & InitInteger*(value: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetInt*(VAR v: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END IntegerValue; 
+
+	RealValue* = OBJECT (Value)
+	VAR 
+		value*: LONGREAL; 
+
+		PROCEDURE ^  & InitReal*(value: LONGREAL); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RealValue; 
+
+	BooleanValue* = OBJECT (Value)
+	VAR 
+		value*: BOOLEAN; 
+
+		PROCEDURE ^  & InitBoolean*(value: BOOLEAN); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END BooleanValue; 
+
+	StringValue* = OBJECT (Value)
+	VAR 
+		value*: Strings.String; 
+
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END StringValue; 
+
+	SetValue* = OBJECT (Value)
+	VAR 
+		value*: SET; 
+
+		PROCEDURE ^  & InitSet*(value: SET); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END SetValue; 
+
+	RangeValue* = OBJECT (Value)
+	VAR 
+		value*: RANGE; 
+
+		PROCEDURE ^  & InitRange*(r: RANGE); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RangeValue; 
+
+	CharValue* = OBJECT (Value)
+	VAR 
+		value: CHAR; 
+
+		PROCEDURE ^  & InitChar*(c: CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetChar*(VAR c: CHAR): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END CharValue; 
+
+	EnumValue* = OBJECT (Value)
+	VAR 
+		value: HUGEINT; 
+		translation: PersistentObjects.Translation; 
+
+		PROCEDURE ^  & InitEnumValue*(trans: PersistentObjects.Translation; v: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END EnumValue; 
+
+	MathArrayValue* = OBJECT (Value)
+	VAR 
+		values: ARRAY [*] OF Value; 
+
+		PROCEDURE ^  & InitMathArrayValue*(len: LONGINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ SetValue*(at: LONGINT; value: Value); 
+		PROCEDURE ^ GetValue*(at: LONGINT): Value; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+	END MathArrayValue; 
+
+	Symbol* = OBJECT 
+	VAR 
+		name: StringPool.Index; 
+		item-: Item; 
+
+		PROCEDURE ^  & InitSymbol(name: StringPool.Index; index: LONGINT); 
+		PROCEDURE ^ GetName(VAR name: ARRAY OF CHAR); 
+	END Symbol; 
+
+	Container* = OBJECT (Item)
+	VAR 
+		symbols-: Basic.List; 
+		lookup-: Basic.HashTableInt; 
+
+		PROCEDURE ^  & InitContainer*; 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetItem*(index: LONGINT): Item; 
+		PROCEDURE ^ Enter1*(item: Item; name: StringPool.Index); 
+		PROCEDURE ^ Enter*(item: Item; CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ Find1*(id: LONGINT): Item; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Item; 
+	END Container; 
+
+	Scope* = OBJECT 
+	VAR 
+		outer-: Scope; 
+		object-: Object; 
+		level: LONGINT; 
+
+		PROCEDURE ^  & InitScope*(outer: Scope; object: Object); 
+		PROCEDURE ^ Enter*(object: Object): Scope; 
+		PROCEDURE ^ FindObject*(CONST name: ARRAY OF CHAR; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ FindObject1*(name: StringPool.Index; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ Leave*(): Scope; 
+		PROCEDURE ^ Dump*(log: Streams.Writer); 
+	END Scope; 
+
+	ObjectFilter* = OBJECT 
+	VAR 
+		content: Content; 
+		object: Object; 
+		found: Container; 
+		attribute, value: ARRAY 256 OF CHAR; 
+
+		PROCEDURE ^  & InitObjectFilter*; 
+		PROCEDURE ^ AddFiltered(obj: Object); 
+		PROCEDURE ^ Enumerate(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Filter*(obj: Object; attribute, value: ARRAY OF CHAR): Container; 
+	END ObjectFilter; 
+
+	PROCEDURE ^ FindSymbol*(CONST name: ARRAY OF CHAR; meta: Meta): Meta; 
+	PROCEDURE ^ SymbolKind*(meta: Meta): CHAR; 
+	PROCEDURE ^ SymbolParent*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolName*(meta: Meta; VAR name: ARRAY OF CHAR); 
+	PROCEDURE ^ VariableMode*(meta: Meta): Meta; 
+	PROCEDURE ^ VariableType*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolAddress*(meta: Meta; base: ADDRESS): ADDRESS; 
+	PROCEDURE ^ FindInType(scope: Result; address: ADDRESS; type: ADDRESS; CONST name: ARRAY OF CHAR): Result; 
+	PROCEDURE ^ FindConstructor(scope: Result; type: ADDRESS): ProcedureResult; 
+	PROCEDURE ^ Indent(w: Streams.Writer; level: LONGINT); 
+	PROCEDURE ^ Test*(context: Commands.Context); 
+	PROCEDURE ^ ContentGetValue(c: Content): Value; 
+	PROCEDURE ^ NewIntegerValue(value: HUGEINT): IntegerValue; 
+	PROCEDURE ^ NewFloatValue(value: LONGREAL): RealValue; 
+	PROCEDURE ^ NewBooleanValue(value: BOOLEAN): BooleanValue; 
+	PROCEDURE ^ NewStringValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewNameValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewRangeValue(value: RANGE): RangeValue; 
+	PROCEDURE ^ NewCharValue(value: CHAR): CharValue; 
+	PROCEDURE ^ NewSetValue(value: SET): SetValue; 
+	PROCEDURE ^ NewEnumValue(translation: PersistentObjects.Translation; value: HUGEINT): EnumValue; 
+	PROCEDURE ^ FindInObject*(in: Object; CONST name: ARRAY OF CHAR; index: LONGINT): Object; 
+	PROCEDURE ^ GetModule*(CONST name: ARRAY OF CHAR): ModuleResult; 
+	PROCEDURE ^ FindInObject1*(in: Object; name: StringPool.Index; index: LONGINT): Object; 
+BEGIN
+END FoxInterpreterSymbols.

Linux32/bin/HierarchicalProfiler.SymU

@@ -0,0 +1,111 @@
+MODULE HierarchicalProfiler;
+	IMPORT SYSTEM, Machine, Streams, Modules, Objects, Kernel, Reflection, Commands, Options, Strings, Errors, HierarchicalProfiler0;
+CONST 
+	Ok* = 0; 
+	AlreadyRunning* = 5101; 
+	NotRunning* = 5102; 
+	NoProfileDataAvailable* = 5103; 
+	SampleBufferFull* = 5104; 
+	SampleBufferNotInitialized* = 5105; 
+	Hierarchical* = 0; 
+	Flat* = 1; 
+	None* = 0; 
+	Threads* = 1; 
+	Processors* = 2; 
+	ThreadsProcessors* = 3; 
+	ProcessorsThreads* = 4; 
+	NotRunningNoDataAvailable* = 0; 
+	NotRunningDataAvailable* = 1; 
+	Running* = 2; 
+	DefaultMaxTime = 30; 
+	MaxUnwindingDepth = 64; 
+	Invalid = 0; 
+TYPE 
+	Name = ARRAY 256 OF CHAR; 
+
+	Sample = ARRAY MaxUnwindingDepth OF ADDRESS; 
+
+	Samples = POINTER TO ARRAY OF Sample; 
+
+	SampleInfo = RECORD 
+		processorID: LONGINT; 
+		process: Objects.Process; 
+	END; 
+
+	SampleInfos = POINTER TO ARRAY OF SampleInfo; 
+
+	Node* = OBJECT 
+	VAR 
+		parent-: Node; 
+		child-: Node; 
+		sibling-: Node; 
+		count-: LONGINT; 
+		percent-: REAL; 
+		nofChildren-: LONGINT; 
+		name-: Name; 
+		extern*: BOOLEAN; 
+		marked*: BOOLEAN; 
+		next: Node; 
+
+		PROCEDURE ^ GetCaption*(): Strings.String; 
+		PROCEDURE ^ Show(out: Streams.Writer; indent: LONGINT); 
+		PROCEDURE ^  & Init*; 
+	END Node; 
+
+	VisitorProcedure* = PROCEDURE {DELEGATE}(node: Node); 
+
+	Profile* = OBJECT {EXCLUSIVE} 
+	VAR 
+		nodes-: Node; 
+		nofSamples-: LONGINT; 
+		nofProcessors-: LONGINT; 
+		nofRunsTooDeep-: LONGINT; 
+		nofUnwindingFaults-: LONGINT; 
+		nofSamplesNotStored-: LONGINT; 
+		pattern: ARRAY 64 OF CHAR; 
+		minPercent: LONGINT; 
+
+		PROCEDURE ^ FindNode(CONST name: Name; list: Node): Node; 
+		PROCEDURE ^ MergeNode(newNode, parent: Node); 
+		PROCEDURE ^ Flatten*(parent: Node); 
+		PROCEDURE ^ VisitorClearMark(node: Node); 
+		PROCEDURE ^ Mark*(CONST pattern: ARRAY OF CHAR; minPercent: LONGINT); 
+		PROCEDURE ^ VisitorSetMark(node: Node); 
+		PROCEDURE ^ VisitNodes(node: Node; visitorProc: VisitorProcedure); 
+		PROCEDURE ^ Visit*(visitorProc: VisitorProcedure); 
+		PROCEDURE ^  & Init*; 
+	END Profile; 
+VAR 
+	samples: Samples; 
+	sampleInfos: SampleInfos; 
+	maxNofSamples: LONGINT; 
+	nofRunsTooDeep: LONGINT; 
+	nofUnwindingFaults: LONGINT; 
+	nofSamplesNotStored: LONGINT; 
+	nofSamples: LONGINT; 
+	currentIndex: LONGINT; 
+	locked: BOOLEAN; 
+	state: LONGINT; 
+
+	PROCEDURE ^ FindChildNode(CONST name: Name; parent: Node): Node; 
+	PROCEDURE ^ MergeChildNode(CONST procedureName: ARRAY OF CHAR; parent: Node): Node; 
+	PROCEDURE ^ AddSample(profile: Node; type, info: LONGINT; CONST sampleInfo: SampleInfo; CONST sample: Sample); 
+	PROCEDURE ^ HandleTimer(id: LONGINT; process: Objects.Process; pc, bp, lowAdr, highAdr: ADDRESS); 
+	PROCEDURE ^ InvalidateSample(VAR sample: Sample); 
+	PROCEDURE ^ SortChildren(parent: Node); 
+	PROCEDURE ^ PostProcessNode(profile: Profile; node: Node); 
+	PROCEDURE ^ PostProcessProfile(profile: Profile); 
+	PROCEDURE ^ CreateProfile(type: LONGINT; info: LONGINT): Profile; 
+	PROCEDURE ^ GetBufferSize*(time: LONGINT): LONGINT; 
+	PROCEDURE ^ GetProfile*(type, info: LONGINT; VAR profile: Profile; VAR res: WORD); 
+	PROCEDURE ^ Start*(context: Commands.Context); 
+	PROCEDURE ^ StartProfiling*(maxTime: LONGINT; VAR res: WORD); 
+	PROCEDURE ^ Stop*(context: Commands.Context); 
+	PROCEDURE ^ StopProfiling*(VAR res: WORD); 
+	PROCEDURE ^ Continue*(context: Commands.Context); 
+	PROCEDURE ^ ContinueProfiling*(VAR res: WORD); 
+	PROCEDURE ^ GetState*(VAR currentSamples, maxSamples: LONGINT): LONGINT; 
+	PROCEDURE ^ Show*(context: Commands.Context); 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END HierarchicalProfiler.

Linux32/bin/HierarchicalProfiler0.SymU

@@ -0,0 +1,42 @@
+MODULE HierarchicalProfiler0;
+	IMPORT SYSTEM, Kernel, Unix, Objects, Modules, ProcessInfo, Heaps;
+CONST 
+	Initialized = 0; 
+	Running = 1; 
+	Terminating = 2; 
+	Terminated = 3; 
+	Intervall = 1; 
+TYPE 
+	ProcessTimeArray = POINTER TO ARRAY ProcessInfo.MaxNofProcesses OF HUGEINT; 
+
+	Callback = PROCEDURE (id: LONGINT; process: Objects.Process; pc, bp, lowAdr, highAdr: ADDRESS); 
+
+	Poller = OBJECT {EXCLUSIVE} 
+	VAR 
+		processes, oldProcesses: ARRAY ProcessInfo.MaxNofProcesses OF Objects.Process; 
+		nofProcesses, oldNofProcesses: LONGINT; 
+		times, oldTimes: ProcessTimeArray; 
+		me: Objects.Process; 
+		state: LONGINT; 
+		timer: Kernel.Timer; 
+		NormalGC: PROCEDURE ; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Terminate; 
+		PROCEDURE ^ Clear(array: ProcessTimeArray); 
+		PROCEDURE ^ RanMeanwhile(process: Objects.Process; currentCycles: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ Process; 
+	BEGIN{ACTIVE, PRIORITY(Objects.Realtime)} 
+	END Poller; 
+VAR 
+	poller: Poller; 
+	callback: Callback; 
+	state: LONGINT; 
+
+	PROCEDURE ^ Nothing; 
+	PROCEDURE ^ HandleProcess(process: Objects.Process); 
+	PROCEDURE ^ Enable*(proc: Callback); 
+	PROCEDURE ^ Disable*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END HierarchicalProfiler0.

Linux32/bin/HostLibs.SymU

@@ -0,0 +1,12 @@
+MODULE HostLibs;
+	IMPORT SYSTEM, Unix;
+CONST 
+	NilLibHandle* = NIL; 
+TYPE 
+	LibHandle* = ADDRESS; 
+
+	PROCEDURE ^ LoadLibrary*(CONST fileName: ARRAY OF CHAR; VAR lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ FreeLibrary*(CONST lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ GetProcedure*(CONST lib: LibHandle; CONST name: ARRAY OF CHAR; CONST procAddr: ADDRESS): BOOLEAN; 
+BEGIN
+END HostLibs.

Linux32/bin/Huffman.SymU

@@ -0,0 +1,74 @@
+MODULE Huffman;
+	IMPORT Streams;
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	PatternCounts = ARRAY 256 OF LONGINT; 
+
+	Pattern = RECORD 
+		patt, weight: LONGINT; 
+	END; 
+
+	PatternWeights = POINTER TO ARRAY OF Pattern; 
+
+	HuffCode = RECORD 
+		bits, val: LONGINT; 
+	END; 
+
+	Node = OBJECT 
+	VAR 
+		weight: LONGINT; 
+		pattern: LONGINT; 
+		left, right: Node; 
+
+		PROCEDURE ^  & Init(patt, w: LONGINT); 
+		PROCEDURE ^ AddChildren(l, r: Node); 
+	END Node; 
+
+	Encoder* = OBJECT 
+	VAR 
+		w: Streams.Writer; 
+		out: BitWriter; 
+		codeTable: ARRAY 256 OF HuffCode; 
+
+		PROCEDURE ^  & New*(output: Streams.Writer); 
+		PROCEDURE ^ WriteFrequencies(pw: PatternWeights); 
+		PROCEDURE ^ CountPatterns(CONST source: ARRAY OF CHAR; len: LONGINT): PatternWeights; 
+		PROCEDURE ^ BuildCodeTable(pw: PatternWeights); 
+		PROCEDURE ^ PutCode(code: HuffCode); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		r: Streams.Reader; 
+		in: BitReader; 
+		tree: Node; 
+
+		PROCEDURE ^  & New*(input: Streams.Reader); 
+		PROCEDURE ^ ReadFrequencies(r: Streams.Reader): PatternWeights; 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+
+	PROCEDURE ^ ContainedPatterns(VAR pc: PatternCounts): PatternWeights; 
+	PROCEDURE ^ BuildTree(pw: PatternWeights): Node; 
+BEGIN
+END Huffman.

Linux32/bin/IPBandwidth.SymU

@@ -0,0 +1,53 @@
+MODULE IPBandwidth;
+	IMPORT Commands, Diagnostics, Kernel, Options, Streams, DNS, IP, TCP, UDP;
+CONST 
+	DefaultPort = 5772; 
+	DefaultDuration = 10; 
+TYPE 
+	Link = OBJECT 
+	VAR 
+		context: Commands.Context; 
+		diagnostics: Diagnostics.StreamDiagnostics; 
+		hostname: DNS.Name; 
+		port, result: WORD; 
+		address: IP.Adr; 
+		buffer: ARRAY 65000 OF CHAR; 
+
+		PROCEDURE ^  & Initialize(context: Commands.Context); 
+		PROCEDURE ^ Send; 
+		PROCEDURE ^ Receive; 
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END Link; 
+
+	TCPLink = OBJECT (Link)
+	VAR 
+		service, connection: TCP.Connection; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END TCPLink; 
+
+	UDPLink = OBJECT (Link)
+	VAR 
+		socket: UDP.Socket; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END UDPLink; 
+
+	PROCEDURE ^ SendTCP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveTCP*(context: Commands.Context); 
+	PROCEDURE ^ SendUDP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveUDP*(context: Commands.Context); 
+BEGIN
+END IPBandwidth.

Linux32/bin/MinosLinker.SymU

@@ -0,0 +1,58 @@
+MODULE MinosLinker;
+	IMPORT Streams, Commands, Files, KernelLog;
+CONST 
+TYPE 
+	Name = ARRAY 32 OF CHAR; 
+
+	Command = RECORD 
+		name: Name; 
+		offset: LONGINT; 
+	END; 
+
+	Module = POINTER TO RECORD 
+		name: Name; 
+		key: LONGINT; 
+		dbase, pbase: LONGINT; 
+		size, refcnt: LONGINT; 
+		next: Module; 
+		entries: LONGINT; 
+		entry: ARRAY 256 OF LONGINT; 
+		command: ARRAY 64 OF Command; 
+	END; 
+
+	Linker* = OBJECT 
+	VAR 
+		first, last: Module; 
+		base, heap, descriptorBase, bodyBase: LONGINT; 
+		W: Streams.Writer; 
+		Out: Files.File; 
+		Rout: Files.Writer; 
+		code: ARRAY (256 * 1024) OF LONGINT; 
+		plain, descriptors: BOOLEAN; 
+
+		PROCEDURE ^  & InitLinker*(w: Streams.Writer; plain, descriptors: BOOLEAN); 
+		PROCEDURE ^ SetPos(pos: LONGINT); 
+		PROCEDURE ^ WriteCodeBlock(len, adr: LONGINT); 
+		PROCEDURE ^ Fixup(fixloc, offset, base: LONGINT; VAR entry: ARRAY OF LONGINT); 
+		PROCEDURE ^ FixSelf(fixloc, base: LONGINT); 
+		PROCEDURE ^ ThisMod(VAR modname: ARRAY OF CHAR; VAR success: BOOLEAN): Module; 
+		PROCEDURE ^ Bodies; 
+		PROCEDURE ^ String(VAR str: ARRAY OF CHAR; VAR index: LONGINT); 
+		PROCEDURE ^ ModuleDescriptors; 
+		PROCEDURE ^ AddHeader(fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Begin*(base: LONGINT; fileOut, fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Link*(fileIn: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ End*; 
+	END Linker; 
+VAR 
+	log: Streams.Writer; 
+
+	PROCEDURE ^ Branch(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BranchLink(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BodyBranch(m: Module; pc: LONGINT): LONGINT; 
+	PROCEDURE ^ ThisFile(name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ DoLink(linker: Linker; addHeaderFile: BOOLEAN; context: Commands.Context); 
+	PROCEDURE ^ Link*(context: Commands.Context); 
+	PROCEDURE ^ SetLog*(Log: Streams.Writer); 
+BEGIN
+END MinosLinker.

Linux32/bin/OZip.SymU

@@ -0,0 +1,14 @@
+MODULE OZip;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, Huffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001455); 
+	Suffix = \".oz"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip.

Linux32/bin/OZip2.SymU

@@ -0,0 +1,14 @@
+MODULE OZip2;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, AH := AdaptiveHuffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001432); 
+	Suffix = \".oz2"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip2.

Linux32/bin/PersistentObjects.SymU

@@ -0,0 +1,260 @@
+MODULE PersistentObjects;
+	IMPORT XML, XMLParser, XMLScanner, Basic := FoxBasic, Strings, StringPool, Streams, Commands, FoxBasic, Files, XMLObjects, Modules, D := Debugging;
+CONST 
+	Persistent = 0; 
+	None* =  -1; 
+	EnableTrace = FALSE; 
+TYPE 
+	Translation* = OBJECT 
+	TYPE 
+		Entry = RECORD 
+			name: ARRAY 32 OF CHAR; 
+			key: LONGINT; 
+		END; 
+
+		Table = POINTER TO ARRAY OF Entry; 
+	VAR 
+		table: Table; 
+		len: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Grow; 
+		PROCEDURE ^ Add*(CONST name: ARRAY OF CHAR; key: LONGINT); 
+		PROCEDURE ^ Key*(CONST name: ARRAY OF CHAR; VAR key: LONGINT): BOOLEAN; 
+		PROCEDURE ^ Name*(index: SIZE; VAR name: ARRAY OF CHAR): BOOLEAN; 
+	END Translation; 
+
+	Action* = PROCEDURE {DELEGATE}(o: Object); 
+
+	Class* = ENUM Char* = 0, Object* = 1, String* = 2, Integer* = 3, Float* = 4, Boolean* = 5, Enum* = 6, Name* = 7, Range* = 8, Set* = 9 END; 
+
+	Name = ARRAY 128 OF CHAR; 
+
+	Content* = OBJECT 
+	VAR 
+		class*: Class; 
+		name*, type*: Name; 
+		string*: Strings.String; 
+		persistent*: BOOLEAN; 
+		object*: Object; 
+		char*: CHAR; 
+		integer*: HUGEINT; 
+		float*: LONGREAL; 
+		boolean*: BOOLEAN; 
+		translation*: Translation; 
+		range*: RANGE; 
+		set*: SET; 
+		success*: BOOLEAN; 
+
+		PROCEDURE ^ SetClass*(class: Class; persistent: BOOLEAN); 
+		PROCEDURE ^ GetChar*(VAR char: CHAR); 
+		PROCEDURE ^ SetChar*(char: CHAR); 
+		PROCEDURE ^ GetString*(VAR string: Strings.String); 
+		PROCEDURE ^ SetString*(string: Strings.String); 
+		PROCEDURE ^ SetAsString*(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Equals*(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetName*(VAR name: ARRAY OF CHAR); 
+		PROCEDURE ^ SetName*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ GetInteger*(VAR integer: HUGEINT); 
+		PROCEDURE ^ SetInteger*(integer: SIZE); 
+		PROCEDURE ^ GetSet*(VAR set: SET); 
+		PROCEDURE ^ SetSet*(set: SET); 
+		PROCEDURE ^ GetEnum*(translation: Translation; VAR integer: HUGEINT); 
+		PROCEDURE ^ SetEnum*(translation: Translation; integer: HUGEINT); 
+		PROCEDURE ^ GetRange*(VAR range: RANGE); 
+		PROCEDURE ^ SetRange*(CONST range: RANGE); 
+		PROCEDURE ^ GetFloat*(VAR float: LONGREAL); 
+		PROCEDURE ^ SetFloat*(float: LONGREAL); 
+		PROCEDURE ^ GetBoolean*(VAR boolean: BOOLEAN); 
+		PROCEDURE ^ SetBoolean*(boolean: BOOLEAN); 
+		PROCEDURE ^ GetObject*(VAR object: Object); 
+		PROCEDURE ^ SetObject*(object: Object; CONST optionalType: ARRAY OF CHAR); 
+	END Content; 
+
+	Enumerator* = PROCEDURE {DELEGATE}(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+
+	Interpretation* = POINTER TO RECORD 
+		name-, str-: Strings.String; 
+		next-: Interpretation; 
+	END; 
+
+	Object* = OBJECT 
+	CONST 
+		StrType = \"type"\; 
+	VAR 
+		reader: Reader; 
+		writer: Writer; 
+		content: Content; 
+		action: Action; 
+		firstTranslation-: Interpretation; 
+		type*: ARRAY 64 OF CHAR; 
+
+		PROCEDURE ^  & InitObject*; 
+		PROCEDURE ^ ActionEnumerator(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ AddTranslation*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ FindTranslation*(CONST name: ARRAY OF CHAR; VAR translation: Interpretation): BOOLEAN; 
+		PROCEDURE ^ RemoveTranslation*(CONST name: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ ReadContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ WriteContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Write*(w: Writer); 
+		PROCEDURE ^ Read*(r: Reader): BOOLEAN; 
+		PROCEDURE ^ Dump*(log: Streams.Writer; CONST name: ARRAY OF CHAR); 
+	END Object; 
+
+	ObjectList* = OBJECT (Object)
+	VAR 
+		list*: FoxBasic.List; 
+		baseType*: Name; 
+
+		PROCEDURE ^  & InitList*(initialSize: LONGINT; CONST baseType: ARRAY OF CHAR); 
+		PROCEDURE ^ Length*(): LONGINT; 
+		PROCEDURE ^ GetElement*(i: LONGINT): Object; 
+		PROCEDURE ^ SetElement*(i: LONGINT; o: Object); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Add*(o: Object); 
+		PROCEDURE ^ Contains*(o: Object): BOOLEAN; 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ IndexOf*(o: Object): LONGINT; 
+	END ObjectList; 
+
+	Generator = PROCEDURE {DELEGATE}(CONST type: ARRAY OF CHAR):Object; 
+
+	Reader* = OBJECT 
+	VAR 
+		generator: Generator; 
+		error: Streams.Writer; 
+		err-: BOOLEAN; 
+		filename*: Files.FileName; 
+
+		PROCEDURE ^  & InitReader(gen: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ NeedsTranslation(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ AttributeNeedingTranslation*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ NameAttribute*(CONST name: ARRAY OF CHAR; VAR str: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; VAR value: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; VAR value: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; VAR value: RANGE): BOOLEAN; 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; VAR set: SET): BOOLEAN; 
+	END Reader; 
+
+	Writer* = OBJECT 
+
+		PROCEDURE ^  & InitWriter*; 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+		PROCEDURE ^ StartObjectArray*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; value: HUGEINT); 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; value: LONGREAL); 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; value: BOOLEAN); 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; value: HUGEINT); 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; value: RANGE); 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; value: SET); 
+	END Writer; 
+
+	WrittenTable = OBJECT (Basic.HashTable)
+	TYPE 
+		ObjectId = POINTER TO RECORD 
+			num: LONGINT; 
+		END; 
+	VAR 
+		length: LONGINT; 
+
+		PROCEDURE ^ Enter(o: Object; VAR entry: LONGINT): BOOLEAN; 
+	END WrittenTable; 
+
+	XMLWriter* = OBJECT (Writer)
+	VAR 
+		w: Streams.Writer; 
+		document-: XML.Document; 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		written: WrittenTable; 
+
+		PROCEDURE ^  & InitXMLWriter*(writer: Streams.Writer); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; o: Object); 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+	END XMLWriter; 
+
+	ReadTable = OBJECT (Basic.List)
+
+		PROCEDURE ^ Enter(o: Object); 
+		PROCEDURE ^ GetObject(index: HUGEINT): Object; 
+	END ReadTable; 
+
+	Element = POINTER TO RECORD 
+		index: LONGINT; 
+		e: XML.Element; 
+		next: Element; 
+	END; 
+
+	Symbol = POINTER TO RECORD 
+		name: LONGINT; 
+		first, last: Element; 
+		numberElements: LONGINT; 
+		next: Symbol; 
+	END; 
+
+	Stack = POINTER TO RECORD 
+		container: XML.Container; 
+		symbols: Basic.HashTableInt; 
+		firstSymbol: Symbol; 
+		used: Basic.HashTable; 
+		next: Stack; 
+	END; 
+
+	Scope = OBJECT 
+	VAR 
+		stack: Stack; 
+
+		PROCEDURE ^  & InitScope(c: XML.Container); 
+		PROCEDURE ^ Enter(c: XML.Container); 
+		PROCEDURE ^ Register(c: XML.Container); 
+		PROCEDURE ^ Exit(VAR c: XML.Container); 
+		PROCEDURE ^ Use(o: ANY); 
+		PROCEDURE ^ Used(o: ANY): BOOLEAN; 
+		PROCEDURE ^ AddSymbol(CONST name: ARRAY OF CHAR): Symbol; 
+		PROCEDURE ^ FindElement(CONST name: ARRAY OF CHAR; index: LONGINT): XML.Element; 
+		PROCEDURE ^ PutElement(symbol: Symbol; element: Element); 
+		PROCEDURE ^ EnterElement(e: XML.Element); 
+		PROCEDURE ^ Write(w: Streams.Writer); 
+	END Scope; 
+
+	XMLReader* = OBJECT (Reader)
+	VAR 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		read: ReadTable; 
+
+		PROCEDURE ^ ReportXMLError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^  & InitXMLReader*(reader: Streams.Reader; generator: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ CheckUse(o: ANY); 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+	END XMLReader; 
+
+	PROCEDURE ^ NewXMLWriter*(w: Streams.Writer): Writer; 
+	PROCEDURE ^ NewXMLReader*(r: Streams.Reader; generator: Generator): Reader; 
+	PROCEDURE ^ Clone*(o: Object; gen: Generator): Object; 
+	PROCEDURE ^ Trace*(o: Object); 
+BEGIN
+END PersistentObjects.

Linux32/bin/PrecisionTimer.SymU

@@ -0,0 +1,31 @@
+MODULE PrecisionTimer;
+	IMPORT Unix, KernelLog;
+CONST 
+	CLOCK_REALTIME = 0; 
+	CLOCK_MONOTONIC = 1; 
+	CLOCK_PROCESS_CPUTIME_ID = 2; 
+	CLOCK_THREAD_CPUTIME_ID = 3; 
+	CLOCK_MONOTONIC_RAW = 4; 
+	CLOCK_REALTIME_COARSE = 5; 
+	CLOCK_MONOTONIC_COARSE = 6; 
+	CLOCK_BOOTTIME = 7; 
+	CLOCK_REALTIME_ALARM = 8; 
+	CLOCK_BOOTTIME_ALARM = 9; 
+TYPE 
+	Counter* = HUGEINT; 
+
+	Timespec = RECORD 
+		sec: LONGWORD; 
+		nsec: LONGINT; 
+	END; 
+VAR 
+	clock_gettime: PROCEDURE {C}(clk_id: LONGINT; CONST tp: Timespec):LONGINT; 
+	clock_getres: PROCEDURE {C}(clk_id: LONGINT; CONST res: Timespec):LONGINT; 
+	clockType := CLOCK_MONOTONIC: LONGINT; 
+	frequency: Counter; 
+
+	PROCEDURE ^ GetCounter*(): Counter; 
+	PROCEDURE ^ GetFrequency*(): Counter; 
+	PROCEDURE ^ InitMod; 
+BEGIN
+END PrecisionTimer.

Linux32/bin/Sockets.SymU

@@ -2,7 +2,6 @@ MODULE Sockets;
 	IMPORT S := SYSTEM, Unix, Trace, IP;
 CONST 
 	Backlog = 5; 
-	LingerSize = 8; 
 TYPE 
 	SocketAdr* = POINTER TO RECORD 
 		family*: INTEGER; 
@@ -25,20 +24,20 @@ TYPE
 		buf: ARRAY 64 OF CHAR; 
 	END; 
 
-	SocketOption = POINTER TO RECORD 
+	SocketOption = RECORD 
 	END; 
 
-	Linger = POINTER TO RECORD (SocketOption)
+	Linger = RECORD (SocketOption)
 		onoff: LONGINT; 
 		linger: LONGINT; 
 	END; 
 
-	Switch = POINTER TO RECORD (SocketOption)
+	Switch = RECORD (SocketOption)
 		onoff: LONGINT; 
 	END; 
 VAR 
 	socket: PROCEDURE {C}(af, typ, protocol: LONGINT):LONGINT; 
-	setsockopt: PROCEDURE {C}(s: LONGINT; level, optname: LONGINT; opt: SocketOption; optlen: LONGINT):LONGINT; 
+	setsockopt: PROCEDURE {C}(s: LONGINT; level, optname: LONGINT; VAR opt: SocketOption; optlen: LONGINT):LONGINT; 
 	accept: PROCEDURE {C}(s: LONGINT; adrPtr: ADDRESS; VAR adrlen: LONGINT):LONGINT; 
 	bind: PROCEDURE {C}(s: LONGINT; adr: SocketAdr; adrlen: LONGINT):LONGINT; 
 	connect: PROCEDURE {C}(s: LONGINT; adr: SocketAdr; adrlen: LONGINT):LONGINT; 

Linux32/bin/WMProfiler.SymU

@@ -0,0 +1,48 @@
+MODULE WMProfiler;
+	IMPORT Modules, Kernel, Strings, HierarchicalProfiler, WMGraphics, WMMessages, WMRestorable, WMWindowManager, WMComponents, WMStandardComponents, WMEditors, WMTrees, WMErrors, WMProgressComponents;
+CONST 
+	DefaultTime = 30; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		startBtn, stopBtn, continueBtn, getProfileBtn, flattenBtn, filterBtn: WMStandardComponents.Button; 
+		timeEdit, typeEdit, infoEdit, filterMaskEdit, filterCountEdit: WMEditors.Editor; 
+		tree: WMTrees.Tree; 
+		treeView: WMTrees.TreeView; 
+		lastSelectedNode: HierarchicalProfiler.Node; 
+		lastState: LONGINT; 
+		statusLabel: WMStandardComponents.Label; 
+		progressBar: WMProgressComponents.ProgressBar; 
+		profile: HierarchicalProfiler.Profile; 
+		alive, dead: BOOLEAN; 
+		timer: Kernel.Timer; 
+
+		PROCEDURE ^ HasVisibleChildren(node: HierarchicalProfiler.Node): BOOLEAN; 
+		PROCEDURE ^ AddChildNodes(parent: WMTrees.TreeNode; node: HierarchicalProfiler.Node; expand: BOOLEAN); 
+		PROCEDURE ^ ClearExternField(node: HierarchicalProfiler.Node); 
+		PROCEDURE ^ UpdateTree; 
+		PROCEDURE ^ UpdateStatusBar(forceUpdate: BOOLEAN); 
+		PROCEDURE ^ HandleNodeClicked(sender, data: ANY); 
+		PROCEDURE ^ HandleNodeSelected(sender, data: ANY); 
+		PROCEDURE ^ GetTypeAndInfo(VAR type, info: LONGINT); 
+		PROCEDURE ^ GetFilterMask(VAR mask: ARRAY OF CHAR; VAR minPercent: LONGINT); 
+		PROCEDURE ^ HandleButtons(sender, data: ANY); 
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^  & New*(context: WMRestorable.Context); 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ Close*; 
+	BEGIN{ACTIVE} 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Restore*(context: WMRestorable.Context); 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END WMProfiler.

Linux64/bin/AdaptiveHuffman.SymUu

@@ -0,0 +1,81 @@
+MODULE AdaptiveHuffman;
+	IMPORT Streams;
+CONST 
+	AlphabetSize = 256; 
+	BlockSize* = (8 * 1024); 
+	ScaleLimit = (4 * 1024); 
+	Encode = 0; 
+	Decode = 1; 
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	HuffmanCoder = OBJECT 
+	TYPE 
+		Index = INTEGER; 
+
+		Pattern = INTEGER; 
+
+		Node = RECORD 
+			weight: INTEGER; 
+			pattern: Pattern; 
+			up: Index; 
+			down: Index; 
+		END; 
+	VAR 
+		mode: SHORTINT; 
+		in: BitReader; 
+		out: BitWriter; 
+		esc: Index; 
+		root: Index; 
+		map: ARRAY AlphabetSize OF Index; 
+		table: ARRAY ((2 * AlphabetSize) + 2) OF Node; 
+
+		PROCEDURE ^  & New(m: SHORTINT; input: Streams.Reader; output: Streams.Writer); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Finish; 
+		PROCEDURE ^ GetPattern(): Pattern; 
+		PROCEDURE ^ PutPattern(patt: Pattern); 
+		PROCEDURE ^ AddPattern(patt: Pattern): Index; 
+		PROCEDURE ^ GroupLeader(node: Index): Index; 
+		PROCEDURE ^ SlideNode(node: Index): Index; 
+		PROCEDURE ^ IncrementWeight(node: Index); 
+		PROCEDURE ^ Scale; 
+		PROCEDURE ^ EncodeByte(ch: CHAR); 
+		PROCEDURE ^ ExtractByte(): CHAR; 
+	END HuffmanCoder; 
+
+	Encoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Writer); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Reader); 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+BEGIN
+END AdaptiveHuffman.

Linux64/bin/BorrowsWheeler.SymUu

@@ -0,0 +1,57 @@
+MODULE BorrowsWheeler;
+CONST 
+	BlockSize* = (8 * 1024); 
+TYPE 
+	MTF = OBJECT 
+	TYPE 
+		Node = POINTER TO RECORD 
+			byte: CHAR; 
+			next: Node; 
+		END; 
+	VAR 
+		alpha: Node; 
+
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Encode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+		PROCEDURE ^ Decode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END MTF; 
+
+	Encoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		length: LONGINT; 
+		sbuf: ARRAY (2 * BlockSize) OF CHAR; 
+		rotation: ARRAY BlockSize OF Index; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ Less(a, b: Index): BOOLEAN; 
+		PROCEDURE ^ Swap(a, b: Index); 
+		PROCEDURE ^ InsertSort(lo, hi: Index); 
+		PROCEDURE ^ SortR(lo, hi: LONGINT); 
+		PROCEDURE ^ EncodeBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT): LONGINT; 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		f, l: ARRAY BlockSize OF CHAR; 
+		lc, fc: ARRAY BlockSize OF INTEGER; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE  - Swap(a, b: Index);
+		VAR 
+			tmp: CHAR; 
+		BEGIN
+			tmp := f[a]; 
+			f[a] := f[b]; 
+			f[b] := tmp
+		END Swap; 
+		PROCEDURE ^ SortF(lo, hi: Index); 
+		PROCEDURE ^ DecodeBlock*(VAR buf: ARRAY OF CHAR; len, index: LONGINT); 
+	END Decoder; 
+BEGIN
+END BorrowsWheeler.

Linux64/bin/DNS.SymUu

@@ -8,8 +8,8 @@ CONST
 TYPE 
 	Name* = ARRAY 128 OF CHAR; 
 
-	Hostent = POINTER TO RECORD 
-		name: ADDRESS; 
+	Hostent = POINTER {UNSAFE, UNTRACED} TO RECORD 
+		name: POINTER {UNSAFE, UNTRACED} TO Name; 
 		aliases: ADDRESS; 
 		addrtype: LONGINT; 
 		length: LONGINT; 

Linux64/bin/FoxInterpreter.SymUu

@@ -0,0 +1,205 @@
+MODULE FoxInterpreter;
+	IMPORT Scanner := FoxScanner, FoxParser, SyntaxTree := FoxSyntaxTree, Printout := FoxPrintout, Commands, Diagnostics, StringPool, InterpreterSymbols := FoxInterpreterSymbols, D := Debugging, Strings, Streams, Modules, PersistentObjects, Basic := FoxBasic, SYSTEM, Machine, Global := FoxGlobal, Heaps;
+CONST 
+	EnableTrace = FALSE; 
+	MaxIndex = 8; 
+TYPE 
+	Result* = InterpreterSymbols.Result; 
+
+	Value* = InterpreterSymbols.Value; 
+
+	Integer* = InterpreterSymbols.IntegerValue; 
+
+	Real* = InterpreterSymbols.RealValue; 
+
+	String* = InterpreterSymbols.StringValue; 
+
+	Boolean* = InterpreterSymbols.BooleanValue; 
+
+	Set* = InterpreterSymbols.SetValue; 
+
+	Range* = InterpreterSymbols.RangeValue; 
+
+	Char* = InterpreterSymbols.CharValue; 
+
+	Any* = InterpreterSymbols.AnyValue; 
+
+	MathArrayValue* = InterpreterSymbols.MathArrayValue; 
+
+	Scope* = InterpreterSymbols.Scope; 
+
+	Container* = InterpreterSymbols.Container; 
+
+	Builtin* = OBJECT (InterpreterSymbols.Object)
+	VAR 
+		id: LONGINT; 
+	END Builtin; 
+
+	Item* = RECORD 
+		object*: InterpreterSymbols.Item; 
+		in*: InterpreterSymbols.Item; 
+		name*: StringPool.Index; 
+		i*: ARRAY MaxIndex OF LONGINT; 
+	END; 
+
+	CommandStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		command: Strings.String; 
+
+		PROCEDURE ^  & InitCommandStatement(s: Strings.String); 
+	END CommandStatement; 
+
+	PrintStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		expression: SyntaxTree.Expression; 
+
+		PROCEDURE ^  & InitPrintStatement(e: SyntaxTree.Expression); 
+	END PrintStatement; 
+
+	Parser* = OBJECT (FoxParser.Parser)
+
+		PROCEDURE ^ Statement*(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement): BOOLEAN; 
+		PROCEDURE ^ Cmd(): SyntaxTree.Statement; 
+		PROCEDURE ^ Print(): SyntaxTree.Statement; 
+	END Parser; 
+
+	Interpreter* = OBJECT (SyntaxTree.Visitor)
+	VAR 
+		value: BOOLEAN; 
+		item-: Item; 
+		module-: Modules.Module; 
+		typeDesc-: Modules.TypeDesc; 
+		scope-: Scope; 
+		exit: BOOLEAN; 
+		error-: BOOLEAN; 
+		diagnostics: Diagnostics.Diagnostics; 
+		context-: Commands.Context; 
+
+		PROCEDURE ^  & Init*(scope: Scope; diagnostics: Diagnostics.Diagnostics; context: Commands.Context); 
+		PROCEDURE ^ SetScope*(s: Scope); 
+		PROCEDURE ^ Reset*; 
+		PROCEDURE ^ Error(CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ErrorSS(CONST msg: ARRAY OF CHAR; id: StringPool.Index); 
+		PROCEDURE ^ VisitSet*(x: SyntaxTree.Set); 
+		PROCEDURE ^ VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression); 
+		PROCEDURE ^ NewInt(i: HUGEINT); 
+		PROCEDURE ^ NewReal(i: LONGREAL); 
+		PROCEDURE ^ NewBool(b: BOOLEAN); 
+		PROCEDURE ^ NewSet(s: SET); 
+		PROCEDURE ^ NewString(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ NewRange(r: RANGE); 
+		PROCEDURE ^ NewChar(c: CHAR); 
+		PROCEDURE ^ VisitUnaryExpression*(x: SyntaxTree.UnaryExpression); 
+		PROCEDURE ^ VisitBinaryExpression*(x: SyntaxTree.BinaryExpression); 
+		PROCEDURE ^ VisitRangeExpression*(x: SyntaxTree.RangeExpression); 
+		PROCEDURE ^ VisitTensorRangeExpression*(x: SyntaxTree.TensorRangeExpression); 
+		PROCEDURE ^ VisitConversion*(x: SyntaxTree.Conversion); 
+		PROCEDURE ^ VisitDesignator*(x: SyntaxTree.Designator); 
+		PROCEDURE ^ VisitQualifiedType*(x: SyntaxTree.QualifiedType); 
+		PROCEDURE ^ VisitIdentifierDesignator*(x: SyntaxTree.IdentifierDesignator); 
+		PROCEDURE ^ VisitSelectorDesignator*(x: SyntaxTree.SelectorDesignator); 
+		PROCEDURE ^ VisitParameterDesignator*(x: SyntaxTree.ParameterDesignator); 
+		PROCEDURE ^ VisitArrowDesignator*(x: SyntaxTree.ArrowDesignator); 
+		PROCEDURE ^ VisitBracketDesignator*(x: SyntaxTree.BracketDesignator); 
+		PROCEDURE ^ VisitSymbolDesignator*(x: SyntaxTree.SymbolDesignator); 
+		PROCEDURE ^ VisitIndexDesignator*(x: SyntaxTree.IndexDesignator); 
+		PROCEDURE ^ VisitProcedureCallDesignator*(x: SyntaxTree.ProcedureCallDesignator); 
+		PROCEDURE ^ SystemTrace(x: SyntaxTree.ExpressionList); 
+		PROCEDURE ^ FindType(type: SyntaxTree.Type): Result; 
+		PROCEDURE ^ VisitBuiltinCallDesignator*(x: SyntaxTree.BuiltinCallDesignator); 
+		PROCEDURE ^ VisitTypeGuardDesignator*(x: SyntaxTree.TypeGuardDesignator); 
+		PROCEDURE ^ VisitDereferenceDesignator*(x: SyntaxTree.DereferenceDesignator); 
+		PROCEDURE ^ VisitSupercallDesignator*(x: SyntaxTree.SupercallDesignator); 
+		PROCEDURE ^ VisitSelfDesignator*(x: SyntaxTree.SelfDesignator); 
+		PROCEDURE ^ VisitResultDesignator*(x: SyntaxTree.ResultDesignator); 
+		PROCEDURE ^ VisitValue*(x: SyntaxTree.Value); 
+		PROCEDURE ^ VisitBooleanValue*(x: SyntaxTree.BooleanValue); 
+		PROCEDURE ^ VisitIntegerValue*(x: SyntaxTree.IntegerValue); 
+		PROCEDURE ^ VisitCharacterValue*(x: SyntaxTree.CharacterValue); 
+		PROCEDURE ^ VisitSetValue*(x: SyntaxTree.SetValue); 
+		PROCEDURE ^ VisitMathArrayValue*(x: SyntaxTree.MathArrayValue); 
+		PROCEDURE ^ VisitRealValue*(x: SyntaxTree.RealValue); 
+		PROCEDURE ^ VisitComplexValue*(x: SyntaxTree.ComplexValue); 
+		PROCEDURE ^ VisitStringValue*(x: SyntaxTree.StringValue); 
+		PROCEDURE ^ VisitNilValue*(x: SyntaxTree.NilValue); 
+		PROCEDURE ^ VisitEnumerationValue*(x: SyntaxTree.EnumerationValue); 
+		PROCEDURE ^ VisitSymbol*(x: SyntaxTree.Symbol); 
+		PROCEDURE ^ VisitTypeDeclaration*(x: SyntaxTree.TypeDeclaration); 
+		PROCEDURE ^ VisitConstant*(x: SyntaxTree.Constant); 
+		PROCEDURE ^ VisitVariable*(x: SyntaxTree.Variable); 
+		PROCEDURE ^ VisitParameter*(x: SyntaxTree.Parameter); 
+		PROCEDURE ^ VisitProcedure*(x: SyntaxTree.Procedure); 
+		PROCEDURE ^ VisitBuiltin*(x: SyntaxTree.Builtin); 
+		PROCEDURE ^ VisitOperator*(x: SyntaxTree.Operator); 
+		PROCEDURE ^ VisitImport*(x: SyntaxTree.Import); 
+		PROCEDURE ^ TranslateString*(cmd: CHAR; CONST str: ARRAY OF CHAR; VAR dest: Strings.String): BOOLEAN; 
+		PROCEDURE ^ VisitCommandStatement(x: CommandStatement); 
+		PROCEDURE ^ VisitPrintStatement(x: PrintStatement); 
+		PROCEDURE ^ VisitStatement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ VisitProcedureCallStatement*(x: SyntaxTree.ProcedureCallStatement); 
+		PROCEDURE ^ LoadValue; 
+		PROCEDURE ^ GetValue*(x: SyntaxTree.Expression; VAR w: Value): BOOLEAN; 
+		PROCEDURE ^ Designate(x: SyntaxTree.Expression): Result; 
+		PROCEDURE ^ Evaluate(x: SyntaxTree.Expression): Value; 
+		PROCEDURE ^ GetInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ ExpectInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ GetBoolean(x: SyntaxTree.Expression; VAR i: Boolean): BOOLEAN; 
+		PROCEDURE ^ ExpectBoolean(x: SyntaxTree.Expression; VAR b: Boolean): BOOLEAN; 
+		PROCEDURE ^ PutValue(x: SyntaxTree.Designator; v: Value); 
+		PROCEDURE ^ VisitAssignment*(x: SyntaxTree.Assignment); 
+		PROCEDURE ^ IfPart(ifPart: SyntaxTree.IfPart): BOOLEAN; 
+		PROCEDURE ^ VisitIfStatement*(x: SyntaxTree.IfStatement); 
+		PROCEDURE ^ VisitWithStatement*(x: SyntaxTree.WithStatement); 
+		PROCEDURE ^ CasePart(x: SyntaxTree.CasePart; b: SyntaxTree.BinaryExpression): BOOLEAN; 
+		PROCEDURE ^ VisitCaseStatement*(x: SyntaxTree.CaseStatement); 
+		PROCEDURE ^ VisitWhileStatement*(x: SyntaxTree.WhileStatement); 
+		PROCEDURE ^ VisitRepeatStatement*(x: SyntaxTree.RepeatStatement); 
+		PROCEDURE ^ VisitForStatement*(x: SyntaxTree.ForStatement); 
+		PROCEDURE ^ VisitLoopStatement*(x: SyntaxTree.LoopStatement); 
+		PROCEDURE ^ VisitExitStatement*(x: SyntaxTree.ExitStatement); 
+		PROCEDURE ^ VisitReturnStatement*(x: SyntaxTree.ReturnStatement); 
+		PROCEDURE ^ VisitAwaitStatement*(x: SyntaxTree.AwaitStatement); 
+		PROCEDURE ^ VisitStatementBlock*(x: SyntaxTree.StatementBlock); 
+		PROCEDURE ^ VisitCode*(x: SyntaxTree.Code); 
+		PROCEDURE ^ Expression(x: SyntaxTree.Expression); 
+		PROCEDURE ^ Statement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ StatementSequence*(x: SyntaxTree.StatementSequence); 
+	END Interpreter; 
+
+	Resolver* = OBJECT 
+	VAR 
+		interpreter: Interpreter; 
+		content: PersistentObjects.Content; 
+		resolved: Basic.HashTable; 
+		current: Scope; 
+		changed: BOOLEAN; 
+
+		PROCEDURE ^  & InitResolver*; 
+		PROCEDURE ^ Traverse(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ DoResolve*(scope: Scope); 
+		PROCEDURE ^ Resolve*(scope: Scope); 
+	END Resolver; 
+
+	TestO = OBJECT 
+	VAR 
+		i: LONGINT; 
+
+		PROCEDURE ^  & P(s: SHORTINT); 
+	END TestO; 
+
+	; 
+VAR 
+	global-: Scope; 
+	c: LONGINT; 
+	d: RECORD 
+		e: LONGINT; 
+	END; 
+
+	PROCEDURE ^ Statements*(context: Commands.Context); 
+	PROCEDURE ^ Expression*(context: Commands.Context); 
+	PROCEDURE ^ TranslateString*(context: Commands.Context); 
+	PROCEDURE ^ InitGlobalScope; 
+	PROCEDURE ^ Getter(): LONGINT; 
+	PROCEDURE ^ Setter(a: LONGINT): LONGINT; 
+BEGIN
+END FoxInterpreter.

Linux64/bin/FoxInterpreterSymbols.SymUu

@@ -0,0 +1,351 @@
+MODULE FoxInterpreterSymbols;
+	IMPORT Strings, Basic := FoxBasic, StringPool, Streams, Commands, PersistentObjects, Modules, Machine, SyntaxTree := FoxSyntaxTree, SYSTEM, Reflection;
+CONST 
+	TAB = 9X; 
+	StrValue = \"value"\; 
+TYPE 
+	Item* = PersistentObjects.Object; 
+
+	Object* = PersistentObjects.Object; 
+
+	Content* = PersistentObjects.Content; 
+
+	Name* = ARRAY 128 OF CHAR; 
+
+	Meta* = RECORD 
+		module*: Modules.Module; 
+		refs*: Modules.Bytes; 
+		offset*: SIZE; 
+	END; 
+
+	Result* = OBJECT (Item)
+
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Trace*; 
+	END Result; 
+
+	SymbolResult* = OBJECT (Result)
+	VAR 
+		name: ARRAY 32 OF CHAR; 
+
+		PROCEDURE ^ InitSymbol(CONST n: ARRAY OF CHAR); 
+	END SymbolResult; 
+
+	TypeResult* = OBJECT (SymbolResult)
+	VAR 
+		type-: Meta; 
+		address: ADDRESS; 
+
+		PROCEDURE ^  & InitType(CONST name: ARRAY OF CHAR; t: Meta); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Constructor*(): ProcedureResult; 
+	END TypeResult; 
+
+	ModuleResult* = OBJECT (SymbolResult)
+	VAR 
+		self: Meta; 
+
+		PROCEDURE ^  & InitModule(CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END ModuleResult; 
+
+	Callstack = OBJECT 
+	VAR 
+		data: ARRAY 1024 OF CHAR; 
+		pos: SIZE; 
+		size: SIZE; 
+		H: HUGEINT; 
+		pPos: LONGINT; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Next(s: SIZE): ADDRESS; 
+		PROCEDURE ^ PushH(h: HUGEINT); 
+		PROCEDURE ^ PushL(i: LONGINT); 
+		PROCEDURE ^ PushI(i: INTEGER); 
+		PROCEDURE ^ PushS(i: SHORTINT); 
+		PROCEDURE ^ PushB(b: BOOLEAN); 
+		PROCEDURE ^ PushC(c: CHAR); 
+		PROCEDURE ^ PushSet(set: SET); 
+		PROCEDURE ^ PushR(r: REAL); 
+		PROCEDURE ^ PushX(x: LONGREAL); 
+		PROCEDURE ^ PushA(a: ADDRESS); 
+		PROCEDURE ^ PushSz(s: SIZE); 
+		PROCEDURE ^ Call(adr: ADDRESS); 
+		PROCEDURE ^ CallH(adr: ADDRESS): HUGEINT; 
+		PROCEDURE ^ CallR(adr: ADDRESS): REAL; 
+		PROCEDURE ^ CallX(adr: ADDRESS): LONGREAL; 
+	END Callstack; 
+
+	ProcedureResult* = OBJECT (SymbolResult)
+	VAR 
+		meta: Meta; 
+		address: ADDRESS; 
+		stack: Callstack; 
+		index: LONGINT; 
+		caller-: Result; 
+		parameters: Meta; 
+		flags: SET; 
+
+		PROCEDURE ^ Parameters(): Meta; 
+		PROCEDURE ^ ReturnType(): Meta; 
+		PROCEDURE ^ ReturnsPointer*(): BOOLEAN; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^  & InitProcedure(c: Result; CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Pars*; 
+		PROCEDURE ^ PushAddress*(adr: ADDRESS); 
+		PROCEDURE ^ PushTyped*(o: Result; mode: CHAR; refs: Modules.Bytes; VAR offset: SIZE): BOOLEAN; 
+		PROCEDURE ^ Push*(o: Result): BOOLEAN; 
+		PROCEDURE ^ Check*(): BOOLEAN; 
+		PROCEDURE ^ Evaluate*(): Value; 
+	END ProcedureResult; 
+
+	FieldResult* = OBJECT (SymbolResult)
+	VAR 
+		address: ADDRESS; 
+		meta: Meta; 
+
+		PROCEDURE ^  & InitField(CONST name: ARRAY OF CHAR; meta: Meta; base: ADDRESS); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END FieldResult; 
+
+	Value* = OBJECT (Result)
+
+		PROCEDURE ^  & InitValue; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ GetInt*(VAR h: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ GetChar*(VAR x: CHAR): BOOLEAN; 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ GetString*(VAR w: ARRAY OF CHAR); 
+	END Value; 
+
+	AnyValue* = OBJECT (Value)
+	VAR 
+		value*: ANY; 
+
+		PROCEDURE ^  & InitAny*(value: ANY); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END AnyValue; 
+
+	AddressValue* = OBJECT (Value)
+	VAR 
+		value*: ADDRESS; 
+
+		PROCEDURE ^  & InitAny*(value: ADDRESS); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END AddressValue; 
+
+	IntegerValue* = OBJECT (Value)
+	VAR 
+		value*: HUGEINT; 
+
+		PROCEDURE ^  & InitInteger*(value: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetInt*(VAR v: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END IntegerValue; 
+
+	RealValue* = OBJECT (Value)
+	VAR 
+		value*: LONGREAL; 
+
+		PROCEDURE ^  & InitReal*(value: LONGREAL); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RealValue; 
+
+	BooleanValue* = OBJECT (Value)
+	VAR 
+		value*: BOOLEAN; 
+
+		PROCEDURE ^  & InitBoolean*(value: BOOLEAN); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END BooleanValue; 
+
+	StringValue* = OBJECT (Value)
+	VAR 
+		value*: Strings.String; 
+
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END StringValue; 
+
+	SetValue* = OBJECT (Value)
+	VAR 
+		value*: SET; 
+
+		PROCEDURE ^  & InitSet*(value: SET); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END SetValue; 
+
+	RangeValue* = OBJECT (Value)
+	VAR 
+		value*: RANGE; 
+
+		PROCEDURE ^  & InitRange*(r: RANGE); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RangeValue; 
+
+	CharValue* = OBJECT (Value)
+	VAR 
+		value: CHAR; 
+
+		PROCEDURE ^  & InitChar*(c: CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetChar*(VAR c: CHAR): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END CharValue; 
+
+	EnumValue* = OBJECT (Value)
+	VAR 
+		value: HUGEINT; 
+		translation: PersistentObjects.Translation; 
+
+		PROCEDURE ^  & InitEnumValue*(trans: PersistentObjects.Translation; v: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END EnumValue; 
+
+	MathArrayValue* = OBJECT (Value)
+	VAR 
+		values: ARRAY [*] OF Value; 
+
+		PROCEDURE ^  & InitMathArrayValue*(len: LONGINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ SetValue*(at: LONGINT; value: Value); 
+		PROCEDURE ^ GetValue*(at: LONGINT): Value; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+	END MathArrayValue; 
+
+	Symbol* = OBJECT 
+	VAR 
+		name: StringPool.Index; 
+		item-: Item; 
+
+		PROCEDURE ^  & InitSymbol(name: StringPool.Index; index: LONGINT); 
+		PROCEDURE ^ GetName(VAR name: ARRAY OF CHAR); 
+	END Symbol; 
+
+	Container* = OBJECT (Item)
+	VAR 
+		symbols-: Basic.List; 
+		lookup-: Basic.HashTableInt; 
+
+		PROCEDURE ^  & InitContainer*; 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetItem*(index: LONGINT): Item; 
+		PROCEDURE ^ Enter1*(item: Item; name: StringPool.Index); 
+		PROCEDURE ^ Enter*(item: Item; CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ Find1*(id: LONGINT): Item; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Item; 
+	END Container; 
+
+	Scope* = OBJECT 
+	VAR 
+		outer-: Scope; 
+		object-: Object; 
+		level: LONGINT; 
+
+		PROCEDURE ^  & InitScope*(outer: Scope; object: Object); 
+		PROCEDURE ^ Enter*(object: Object): Scope; 
+		PROCEDURE ^ FindObject*(CONST name: ARRAY OF CHAR; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ FindObject1*(name: StringPool.Index; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ Leave*(): Scope; 
+		PROCEDURE ^ Dump*(log: Streams.Writer); 
+	END Scope; 
+
+	ObjectFilter* = OBJECT 
+	VAR 
+		content: Content; 
+		object: Object; 
+		found: Container; 
+		attribute, value: ARRAY 256 OF CHAR; 
+
+		PROCEDURE ^  & InitObjectFilter*; 
+		PROCEDURE ^ AddFiltered(obj: Object); 
+		PROCEDURE ^ Enumerate(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Filter*(obj: Object; attribute, value: ARRAY OF CHAR): Container; 
+	END ObjectFilter; 
+
+	PROCEDURE ^ FindSymbol*(CONST name: ARRAY OF CHAR; meta: Meta): Meta; 
+	PROCEDURE ^ SymbolKind*(meta: Meta): CHAR; 
+	PROCEDURE ^ SymbolParent*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolName*(meta: Meta; VAR name: ARRAY OF CHAR); 
+	PROCEDURE ^ VariableMode*(meta: Meta): Meta; 
+	PROCEDURE ^ VariableType*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolAddress*(meta: Meta; base: ADDRESS): ADDRESS; 
+	PROCEDURE ^ FindInType(scope: Result; address: ADDRESS; type: ADDRESS; CONST name: ARRAY OF CHAR): Result; 
+	PROCEDURE ^ FindConstructor(scope: Result; type: ADDRESS): ProcedureResult; 
+	PROCEDURE ^ Indent(w: Streams.Writer; level: LONGINT); 
+	PROCEDURE ^ Test*(context: Commands.Context); 
+	PROCEDURE ^ ContentGetValue(c: Content): Value; 
+	PROCEDURE ^ NewIntegerValue(value: HUGEINT): IntegerValue; 
+	PROCEDURE ^ NewFloatValue(value: LONGREAL): RealValue; 
+	PROCEDURE ^ NewBooleanValue(value: BOOLEAN): BooleanValue; 
+	PROCEDURE ^ NewStringValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewNameValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewRangeValue(value: RANGE): RangeValue; 
+	PROCEDURE ^ NewCharValue(value: CHAR): CharValue; 
+	PROCEDURE ^ NewSetValue(value: SET): SetValue; 
+	PROCEDURE ^ NewEnumValue(translation: PersistentObjects.Translation; value: HUGEINT): EnumValue; 
+	PROCEDURE ^ FindInObject*(in: Object; CONST name: ARRAY OF CHAR; index: LONGINT): Object; 
+	PROCEDURE ^ GetModule*(CONST name: ARRAY OF CHAR): ModuleResult; 
+	PROCEDURE ^ FindInObject1*(in: Object; name: StringPool.Index; index: LONGINT): Object; 
+BEGIN
+END FoxInterpreterSymbols.

Linux64/bin/HierarchicalProfiler.SymUu

@@ -0,0 +1,111 @@
+MODULE HierarchicalProfiler;
+	IMPORT SYSTEM, Machine, Streams, Modules, Objects, Kernel, Reflection, Commands, Options, Strings, Errors, HierarchicalProfiler0;
+CONST 
+	Ok* = 0; 
+	AlreadyRunning* = 5101; 
+	NotRunning* = 5102; 
+	NoProfileDataAvailable* = 5103; 
+	SampleBufferFull* = 5104; 
+	SampleBufferNotInitialized* = 5105; 
+	Hierarchical* = 0; 
+	Flat* = 1; 
+	None* = 0; 
+	Threads* = 1; 
+	Processors* = 2; 
+	ThreadsProcessors* = 3; 
+	ProcessorsThreads* = 4; 
+	NotRunningNoDataAvailable* = 0; 
+	NotRunningDataAvailable* = 1; 
+	Running* = 2; 
+	DefaultMaxTime = 30; 
+	MaxUnwindingDepth = 64; 
+	Invalid = 0; 
+TYPE 
+	Name = ARRAY 256 OF CHAR; 
+
+	Sample = ARRAY MaxUnwindingDepth OF ADDRESS; 
+
+	Samples = POINTER TO ARRAY OF Sample; 
+
+	SampleInfo = RECORD 
+		processorID: LONGINT; 
+		process: Objects.Process; 
+	END; 
+
+	SampleInfos = POINTER TO ARRAY OF SampleInfo; 
+
+	Node* = OBJECT 
+	VAR 
+		parent-: Node; 
+		child-: Node; 
+		sibling-: Node; 
+		count-: LONGINT; 
+		percent-: REAL; 
+		nofChildren-: LONGINT; 
+		name-: Name; 
+		extern*: BOOLEAN; 
+		marked*: BOOLEAN; 
+		next: Node; 
+
+		PROCEDURE ^ GetCaption*(): Strings.String; 
+		PROCEDURE ^ Show(out: Streams.Writer; indent: LONGINT); 
+		PROCEDURE ^  & Init*; 
+	END Node; 
+
+	VisitorProcedure* = PROCEDURE {DELEGATE}(node: Node); 
+
+	Profile* = OBJECT {EXCLUSIVE} 
+	VAR 
+		nodes-: Node; 
+		nofSamples-: LONGINT; 
+		nofProcessors-: LONGINT; 
+		nofRunsTooDeep-: LONGINT; 
+		nofUnwindingFaults-: LONGINT; 
+		nofSamplesNotStored-: LONGINT; 
+		pattern: ARRAY 64 OF CHAR; 
+		minPercent: LONGINT; 
+
+		PROCEDURE ^ FindNode(CONST name: Name; list: Node): Node; 
+		PROCEDURE ^ MergeNode(newNode, parent: Node); 
+		PROCEDURE ^ Flatten*(parent: Node); 
+		PROCEDURE ^ VisitorClearMark(node: Node); 
+		PROCEDURE ^ Mark*(CONST pattern: ARRAY OF CHAR; minPercent: LONGINT); 
+		PROCEDURE ^ VisitorSetMark(node: Node); 
+		PROCEDURE ^ VisitNodes(node: Node; visitorProc: VisitorProcedure); 
+		PROCEDURE ^ Visit*(visitorProc: VisitorProcedure); 
+		PROCEDURE ^  & Init*; 
+	END Profile; 
+VAR 
+	samples: Samples; 
+	sampleInfos: SampleInfos; 
+	maxNofSamples: LONGINT; 
+	nofRunsTooDeep: LONGINT; 
+	nofUnwindingFaults: LONGINT; 
+	nofSamplesNotStored: LONGINT; 
+	nofSamples: LONGINT; 
+	currentIndex: LONGINT; 
+	locked: BOOLEAN; 
+	state: LONGINT; 
+
+	PROCEDURE ^ FindChildNode(CONST name: Name; parent: Node): Node; 
+	PROCEDURE ^ MergeChildNode(CONST procedureName: ARRAY OF CHAR; parent: Node): Node; 
+	PROCEDURE ^ AddSample(profile: Node; type, info: LONGINT; CONST sampleInfo: SampleInfo; CONST sample: Sample); 
+	PROCEDURE ^ HandleTimer(id: LONGINT; process: Objects.Process; pc, bp, lowAdr, highAdr: ADDRESS); 
+	PROCEDURE ^ InvalidateSample(VAR sample: Sample); 
+	PROCEDURE ^ SortChildren(parent: Node); 
+	PROCEDURE ^ PostProcessNode(profile: Profile; node: Node); 
+	PROCEDURE ^ PostProcessProfile(profile: Profile); 
+	PROCEDURE ^ CreateProfile(type: LONGINT; info: LONGINT): Profile; 
+	PROCEDURE ^ GetBufferSize*(time: LONGINT): LONGINT; 
+	PROCEDURE ^ GetProfile*(type, info: LONGINT; VAR profile: Profile; VAR res: WORD); 
+	PROCEDURE ^ Start*(context: Commands.Context); 
+	PROCEDURE ^ StartProfiling*(maxTime: LONGINT; VAR res: WORD); 
+	PROCEDURE ^ Stop*(context: Commands.Context); 
+	PROCEDURE ^ StopProfiling*(VAR res: WORD); 
+	PROCEDURE ^ Continue*(context: Commands.Context); 
+	PROCEDURE ^ ContinueProfiling*(VAR res: WORD); 
+	PROCEDURE ^ GetState*(VAR currentSamples, maxSamples: LONGINT): LONGINT; 
+	PROCEDURE ^ Show*(context: Commands.Context); 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END HierarchicalProfiler.

Linux64/bin/HierarchicalProfiler0.SymUu

@@ -0,0 +1,42 @@
+MODULE HierarchicalProfiler0;
+	IMPORT SYSTEM, Kernel, Unix, Objects, Modules, ProcessInfo, Heaps;
+CONST 
+	Initialized = 0; 
+	Running = 1; 
+	Terminating = 2; 
+	Terminated = 3; 
+	Intervall = 1; 
+TYPE 
+	ProcessTimeArray = POINTER TO ARRAY ProcessInfo.MaxNofProcesses OF HUGEINT; 
+
+	Callback = PROCEDURE (id: LONGINT; process: Objects.Process; pc, bp, lowAdr, highAdr: ADDRESS); 
+
+	Poller = OBJECT {EXCLUSIVE} 
+	VAR 
+		processes, oldProcesses: ARRAY ProcessInfo.MaxNofProcesses OF Objects.Process; 
+		nofProcesses, oldNofProcesses: LONGINT; 
+		times, oldTimes: ProcessTimeArray; 
+		me: Objects.Process; 
+		state: LONGINT; 
+		timer: Kernel.Timer; 
+		NormalGC: PROCEDURE ; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Terminate; 
+		PROCEDURE ^ Clear(array: ProcessTimeArray); 
+		PROCEDURE ^ RanMeanwhile(process: Objects.Process; currentCycles: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ Process; 
+	BEGIN{ACTIVE, PRIORITY(Objects.Realtime)} 
+	END Poller; 
+VAR 
+	poller: Poller; 
+	callback: Callback; 
+	state: LONGINT; 
+
+	PROCEDURE ^ Nothing; 
+	PROCEDURE ^ HandleProcess(process: Objects.Process); 
+	PROCEDURE ^ Enable*(proc: Callback); 
+	PROCEDURE ^ Disable*; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END HierarchicalProfiler0.

Linux64/bin/HostLibs.SymUu

@@ -0,0 +1,12 @@
+MODULE HostLibs;
+	IMPORT SYSTEM, Unix;
+CONST 
+	NilLibHandle* = NIL; 
+TYPE 
+	LibHandle* = ADDRESS; 
+
+	PROCEDURE ^ LoadLibrary*(CONST fileName: ARRAY OF CHAR; VAR lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ FreeLibrary*(CONST lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ GetProcedure*(CONST lib: LibHandle; CONST name: ARRAY OF CHAR; CONST procAddr: ADDRESS): BOOLEAN; 
+BEGIN
+END HostLibs.

Linux64/bin/Huffman.SymUu

@@ -0,0 +1,74 @@
+MODULE Huffman;
+	IMPORT Streams;
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	PatternCounts = ARRAY 256 OF LONGINT; 
+
+	Pattern = RECORD 
+		patt, weight: LONGINT; 
+	END; 
+
+	PatternWeights = POINTER TO ARRAY OF Pattern; 
+
+	HuffCode = RECORD 
+		bits, val: LONGINT; 
+	END; 
+
+	Node = OBJECT 
+	VAR 
+		weight: LONGINT; 
+		pattern: LONGINT; 
+		left, right: Node; 
+
+		PROCEDURE ^  & Init(patt, w: LONGINT); 
+		PROCEDURE ^ AddChildren(l, r: Node); 
+	END Node; 
+
+	Encoder* = OBJECT 
+	VAR 
+		w: Streams.Writer; 
+		out: BitWriter; 
+		codeTable: ARRAY 256 OF HuffCode; 
+
+		PROCEDURE ^  & New*(output: Streams.Writer); 
+		PROCEDURE ^ WriteFrequencies(pw: PatternWeights); 
+		PROCEDURE ^ CountPatterns(CONST source: ARRAY OF CHAR; len: LONGINT): PatternWeights; 
+		PROCEDURE ^ BuildCodeTable(pw: PatternWeights); 
+		PROCEDURE ^ PutCode(code: HuffCode); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		r: Streams.Reader; 
+		in: BitReader; 
+		tree: Node; 
+
+		PROCEDURE ^  & New*(input: Streams.Reader); 
+		PROCEDURE ^ ReadFrequencies(r: Streams.Reader): PatternWeights; 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+
+	PROCEDURE ^ ContainedPatterns(VAR pc: PatternCounts): PatternWeights; 
+	PROCEDURE ^ BuildTree(pw: PatternWeights): Node; 
+BEGIN
+END Huffman.

Linux64/bin/IPBandwidth.SymUu

@@ -0,0 +1,53 @@
+MODULE IPBandwidth;
+	IMPORT Commands, Diagnostics, Kernel, Options, Streams, DNS, IP, TCP, UDP;
+CONST 
+	DefaultPort = 5772; 
+	DefaultDuration = 10; 
+TYPE 
+	Link = OBJECT 
+	VAR 
+		context: Commands.Context; 
+		diagnostics: Diagnostics.StreamDiagnostics; 
+		hostname: DNS.Name; 
+		port, result: WORD; 
+		address: IP.Adr; 
+		buffer: ARRAY 65000 OF CHAR; 
+
+		PROCEDURE ^  & Initialize(context: Commands.Context); 
+		PROCEDURE ^ Send; 
+		PROCEDURE ^ Receive; 
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END Link; 
+
+	TCPLink = OBJECT (Link)
+	VAR 
+		service, connection: TCP.Connection; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END TCPLink; 
+
+	UDPLink = OBJECT (Link)
+	VAR 
+		socket: UDP.Socket; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END UDPLink; 
+
+	PROCEDURE ^ SendTCP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveTCP*(context: Commands.Context); 
+	PROCEDURE ^ SendUDP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveUDP*(context: Commands.Context); 
+BEGIN
+END IPBandwidth.

Linux64/bin/MinosLinker.SymUu

@@ -0,0 +1,58 @@
+MODULE MinosLinker;
+	IMPORT Streams, Commands, Files, KernelLog;
+CONST 
+TYPE 
+	Name = ARRAY 32 OF CHAR; 
+
+	Command = RECORD 
+		name: Name; 
+		offset: LONGINT; 
+	END; 
+
+	Module = POINTER TO RECORD 
+		name: Name; 
+		key: LONGINT; 
+		dbase, pbase: LONGINT; 
+		size, refcnt: LONGINT; 
+		next: Module; 
+		entries: LONGINT; 
+		entry: ARRAY 256 OF LONGINT; 
+		command: ARRAY 64 OF Command; 
+	END; 
+
+	Linker* = OBJECT 
+	VAR 
+		first, last: Module; 
+		base, heap, descriptorBase, bodyBase: LONGINT; 
+		W: Streams.Writer; 
+		Out: Files.File; 
+		Rout: Files.Writer; 
+		code: ARRAY (256 * 1024) OF LONGINT; 
+		plain, descriptors: BOOLEAN; 
+
+		PROCEDURE ^  & InitLinker*(w: Streams.Writer; plain, descriptors: BOOLEAN); 
+		PROCEDURE ^ SetPos(pos: LONGINT); 
+		PROCEDURE ^ WriteCodeBlock(len, adr: LONGINT); 
+		PROCEDURE ^ Fixup(fixloc, offset, base: LONGINT; VAR entry: ARRAY OF LONGINT); 
+		PROCEDURE ^ FixSelf(fixloc, base: LONGINT); 
+		PROCEDURE ^ ThisMod(VAR modname: ARRAY OF CHAR; VAR success: BOOLEAN): Module; 
+		PROCEDURE ^ Bodies; 
+		PROCEDURE ^ String(VAR str: ARRAY OF CHAR; VAR index: LONGINT); 
+		PROCEDURE ^ ModuleDescriptors; 
+		PROCEDURE ^ AddHeader(fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Begin*(base: LONGINT; fileOut, fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Link*(fileIn: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ End*; 
+	END Linker; 
+VAR 
+	log: Streams.Writer; 
+
+	PROCEDURE ^ Branch(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BranchLink(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BodyBranch(m: Module; pc: LONGINT): LONGINT; 
+	PROCEDURE ^ ThisFile(name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ DoLink(linker: Linker; addHeaderFile: BOOLEAN; context: Commands.Context); 
+	PROCEDURE ^ Link*(context: Commands.Context); 
+	PROCEDURE ^ SetLog*(Log: Streams.Writer); 
+BEGIN
+END MinosLinker.

Linux64/bin/OZip.SymUu

@@ -0,0 +1,14 @@
+MODULE OZip;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, Huffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001455); 
+	Suffix = \".oz"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip.

Linux64/bin/OZip2.SymUu

@@ -0,0 +1,14 @@
+MODULE OZip2;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, AH := AdaptiveHuffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001432); 
+	Suffix = \".oz2"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip2.

Linux64/bin/PersistentObjects.SymUu

@@ -0,0 +1,260 @@
+MODULE PersistentObjects;
+	IMPORT XML, XMLParser, XMLScanner, Basic := FoxBasic, Strings, StringPool, Streams, Commands, FoxBasic, Files, XMLObjects, Modules, D := Debugging;
+CONST 
+	Persistent = 0; 
+	None* =  -1; 
+	EnableTrace = FALSE; 
+TYPE 
+	Translation* = OBJECT 
+	TYPE 
+		Entry = RECORD 
+			name: ARRAY 32 OF CHAR; 
+			key: LONGINT; 
+		END; 
+
+		Table = POINTER TO ARRAY OF Entry; 
+	VAR 
+		table: Table; 
+		len: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Grow; 
+		PROCEDURE ^ Add*(CONST name: ARRAY OF CHAR; key: LONGINT); 
+		PROCEDURE ^ Key*(CONST name: ARRAY OF CHAR; VAR key: LONGINT): BOOLEAN; 
+		PROCEDURE ^ Name*(index: SIZE; VAR name: ARRAY OF CHAR): BOOLEAN; 
+	END Translation; 
+
+	Action* = PROCEDURE {DELEGATE}(o: Object); 
+
+	Class* = ENUM Char* = 0, Object* = 1, String* = 2, Integer* = 3, Float* = 4, Boolean* = 5, Enum* = 6, Name* = 7, Range* = 8, Set* = 9 END; 
+
+	Name = ARRAY 128 OF CHAR; 
+
+	Content* = OBJECT 
+	VAR 
+		class*: Class; 
+		name*, type*: Name; 
+		string*: Strings.String; 
+		persistent*: BOOLEAN; 
+		object*: Object; 
+		char*: CHAR; 
+		integer*: HUGEINT; 
+		float*: LONGREAL; 
+		boolean*: BOOLEAN; 
+		translation*: Translation; 
+		range*: RANGE; 
+		set*: SET; 
+		success*: BOOLEAN; 
+
+		PROCEDURE ^ SetClass*(class: Class; persistent: BOOLEAN); 
+		PROCEDURE ^ GetChar*(VAR char: CHAR); 
+		PROCEDURE ^ SetChar*(char: CHAR); 
+		PROCEDURE ^ GetString*(VAR string: Strings.String); 
+		PROCEDURE ^ SetString*(string: Strings.String); 
+		PROCEDURE ^ SetAsString*(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Equals*(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetName*(VAR name: ARRAY OF CHAR); 
+		PROCEDURE ^ SetName*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ GetInteger*(VAR integer: HUGEINT); 
+		PROCEDURE ^ SetInteger*(integer: SIZE); 
+		PROCEDURE ^ GetSet*(VAR set: SET); 
+		PROCEDURE ^ SetSet*(set: SET); 
+		PROCEDURE ^ GetEnum*(translation: Translation; VAR integer: HUGEINT); 
+		PROCEDURE ^ SetEnum*(translation: Translation; integer: HUGEINT); 
+		PROCEDURE ^ GetRange*(VAR range: RANGE); 
+		PROCEDURE ^ SetRange*(CONST range: RANGE); 
+		PROCEDURE ^ GetFloat*(VAR float: LONGREAL); 
+		PROCEDURE ^ SetFloat*(float: LONGREAL); 
+		PROCEDURE ^ GetBoolean*(VAR boolean: BOOLEAN); 
+		PROCEDURE ^ SetBoolean*(boolean: BOOLEAN); 
+		PROCEDURE ^ GetObject*(VAR object: Object); 
+		PROCEDURE ^ SetObject*(object: Object; CONST optionalType: ARRAY OF CHAR); 
+	END Content; 
+
+	Enumerator* = PROCEDURE {DELEGATE}(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+
+	Interpretation* = POINTER TO RECORD 
+		name-, str-: Strings.String; 
+		next-: Interpretation; 
+	END; 
+
+	Object* = OBJECT 
+	CONST 
+		StrType = \"type"\; 
+	VAR 
+		reader: Reader; 
+		writer: Writer; 
+		content: Content; 
+		action: Action; 
+		firstTranslation-: Interpretation; 
+		type*: ARRAY 64 OF CHAR; 
+
+		PROCEDURE ^  & InitObject*; 
+		PROCEDURE ^ ActionEnumerator(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ AddTranslation*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ FindTranslation*(CONST name: ARRAY OF CHAR; VAR translation: Interpretation): BOOLEAN; 
+		PROCEDURE ^ RemoveTranslation*(CONST name: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ ReadContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ WriteContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Write*(w: Writer); 
+		PROCEDURE ^ Read*(r: Reader): BOOLEAN; 
+		PROCEDURE ^ Dump*(log: Streams.Writer; CONST name: ARRAY OF CHAR); 
+	END Object; 
+
+	ObjectList* = OBJECT (Object)
+	VAR 
+		list*: FoxBasic.List; 
+		baseType*: Name; 
+
+		PROCEDURE ^  & InitList*(initialSize: LONGINT; CONST baseType: ARRAY OF CHAR); 
+		PROCEDURE ^ Length*(): LONGINT; 
+		PROCEDURE ^ GetElement*(i: LONGINT): Object; 
+		PROCEDURE ^ SetElement*(i: LONGINT; o: Object); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Add*(o: Object); 
+		PROCEDURE ^ Contains*(o: Object): BOOLEAN; 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ IndexOf*(o: Object): LONGINT; 
+	END ObjectList; 
+
+	Generator = PROCEDURE {DELEGATE}(CONST type: ARRAY OF CHAR):Object; 
+
+	Reader* = OBJECT 
+	VAR 
+		generator: Generator; 
+		error: Streams.Writer; 
+		err-: BOOLEAN; 
+		filename*: Files.FileName; 
+
+		PROCEDURE ^  & InitReader(gen: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ NeedsTranslation(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ AttributeNeedingTranslation*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ NameAttribute*(CONST name: ARRAY OF CHAR; VAR str: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; VAR value: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; VAR value: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; VAR value: RANGE): BOOLEAN; 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; VAR set: SET): BOOLEAN; 
+	END Reader; 
+
+	Writer* = OBJECT 
+
+		PROCEDURE ^  & InitWriter*; 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+		PROCEDURE ^ StartObjectArray*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; value: HUGEINT); 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; value: LONGREAL); 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; value: BOOLEAN); 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; value: HUGEINT); 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; value: RANGE); 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; value: SET); 
+	END Writer; 
+
+	WrittenTable = OBJECT (Basic.HashTable)
+	TYPE 
+		ObjectId = POINTER TO RECORD 
+			num: LONGINT; 
+		END; 
+	VAR 
+		length: LONGINT; 
+
+		PROCEDURE ^ Enter(o: Object; VAR entry: LONGINT): BOOLEAN; 
+	END WrittenTable; 
+
+	XMLWriter* = OBJECT (Writer)
+	VAR 
+		w: Streams.Writer; 
+		document-: XML.Document; 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		written: WrittenTable; 
+
+		PROCEDURE ^  & InitXMLWriter*(writer: Streams.Writer); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; o: Object); 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+	END XMLWriter; 
+
+	ReadTable = OBJECT (Basic.List)
+
+		PROCEDURE ^ Enter(o: Object); 
+		PROCEDURE ^ GetObject(index: HUGEINT): Object; 
+	END ReadTable; 
+
+	Element = POINTER TO RECORD 
+		index: LONGINT; 
+		e: XML.Element; 
+		next: Element; 
+	END; 
+
+	Symbol = POINTER TO RECORD 
+		name: LONGINT; 
+		first, last: Element; 
+		numberElements: LONGINT; 
+		next: Symbol; 
+	END; 
+
+	Stack = POINTER TO RECORD 
+		container: XML.Container; 
+		symbols: Basic.HashTableInt; 
+		firstSymbol: Symbol; 
+		used: Basic.HashTable; 
+		next: Stack; 
+	END; 
+
+	Scope = OBJECT 
+	VAR 
+		stack: Stack; 
+
+		PROCEDURE ^  & InitScope(c: XML.Container); 
+		PROCEDURE ^ Enter(c: XML.Container); 
+		PROCEDURE ^ Register(c: XML.Container); 
+		PROCEDURE ^ Exit(VAR c: XML.Container); 
+		PROCEDURE ^ Use(o: ANY); 
+		PROCEDURE ^ Used(o: ANY): BOOLEAN; 
+		PROCEDURE ^ AddSymbol(CONST name: ARRAY OF CHAR): Symbol; 
+		PROCEDURE ^ FindElement(CONST name: ARRAY OF CHAR; index: LONGINT): XML.Element; 
+		PROCEDURE ^ PutElement(symbol: Symbol; element: Element); 
+		PROCEDURE ^ EnterElement(e: XML.Element); 
+		PROCEDURE ^ Write(w: Streams.Writer); 
+	END Scope; 
+
+	XMLReader* = OBJECT (Reader)
+	VAR 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		read: ReadTable; 
+
+		PROCEDURE ^ ReportXMLError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^  & InitXMLReader*(reader: Streams.Reader; generator: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ CheckUse(o: ANY); 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+	END XMLReader; 
+
+	PROCEDURE ^ NewXMLWriter*(w: Streams.Writer): Writer; 
+	PROCEDURE ^ NewXMLReader*(r: Streams.Reader; generator: Generator): Reader; 
+	PROCEDURE ^ Clone*(o: Object; gen: Generator): Object; 
+	PROCEDURE ^ Trace*(o: Object); 
+BEGIN
+END PersistentObjects.

Linux64/bin/PrecisionTimer.SymUu

@@ -0,0 +1,31 @@
+MODULE PrecisionTimer;
+	IMPORT Unix, KernelLog;
+CONST 
+	CLOCK_REALTIME = 0; 
+	CLOCK_MONOTONIC = 1; 
+	CLOCK_PROCESS_CPUTIME_ID = 2; 
+	CLOCK_THREAD_CPUTIME_ID = 3; 
+	CLOCK_MONOTONIC_RAW = 4; 
+	CLOCK_REALTIME_COARSE = 5; 
+	CLOCK_MONOTONIC_COARSE = 6; 
+	CLOCK_BOOTTIME = 7; 
+	CLOCK_REALTIME_ALARM = 8; 
+	CLOCK_BOOTTIME_ALARM = 9; 
+TYPE 
+	Counter* = HUGEINT; 
+
+	Timespec = RECORD 
+		sec: LONGWORD; 
+		nsec: LONGINT; 
+	END; 
+VAR 
+	clock_gettime: PROCEDURE {C}(clk_id: LONGINT; CONST tp: Timespec):LONGINT; 
+	clock_getres: PROCEDURE {C}(clk_id: LONGINT; CONST res: Timespec):LONGINT; 
+	clockType := CLOCK_MONOTONIC: LONGINT; 
+	frequency: Counter; 
+
+	PROCEDURE ^ GetCounter*(): Counter; 
+	PROCEDURE ^ GetFrequency*(): Counter; 
+	PROCEDURE ^ InitMod; 
+BEGIN
+END PrecisionTimer.

Linux64/bin/Sockets.SymUu

@@ -2,7 +2,6 @@ MODULE Sockets;
 	IMPORT S := SYSTEM, Unix, Trace, IP;
 CONST 
 	Backlog = 5; 
-	LingerSize = 8; 
 TYPE 
 	SocketAdr* = POINTER TO RECORD 
 		family*: INTEGER; 
@@ -25,20 +24,20 @@ TYPE
 		buf: ARRAY 64 OF CHAR; 
 	END; 
 
-	SocketOption = POINTER TO RECORD 
+	SocketOption = RECORD 
 	END; 
 
-	Linger = POINTER TO RECORD (SocketOption)
+	Linger = RECORD (SocketOption)
 		onoff: LONGINT; 
 		linger: LONGINT; 
 	END; 
 
-	Switch = POINTER TO RECORD (SocketOption)
+	Switch = RECORD (SocketOption)
 		onoff: LONGINT; 
 	END; 
 VAR 
 	socket: PROCEDURE {C}(af, typ, protocol: LONGINT):LONGINT; 
-	setsockopt: PROCEDURE {C}(s: LONGINT; level, optname: LONGINT; opt: SocketOption; optlen: LONGINT):LONGINT; 
+	setsockopt: PROCEDURE {C}(s: LONGINT; level, optname: LONGINT; VAR opt: SocketOption; optlen: LONGINT):LONGINT; 
 	accept: PROCEDURE {C}(s: LONGINT; adrPtr: ADDRESS; VAR adrlen: LONGINT):LONGINT; 
 	bind: PROCEDURE {C}(s: LONGINT; adr: SocketAdr; adrlen: LONGINT):LONGINT; 
 	connect: PROCEDURE {C}(s: LONGINT; adr: SocketAdr; adrlen: LONGINT):LONGINT; 

Linux64/bin/WMProfiler.SymUu

@@ -0,0 +1,48 @@
+MODULE WMProfiler;
+	IMPORT Modules, Kernel, Strings, HierarchicalProfiler, WMGraphics, WMMessages, WMRestorable, WMWindowManager, WMComponents, WMStandardComponents, WMEditors, WMTrees, WMErrors, WMProgressComponents;
+CONST 
+	DefaultTime = 30; 
+TYPE 
+	KillerMsg = OBJECT 
+	END KillerMsg; 
+
+	Window* = OBJECT {EXCLUSIVE} (WMComponents.FormWindow)
+	VAR 
+		startBtn, stopBtn, continueBtn, getProfileBtn, flattenBtn, filterBtn: WMStandardComponents.Button; 
+		timeEdit, typeEdit, infoEdit, filterMaskEdit, filterCountEdit: WMEditors.Editor; 
+		tree: WMTrees.Tree; 
+		treeView: WMTrees.TreeView; 
+		lastSelectedNode: HierarchicalProfiler.Node; 
+		lastState: LONGINT; 
+		statusLabel: WMStandardComponents.Label; 
+		progressBar: WMProgressComponents.ProgressBar; 
+		profile: HierarchicalProfiler.Profile; 
+		alive, dead: BOOLEAN; 
+		timer: Kernel.Timer; 
+
+		PROCEDURE ^ HasVisibleChildren(node: HierarchicalProfiler.Node): BOOLEAN; 
+		PROCEDURE ^ AddChildNodes(parent: WMTrees.TreeNode; node: HierarchicalProfiler.Node; expand: BOOLEAN); 
+		PROCEDURE ^ ClearExternField(node: HierarchicalProfiler.Node); 
+		PROCEDURE ^ UpdateTree; 
+		PROCEDURE ^ UpdateStatusBar(forceUpdate: BOOLEAN); 
+		PROCEDURE ^ HandleNodeClicked(sender, data: ANY); 
+		PROCEDURE ^ HandleNodeSelected(sender, data: ANY); 
+		PROCEDURE ^ GetTypeAndInfo(VAR type, info: LONGINT); 
+		PROCEDURE ^ GetFilterMask(VAR mask: ARRAY OF CHAR; VAR minPercent: LONGINT); 
+		PROCEDURE ^ HandleButtons(sender, data: ANY); 
+		PROCEDURE ^ CreateForm(): WMComponents.VisualComponent; 
+		PROCEDURE ^  & New*(context: WMRestorable.Context); 
+		PROCEDURE ^ Handle*(VAR x: WMMessages.Message); 
+		PROCEDURE ^ Close*; 
+	BEGIN{ACTIVE} 
+	END Window; 
+VAR 
+	nofWindows: LONGINT; 
+
+	PROCEDURE ^ Open*; 
+	PROCEDURE ^ Restore*(context: WMRestorable.Context); 
+	PROCEDURE ^ IncCount; 
+	PROCEDURE ^ DecCount; 
+	PROCEDURE ^ Cleanup; 
+BEGIN
+END WMProfiler.

Win32/bin/AdaptiveHuffman.SymW

@@ -0,0 +1,81 @@
+MODULE AdaptiveHuffman;
+	IMPORT Streams;
+CONST 
+	AlphabetSize = 256; 
+	BlockSize* = (8 * 1024); 
+	ScaleLimit = (4 * 1024); 
+	Encode = 0; 
+	Decode = 1; 
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	HuffmanCoder = OBJECT 
+	TYPE 
+		Index = INTEGER; 
+
+		Pattern = INTEGER; 
+
+		Node = RECORD 
+			weight: INTEGER; 
+			pattern: Pattern; 
+			up: Index; 
+			down: Index; 
+		END; 
+	VAR 
+		mode: SHORTINT; 
+		in: BitReader; 
+		out: BitWriter; 
+		esc: Index; 
+		root: Index; 
+		map: ARRAY AlphabetSize OF Index; 
+		table: ARRAY ((2 * AlphabetSize) + 2) OF Node; 
+
+		PROCEDURE ^  & New(m: SHORTINT; input: Streams.Reader; output: Streams.Writer); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Finish; 
+		PROCEDURE ^ GetPattern(): Pattern; 
+		PROCEDURE ^ PutPattern(patt: Pattern); 
+		PROCEDURE ^ AddPattern(patt: Pattern): Index; 
+		PROCEDURE ^ GroupLeader(node: Index): Index; 
+		PROCEDURE ^ SlideNode(node: Index): Index; 
+		PROCEDURE ^ IncrementWeight(node: Index); 
+		PROCEDURE ^ Scale; 
+		PROCEDURE ^ EncodeByte(ch: CHAR); 
+		PROCEDURE ^ ExtractByte(): CHAR; 
+	END HuffmanCoder; 
+
+	Encoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Writer); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Reader); 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+BEGIN
+END AdaptiveHuffman.

Win32/bin/BorrowsWheeler.SymW

@@ -0,0 +1,57 @@
+MODULE BorrowsWheeler;
+CONST 
+	BlockSize* = (8 * 1024); 
+TYPE 
+	MTF = OBJECT 
+	TYPE 
+		Node = POINTER TO RECORD 
+			byte: CHAR; 
+			next: Node; 
+		END; 
+	VAR 
+		alpha: Node; 
+
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Encode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+		PROCEDURE ^ Decode(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END MTF; 
+
+	Encoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		length: LONGINT; 
+		sbuf: ARRAY (2 * BlockSize) OF CHAR; 
+		rotation: ARRAY BlockSize OF Index; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE ^ Less(a, b: Index): BOOLEAN; 
+		PROCEDURE ^ Swap(a, b: Index); 
+		PROCEDURE ^ InsertSort(lo, hi: Index); 
+		PROCEDURE ^ SortR(lo, hi: LONGINT); 
+		PROCEDURE ^ EncodeBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT): LONGINT; 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	TYPE 
+		Index = LONGINT; 
+	VAR 
+		mtf: MTF; 
+		f, l: ARRAY BlockSize OF CHAR; 
+		lc, fc: ARRAY BlockSize OF INTEGER; 
+
+		PROCEDURE ^  & New*; 
+		PROCEDURE  - Swap(a, b: Index);
+		VAR 
+			tmp: CHAR; 
+		BEGIN
+			tmp := f[a]; 
+			f[a] := f[b]; 
+			f[b] := tmp
+		END Swap; 
+		PROCEDURE ^ SortF(lo, hi: Index); 
+		PROCEDURE ^ DecodeBlock*(VAR buf: ARRAY OF CHAR; len, index: LONGINT); 
+	END Decoder; 
+BEGIN
+END BorrowsWheeler.

Win32/bin/FoxInterpreter.SymW

@@ -0,0 +1,205 @@
+MODULE FoxInterpreter;
+	IMPORT Scanner := FoxScanner, FoxParser, SyntaxTree := FoxSyntaxTree, Printout := FoxPrintout, Commands, Diagnostics, StringPool, InterpreterSymbols := FoxInterpreterSymbols, D := Debugging, Strings, Streams, Modules, PersistentObjects, Basic := FoxBasic, SYSTEM, Machine, Global := FoxGlobal, Heaps;
+CONST 
+	EnableTrace = FALSE; 
+	MaxIndex = 8; 
+TYPE 
+	Result* = InterpreterSymbols.Result; 
+
+	Value* = InterpreterSymbols.Value; 
+
+	Integer* = InterpreterSymbols.IntegerValue; 
+
+	Real* = InterpreterSymbols.RealValue; 
+
+	String* = InterpreterSymbols.StringValue; 
+
+	Boolean* = InterpreterSymbols.BooleanValue; 
+
+	Set* = InterpreterSymbols.SetValue; 
+
+	Range* = InterpreterSymbols.RangeValue; 
+
+	Char* = InterpreterSymbols.CharValue; 
+
+	Any* = InterpreterSymbols.AnyValue; 
+
+	MathArrayValue* = InterpreterSymbols.MathArrayValue; 
+
+	Scope* = InterpreterSymbols.Scope; 
+
+	Container* = InterpreterSymbols.Container; 
+
+	Builtin* = OBJECT (InterpreterSymbols.Object)
+	VAR 
+		id: LONGINT; 
+	END Builtin; 
+
+	Item* = RECORD 
+		object*: InterpreterSymbols.Item; 
+		in*: InterpreterSymbols.Item; 
+		name*: StringPool.Index; 
+		i*: ARRAY MaxIndex OF LONGINT; 
+	END; 
+
+	CommandStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		command: Strings.String; 
+
+		PROCEDURE ^  & InitCommandStatement(s: Strings.String); 
+	END CommandStatement; 
+
+	PrintStatement = OBJECT (SyntaxTree.Statement)
+	VAR 
+		expression: SyntaxTree.Expression; 
+
+		PROCEDURE ^  & InitPrintStatement(e: SyntaxTree.Expression); 
+	END PrintStatement; 
+
+	Parser* = OBJECT (FoxParser.Parser)
+
+		PROCEDURE ^ Statement*(statements: SyntaxTree.StatementSequence; outer: SyntaxTree.Statement): BOOLEAN; 
+		PROCEDURE ^ Cmd(): SyntaxTree.Statement; 
+		PROCEDURE ^ Print(): SyntaxTree.Statement; 
+	END Parser; 
+
+	Interpreter* = OBJECT (SyntaxTree.Visitor)
+	VAR 
+		value: BOOLEAN; 
+		item-: Item; 
+		module-: Modules.Module; 
+		typeDesc-: Modules.TypeDesc; 
+		scope-: Scope; 
+		exit: BOOLEAN; 
+		error-: BOOLEAN; 
+		diagnostics: Diagnostics.Diagnostics; 
+		context-: Commands.Context; 
+
+		PROCEDURE ^  & Init*(scope: Scope; diagnostics: Diagnostics.Diagnostics; context: Commands.Context); 
+		PROCEDURE ^ SetScope*(s: Scope); 
+		PROCEDURE ^ Reset*; 
+		PROCEDURE ^ Error(CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^ ErrorSS(CONST msg: ARRAY OF CHAR; id: StringPool.Index); 
+		PROCEDURE ^ VisitSet*(x: SyntaxTree.Set); 
+		PROCEDURE ^ VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression); 
+		PROCEDURE ^ NewInt(i: HUGEINT); 
+		PROCEDURE ^ NewReal(i: LONGREAL); 
+		PROCEDURE ^ NewBool(b: BOOLEAN); 
+		PROCEDURE ^ NewSet(s: SET); 
+		PROCEDURE ^ NewString(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ NewRange(r: RANGE); 
+		PROCEDURE ^ NewChar(c: CHAR); 
+		PROCEDURE ^ VisitUnaryExpression*(x: SyntaxTree.UnaryExpression); 
+		PROCEDURE ^ VisitBinaryExpression*(x: SyntaxTree.BinaryExpression); 
+		PROCEDURE ^ VisitRangeExpression*(x: SyntaxTree.RangeExpression); 
+		PROCEDURE ^ VisitTensorRangeExpression*(x: SyntaxTree.TensorRangeExpression); 
+		PROCEDURE ^ VisitConversion*(x: SyntaxTree.Conversion); 
+		PROCEDURE ^ VisitDesignator*(x: SyntaxTree.Designator); 
+		PROCEDURE ^ VisitQualifiedType*(x: SyntaxTree.QualifiedType); 
+		PROCEDURE ^ VisitIdentifierDesignator*(x: SyntaxTree.IdentifierDesignator); 
+		PROCEDURE ^ VisitSelectorDesignator*(x: SyntaxTree.SelectorDesignator); 
+		PROCEDURE ^ VisitParameterDesignator*(x: SyntaxTree.ParameterDesignator); 
+		PROCEDURE ^ VisitArrowDesignator*(x: SyntaxTree.ArrowDesignator); 
+		PROCEDURE ^ VisitBracketDesignator*(x: SyntaxTree.BracketDesignator); 
+		PROCEDURE ^ VisitSymbolDesignator*(x: SyntaxTree.SymbolDesignator); 
+		PROCEDURE ^ VisitIndexDesignator*(x: SyntaxTree.IndexDesignator); 
+		PROCEDURE ^ VisitProcedureCallDesignator*(x: SyntaxTree.ProcedureCallDesignator); 
+		PROCEDURE ^ SystemTrace(x: SyntaxTree.ExpressionList); 
+		PROCEDURE ^ FindType(type: SyntaxTree.Type): Result; 
+		PROCEDURE ^ VisitBuiltinCallDesignator*(x: SyntaxTree.BuiltinCallDesignator); 
+		PROCEDURE ^ VisitTypeGuardDesignator*(x: SyntaxTree.TypeGuardDesignator); 
+		PROCEDURE ^ VisitDereferenceDesignator*(x: SyntaxTree.DereferenceDesignator); 
+		PROCEDURE ^ VisitSupercallDesignator*(x: SyntaxTree.SupercallDesignator); 
+		PROCEDURE ^ VisitSelfDesignator*(x: SyntaxTree.SelfDesignator); 
+		PROCEDURE ^ VisitResultDesignator*(x: SyntaxTree.ResultDesignator); 
+		PROCEDURE ^ VisitValue*(x: SyntaxTree.Value); 
+		PROCEDURE ^ VisitBooleanValue*(x: SyntaxTree.BooleanValue); 
+		PROCEDURE ^ VisitIntegerValue*(x: SyntaxTree.IntegerValue); 
+		PROCEDURE ^ VisitCharacterValue*(x: SyntaxTree.CharacterValue); 
+		PROCEDURE ^ VisitSetValue*(x: SyntaxTree.SetValue); 
+		PROCEDURE ^ VisitMathArrayValue*(x: SyntaxTree.MathArrayValue); 
+		PROCEDURE ^ VisitRealValue*(x: SyntaxTree.RealValue); 
+		PROCEDURE ^ VisitComplexValue*(x: SyntaxTree.ComplexValue); 
+		PROCEDURE ^ VisitStringValue*(x: SyntaxTree.StringValue); 
+		PROCEDURE ^ VisitNilValue*(x: SyntaxTree.NilValue); 
+		PROCEDURE ^ VisitEnumerationValue*(x: SyntaxTree.EnumerationValue); 
+		PROCEDURE ^ VisitSymbol*(x: SyntaxTree.Symbol); 
+		PROCEDURE ^ VisitTypeDeclaration*(x: SyntaxTree.TypeDeclaration); 
+		PROCEDURE ^ VisitConstant*(x: SyntaxTree.Constant); 
+		PROCEDURE ^ VisitVariable*(x: SyntaxTree.Variable); 
+		PROCEDURE ^ VisitParameter*(x: SyntaxTree.Parameter); 
+		PROCEDURE ^ VisitProcedure*(x: SyntaxTree.Procedure); 
+		PROCEDURE ^ VisitBuiltin*(x: SyntaxTree.Builtin); 
+		PROCEDURE ^ VisitOperator*(x: SyntaxTree.Operator); 
+		PROCEDURE ^ VisitImport*(x: SyntaxTree.Import); 
+		PROCEDURE ^ TranslateString*(cmd: CHAR; CONST str: ARRAY OF CHAR; VAR dest: Strings.String): BOOLEAN; 
+		PROCEDURE ^ VisitCommandStatement(x: CommandStatement); 
+		PROCEDURE ^ VisitPrintStatement(x: PrintStatement); 
+		PROCEDURE ^ VisitStatement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ VisitProcedureCallStatement*(x: SyntaxTree.ProcedureCallStatement); 
+		PROCEDURE ^ LoadValue; 
+		PROCEDURE ^ GetValue*(x: SyntaxTree.Expression; VAR w: Value): BOOLEAN; 
+		PROCEDURE ^ Designate(x: SyntaxTree.Expression): Result; 
+		PROCEDURE ^ Evaluate(x: SyntaxTree.Expression): Value; 
+		PROCEDURE ^ GetInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ ExpectInteger(x: SyntaxTree.Expression; VAR i: Integer): BOOLEAN; 
+		PROCEDURE ^ GetBoolean(x: SyntaxTree.Expression; VAR i: Boolean): BOOLEAN; 
+		PROCEDURE ^ ExpectBoolean(x: SyntaxTree.Expression; VAR b: Boolean): BOOLEAN; 
+		PROCEDURE ^ PutValue(x: SyntaxTree.Designator; v: Value); 
+		PROCEDURE ^ VisitAssignment*(x: SyntaxTree.Assignment); 
+		PROCEDURE ^ IfPart(ifPart: SyntaxTree.IfPart): BOOLEAN; 
+		PROCEDURE ^ VisitIfStatement*(x: SyntaxTree.IfStatement); 
+		PROCEDURE ^ VisitWithStatement*(x: SyntaxTree.WithStatement); 
+		PROCEDURE ^ CasePart(x: SyntaxTree.CasePart; b: SyntaxTree.BinaryExpression): BOOLEAN; 
+		PROCEDURE ^ VisitCaseStatement*(x: SyntaxTree.CaseStatement); 
+		PROCEDURE ^ VisitWhileStatement*(x: SyntaxTree.WhileStatement); 
+		PROCEDURE ^ VisitRepeatStatement*(x: SyntaxTree.RepeatStatement); 
+		PROCEDURE ^ VisitForStatement*(x: SyntaxTree.ForStatement); 
+		PROCEDURE ^ VisitLoopStatement*(x: SyntaxTree.LoopStatement); 
+		PROCEDURE ^ VisitExitStatement*(x: SyntaxTree.ExitStatement); 
+		PROCEDURE ^ VisitReturnStatement*(x: SyntaxTree.ReturnStatement); 
+		PROCEDURE ^ VisitAwaitStatement*(x: SyntaxTree.AwaitStatement); 
+		PROCEDURE ^ VisitStatementBlock*(x: SyntaxTree.StatementBlock); 
+		PROCEDURE ^ VisitCode*(x: SyntaxTree.Code); 
+		PROCEDURE ^ Expression(x: SyntaxTree.Expression); 
+		PROCEDURE ^ Statement*(x: SyntaxTree.Statement); 
+		PROCEDURE ^ StatementSequence*(x: SyntaxTree.StatementSequence); 
+	END Interpreter; 
+
+	Resolver* = OBJECT 
+	VAR 
+		interpreter: Interpreter; 
+		content: PersistentObjects.Content; 
+		resolved: Basic.HashTable; 
+		current: Scope; 
+		changed: BOOLEAN; 
+
+		PROCEDURE ^  & InitResolver*; 
+		PROCEDURE ^ Traverse(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ DoResolve*(scope: Scope); 
+		PROCEDURE ^ Resolve*(scope: Scope); 
+	END Resolver; 
+
+	TestO = OBJECT 
+	VAR 
+		i: LONGINT; 
+
+		PROCEDURE ^  & P(s: SHORTINT); 
+	END TestO; 
+
+	; 
+VAR 
+	global-: Scope; 
+	c: LONGINT; 
+	d: RECORD 
+		e: LONGINT; 
+	END; 
+
+	PROCEDURE ^ Statements*(context: Commands.Context); 
+	PROCEDURE ^ Expression*(context: Commands.Context); 
+	PROCEDURE ^ TranslateString*(context: Commands.Context); 
+	PROCEDURE ^ InitGlobalScope; 
+	PROCEDURE ^ Getter(): LONGINT; 
+	PROCEDURE ^ Setter(a: LONGINT): LONGINT; 
+BEGIN
+END FoxInterpreter.

Win32/bin/FoxInterpreterSymbols.SymW

@@ -0,0 +1,351 @@
+MODULE FoxInterpreterSymbols;
+	IMPORT Strings, Basic := FoxBasic, StringPool, Streams, Commands, PersistentObjects, Modules, Machine, SyntaxTree := FoxSyntaxTree, SYSTEM, Reflection;
+CONST 
+	TAB = 9X; 
+	StrValue = \"value"\; 
+TYPE 
+	Item* = PersistentObjects.Object; 
+
+	Object* = PersistentObjects.Object; 
+
+	Content* = PersistentObjects.Content; 
+
+	Name* = ARRAY 128 OF CHAR; 
+
+	Meta* = RECORD 
+		module*: Modules.Module; 
+		refs*: Modules.Bytes; 
+		offset*: SIZE; 
+	END; 
+
+	Result* = OBJECT (Item)
+
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Trace*; 
+	END Result; 
+
+	SymbolResult* = OBJECT (Result)
+	VAR 
+		name: ARRAY 32 OF CHAR; 
+
+		PROCEDURE ^ InitSymbol(CONST n: ARRAY OF CHAR); 
+	END SymbolResult; 
+
+	TypeResult* = OBJECT (SymbolResult)
+	VAR 
+		type-: Meta; 
+		address: ADDRESS; 
+
+		PROCEDURE ^  & InitType(CONST name: ARRAY OF CHAR; t: Meta); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Constructor*(): ProcedureResult; 
+	END TypeResult; 
+
+	ModuleResult* = OBJECT (SymbolResult)
+	VAR 
+		self: Meta; 
+
+		PROCEDURE ^  & InitModule(CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END ModuleResult; 
+
+	Callstack = OBJECT 
+	VAR 
+		data: ARRAY 1024 OF CHAR; 
+		pos: SIZE; 
+		size: SIZE; 
+		H: HUGEINT; 
+		pPos: LONGINT; 
+
+		PROCEDURE ^  & Init; 
+		PROCEDURE ^ Next(s: SIZE): ADDRESS; 
+		PROCEDURE ^ PushH(h: HUGEINT); 
+		PROCEDURE ^ PushL(i: LONGINT); 
+		PROCEDURE ^ PushI(i: INTEGER); 
+		PROCEDURE ^ PushS(i: SHORTINT); 
+		PROCEDURE ^ PushB(b: BOOLEAN); 
+		PROCEDURE ^ PushC(c: CHAR); 
+		PROCEDURE ^ PushSet(set: SET); 
+		PROCEDURE ^ PushR(r: REAL); 
+		PROCEDURE ^ PushX(x: LONGREAL); 
+		PROCEDURE ^ PushA(a: ADDRESS); 
+		PROCEDURE ^ PushSz(s: SIZE); 
+		PROCEDURE ^ Call(adr: ADDRESS); 
+		PROCEDURE ^ CallH(adr: ADDRESS): HUGEINT; 
+		PROCEDURE ^ CallR(adr: ADDRESS): REAL; 
+		PROCEDURE ^ CallX(adr: ADDRESS): LONGREAL; 
+	END Callstack; 
+
+	ProcedureResult* = OBJECT (SymbolResult)
+	VAR 
+		meta: Meta; 
+		address: ADDRESS; 
+		stack: Callstack; 
+		index: LONGINT; 
+		caller-: Result; 
+		parameters: Meta; 
+		flags: SET; 
+
+		PROCEDURE ^ Parameters(): Meta; 
+		PROCEDURE ^ ReturnType(): Meta; 
+		PROCEDURE ^ ReturnsPointer*(): BOOLEAN; 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^  & InitProcedure(c: Result; CONST name: ARRAY OF CHAR; m: Meta); 
+		PROCEDURE ^ Pars*; 
+		PROCEDURE ^ PushAddress*(adr: ADDRESS); 
+		PROCEDURE ^ PushTyped*(o: Result; mode: CHAR; refs: Modules.Bytes; VAR offset: SIZE): BOOLEAN; 
+		PROCEDURE ^ Push*(o: Result): BOOLEAN; 
+		PROCEDURE ^ Check*(): BOOLEAN; 
+		PROCEDURE ^ Evaluate*(): Value; 
+	END ProcedureResult; 
+
+	FieldResult* = OBJECT (SymbolResult)
+	VAR 
+		address: ADDRESS; 
+		meta: Meta; 
+
+		PROCEDURE ^  & InitField(CONST name: ARRAY OF CHAR; meta: Meta; base: ADDRESS); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ SetV*(v: Value): BOOLEAN; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END FieldResult; 
+
+	Value* = OBJECT (Result)
+
+		PROCEDURE ^  & InitValue; 
+		PROCEDURE ^ Evaluate*(): Value; 
+		PROCEDURE ^ GetInt*(VAR h: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ GetChar*(VAR x: CHAR): BOOLEAN; 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ GetString*(VAR w: ARRAY OF CHAR); 
+	END Value; 
+
+	AnyValue* = OBJECT (Value)
+	VAR 
+		value*: ANY; 
+
+		PROCEDURE ^  & InitAny*(value: ANY); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Result; 
+	END AnyValue; 
+
+	AddressValue* = OBJECT (Value)
+	VAR 
+		value*: ADDRESS; 
+
+		PROCEDURE ^  & InitAny*(value: ADDRESS); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetAddress*(VAR a: ADDRESS): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END AddressValue; 
+
+	IntegerValue* = OBJECT (Value)
+	VAR 
+		value*: HUGEINT; 
+
+		PROCEDURE ^  & InitInteger*(value: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetInt*(VAR v: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END IntegerValue; 
+
+	RealValue* = OBJECT (Value)
+	VAR 
+		value*: LONGREAL; 
+
+		PROCEDURE ^  & InitReal*(value: LONGREAL); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetReal*(VAR x: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RealValue; 
+
+	BooleanValue* = OBJECT (Value)
+	VAR 
+		value*: BOOLEAN; 
+
+		PROCEDURE ^  & InitBoolean*(value: BOOLEAN); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetBoolean*(VAR x: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END BooleanValue; 
+
+	StringValue* = OBJECT (Value)
+	VAR 
+		value*: Strings.String; 
+
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END StringValue; 
+
+	SetValue* = OBJECT (Value)
+	VAR 
+		value*: SET; 
+
+		PROCEDURE ^  & InitSet*(value: SET); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetSet*(VAR x: SET): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END SetValue; 
+
+	RangeValue* = OBJECT (Value)
+	VAR 
+		value*: RANGE; 
+
+		PROCEDURE ^  & InitRange*(r: RANGE); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetRange*(VAR x: RANGE): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END RangeValue; 
+
+	CharValue* = OBJECT (Value)
+	VAR 
+		value: CHAR; 
+
+		PROCEDURE ^  & InitChar*(c: CHAR); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetChar*(VAR c: CHAR): BOOLEAN; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END CharValue; 
+
+	EnumValue* = OBJECT (Value)
+	VAR 
+		value: HUGEINT; 
+		translation: PersistentObjects.Translation; 
+
+		PROCEDURE ^  & InitEnumValue*(trans: PersistentObjects.Translation; v: HUGEINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+		PROCEDURE ^ Address*(): ADDRESS; 
+	END EnumValue; 
+
+	MathArrayValue* = OBJECT (Value)
+	VAR 
+		values: ARRAY [*] OF Value; 
+
+		PROCEDURE ^  & InitMathArrayValue*(len: LONGINT); 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ SetValue*(at: LONGINT; value: Value); 
+		PROCEDURE ^ GetValue*(at: LONGINT): Value; 
+		PROCEDURE ^ WriteValue*(w: Streams.Writer); 
+	END MathArrayValue; 
+
+	Symbol* = OBJECT 
+	VAR 
+		name: StringPool.Index; 
+		item-: Item; 
+
+		PROCEDURE ^  & InitSymbol(name: StringPool.Index; index: LONGINT); 
+		PROCEDURE ^ GetName(VAR name: ARRAY OF CHAR); 
+	END Symbol; 
+
+	Container* = OBJECT (Item)
+	VAR 
+		symbols-: Basic.List; 
+		lookup-: Basic.HashTableInt; 
+
+		PROCEDURE ^  & InitContainer*; 
+		PROCEDURE ^ Enumerate*(enum: PersistentObjects.Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ GetItem*(index: LONGINT): Item; 
+		PROCEDURE ^ Enter1*(item: Item; name: StringPool.Index); 
+		PROCEDURE ^ Enter*(item: Item; CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ Find1*(id: LONGINT): Item; 
+		PROCEDURE ^ Find*(CONST name: ARRAY OF CHAR): Item; 
+	END Container; 
+
+	Scope* = OBJECT 
+	VAR 
+		outer-: Scope; 
+		object-: Object; 
+		level: LONGINT; 
+
+		PROCEDURE ^  & InitScope*(outer: Scope; object: Object); 
+		PROCEDURE ^ Enter*(object: Object): Scope; 
+		PROCEDURE ^ FindObject*(CONST name: ARRAY OF CHAR; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ FindObject1*(name: StringPool.Index; index: LONGINT; VAR in: Object): Object; 
+		PROCEDURE ^ Leave*(): Scope; 
+		PROCEDURE ^ Dump*(log: Streams.Writer); 
+	END Scope; 
+
+	ObjectFilter* = OBJECT 
+	VAR 
+		content: Content; 
+		object: Object; 
+		found: Container; 
+		attribute, value: ARRAY 256 OF CHAR; 
+
+		PROCEDURE ^  & InitObjectFilter*; 
+		PROCEDURE ^ AddFiltered(obj: Object); 
+		PROCEDURE ^ Enumerate(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Filter*(obj: Object; attribute, value: ARRAY OF CHAR): Container; 
+	END ObjectFilter; 
+
+	PROCEDURE ^ FindSymbol*(CONST name: ARRAY OF CHAR; meta: Meta): Meta; 
+	PROCEDURE ^ SymbolKind*(meta: Meta): CHAR; 
+	PROCEDURE ^ SymbolParent*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolName*(meta: Meta; VAR name: ARRAY OF CHAR); 
+	PROCEDURE ^ VariableMode*(meta: Meta): Meta; 
+	PROCEDURE ^ VariableType*(meta: Meta): Meta; 
+	PROCEDURE ^ SymbolAddress*(meta: Meta; base: ADDRESS): ADDRESS; 
+	PROCEDURE ^ FindInType(scope: Result; address: ADDRESS; type: ADDRESS; CONST name: ARRAY OF CHAR): Result; 
+	PROCEDURE ^ FindConstructor(scope: Result; type: ADDRESS): ProcedureResult; 
+	PROCEDURE ^ Indent(w: Streams.Writer; level: LONGINT); 
+	PROCEDURE ^ Test*(context: Commands.Context); 
+	PROCEDURE ^ ContentGetValue(c: Content): Value; 
+	PROCEDURE ^ NewIntegerValue(value: HUGEINT): IntegerValue; 
+	PROCEDURE ^ NewFloatValue(value: LONGREAL): RealValue; 
+	PROCEDURE ^ NewBooleanValue(value: BOOLEAN): BooleanValue; 
+	PROCEDURE ^ NewStringValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewNameValue(CONST value: ARRAY OF CHAR): StringValue; 
+	PROCEDURE ^ NewRangeValue(value: RANGE): RangeValue; 
+	PROCEDURE ^ NewCharValue(value: CHAR): CharValue; 
+	PROCEDURE ^ NewSetValue(value: SET): SetValue; 
+	PROCEDURE ^ NewEnumValue(translation: PersistentObjects.Translation; value: HUGEINT): EnumValue; 
+	PROCEDURE ^ FindInObject*(in: Object; CONST name: ARRAY OF CHAR; index: LONGINT): Object; 
+	PROCEDURE ^ GetModule*(CONST name: ARRAY OF CHAR): ModuleResult; 
+	PROCEDURE ^ FindInObject1*(in: Object; name: StringPool.Index; index: LONGINT): Object; 
+BEGIN
+END FoxInterpreterSymbols.

Win32/bin/HostLibs.SymW

@@ -0,0 +1,12 @@
+MODULE HostLibs;
+	IMPORT SYSTEM, Kernel32;
+CONST 
+	NilLibHandle* = Kernel32.NULL; 
+TYPE 
+	LibHandle* = Kernel32.HANDLE; 
+
+	PROCEDURE ^ LoadLibrary*(CONST fileName: ARRAY OF CHAR; VAR lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ FreeLibrary*(CONST lib: LibHandle): BOOLEAN; 
+	PROCEDURE ^ GetProcedure*(CONST lib: LibHandle; CONST name: ARRAY OF CHAR; CONST procAddr: ADDRESS): BOOLEAN; 
+BEGIN
+END HostLibs.

Win32/bin/Huffman.SymW

@@ -0,0 +1,74 @@
+MODULE Huffman;
+	IMPORT Streams;
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	PatternCounts = ARRAY 256 OF LONGINT; 
+
+	Pattern = RECORD 
+		patt, weight: LONGINT; 
+	END; 
+
+	PatternWeights = POINTER TO ARRAY OF Pattern; 
+
+	HuffCode = RECORD 
+		bits, val: LONGINT; 
+	END; 
+
+	Node = OBJECT 
+	VAR 
+		weight: LONGINT; 
+		pattern: LONGINT; 
+		left, right: Node; 
+
+		PROCEDURE ^  & Init(patt, w: LONGINT); 
+		PROCEDURE ^ AddChildren(l, r: Node); 
+	END Node; 
+
+	Encoder* = OBJECT 
+	VAR 
+		w: Streams.Writer; 
+		out: BitWriter; 
+		codeTable: ARRAY 256 OF HuffCode; 
+
+		PROCEDURE ^  & New*(output: Streams.Writer); 
+		PROCEDURE ^ WriteFrequencies(pw: PatternWeights); 
+		PROCEDURE ^ CountPatterns(CONST source: ARRAY OF CHAR; len: LONGINT): PatternWeights; 
+		PROCEDURE ^ BuildCodeTable(pw: PatternWeights); 
+		PROCEDURE ^ PutCode(code: HuffCode); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		r: Streams.Reader; 
+		in: BitReader; 
+		tree: Node; 
+
+		PROCEDURE ^  & New*(input: Streams.Reader); 
+		PROCEDURE ^ ReadFrequencies(r: Streams.Reader): PatternWeights; 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+
+	PROCEDURE ^ ContainedPatterns(VAR pc: PatternCounts): PatternWeights; 
+	PROCEDURE ^ BuildTree(pw: PatternWeights): Node; 
+BEGIN
+END Huffman.

Win32/bin/IPBandwidth.SymW

@@ -0,0 +1,53 @@
+MODULE IPBandwidth;
+	IMPORT Commands, Diagnostics, Kernel, Options, Streams, DNS, IP, TCP, UDP;
+CONST 
+	DefaultPort = 5772; 
+	DefaultDuration = 10; 
+TYPE 
+	Link = OBJECT 
+	VAR 
+		context: Commands.Context; 
+		diagnostics: Diagnostics.StreamDiagnostics; 
+		hostname: DNS.Name; 
+		port, result: WORD; 
+		address: IP.Adr; 
+		buffer: ARRAY 65000 OF CHAR; 
+
+		PROCEDURE ^  & Initialize(context: Commands.Context); 
+		PROCEDURE ^ Send; 
+		PROCEDURE ^ Receive; 
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END Link; 
+
+	TCPLink = OBJECT (Link)
+	VAR 
+		service, connection: TCP.Connection; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END TCPLink; 
+
+	UDPLink = OBJECT (Link)
+	VAR 
+		socket: UDP.Socket; 
+
+		PROCEDURE ^ Connect; 
+		PROCEDURE ^ Listen; 
+		PROCEDURE ^ SendBytes(): Streams.StreamSize; 
+		PROCEDURE ^ ReceiveBytes(): Streams.StreamSize; 
+		PROCEDURE ^ Close; 
+	END UDPLink; 
+
+	PROCEDURE ^ SendTCP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveTCP*(context: Commands.Context); 
+	PROCEDURE ^ SendUDP*(context: Commands.Context); 
+	PROCEDURE ^ ReceiveUDP*(context: Commands.Context); 
+BEGIN
+END IPBandwidth.

Win32/bin/MinosLinker.SymW

@@ -0,0 +1,58 @@
+MODULE MinosLinker;
+	IMPORT Streams, Commands, Files, KernelLog;
+CONST 
+TYPE 
+	Name = ARRAY 32 OF CHAR; 
+
+	Command = RECORD 
+		name: Name; 
+		offset: LONGINT; 
+	END; 
+
+	Module = POINTER TO RECORD 
+		name: Name; 
+		key: LONGINT; 
+		dbase, pbase: LONGINT; 
+		size, refcnt: LONGINT; 
+		next: Module; 
+		entries: LONGINT; 
+		entry: ARRAY 256 OF LONGINT; 
+		command: ARRAY 64 OF Command; 
+	END; 
+
+	Linker* = OBJECT 
+	VAR 
+		first, last: Module; 
+		base, heap, descriptorBase, bodyBase: LONGINT; 
+		W: Streams.Writer; 
+		Out: Files.File; 
+		Rout: Files.Writer; 
+		code: ARRAY (256 * 1024) OF LONGINT; 
+		plain, descriptors: BOOLEAN; 
+
+		PROCEDURE ^  & InitLinker*(w: Streams.Writer; plain, descriptors: BOOLEAN); 
+		PROCEDURE ^ SetPos(pos: LONGINT); 
+		PROCEDURE ^ WriteCodeBlock(len, adr: LONGINT); 
+		PROCEDURE ^ Fixup(fixloc, offset, base: LONGINT; VAR entry: ARRAY OF LONGINT); 
+		PROCEDURE ^ FixSelf(fixloc, base: LONGINT); 
+		PROCEDURE ^ ThisMod(VAR modname: ARRAY OF CHAR; VAR success: BOOLEAN): Module; 
+		PROCEDURE ^ Bodies; 
+		PROCEDURE ^ String(VAR str: ARRAY OF CHAR; VAR index: LONGINT); 
+		PROCEDURE ^ ModuleDescriptors; 
+		PROCEDURE ^ AddHeader(fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Begin*(base: LONGINT; fileOut, fileHeader: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ Link*(fileIn: ARRAY OF CHAR; VAR success: BOOLEAN); 
+		PROCEDURE ^ End*; 
+	END Linker; 
+VAR 
+	log: Streams.Writer; 
+
+	PROCEDURE ^ Branch(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BranchLink(dest, pc: LONGINT): LONGINT; 
+	PROCEDURE ^ BodyBranch(m: Module; pc: LONGINT): LONGINT; 
+	PROCEDURE ^ ThisFile(name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ DoLink(linker: Linker; addHeaderFile: BOOLEAN; context: Commands.Context); 
+	PROCEDURE ^ Link*(context: Commands.Context); 
+	PROCEDURE ^ SetLog*(Log: Streams.Writer); 
+BEGIN
+END MinosLinker.

Win32/bin/OZip.SymW

@@ -0,0 +1,14 @@
+MODULE OZip;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, Huffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001455); 
+	Suffix = \".oz"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip.

Win32/bin/OZip2.SymW

@@ -0,0 +1,14 @@
+MODULE OZip2;
+	IMPORT Streams, Commands, Files, Strings, BW := BorrowsWheeler, AH := AdaptiveHuffman;
+CONST 
+	BlockSize* = (8 * 1024); 
+	ComprTag = LONGINT(4278001432); 
+	Suffix = \".oz2"\; 
+
+	PROCEDURE ^ Compress*(r: Streams.Reader; w: Streams.Writer); 
+	PROCEDURE ^ Uncompress*(r: Streams.Reader; w: Streams.Writer): BOOLEAN; 
+	PROCEDURE ^ NewFile(CONST name: ARRAY OF CHAR): Files.File; 
+	PROCEDURE ^ CompressFile*(c: Commands.Context); 
+	PROCEDURE ^ UncompressFile*(c: Commands.Context); 
+BEGIN
+END OZip2.

Win32/bin/PersistentObjects.SymW

@@ -0,0 +1,260 @@
+MODULE PersistentObjects;
+	IMPORT XML, XMLParser, XMLScanner, Basic := FoxBasic, Strings, StringPool, Streams, Commands, FoxBasic, Files, XMLObjects, Modules, D := Debugging;
+CONST 
+	Persistent = 0; 
+	None* =  -1; 
+	EnableTrace = FALSE; 
+TYPE 
+	Translation* = OBJECT 
+	TYPE 
+		Entry = RECORD 
+			name: ARRAY 32 OF CHAR; 
+			key: LONGINT; 
+		END; 
+
+		Table = POINTER TO ARRAY OF Entry; 
+	VAR 
+		table: Table; 
+		len: LONGINT; 
+
+		PROCEDURE ^  & Init*; 
+		PROCEDURE ^ Grow; 
+		PROCEDURE ^ Add*(CONST name: ARRAY OF CHAR; key: LONGINT); 
+		PROCEDURE ^ Key*(CONST name: ARRAY OF CHAR; VAR key: LONGINT): BOOLEAN; 
+		PROCEDURE ^ Name*(index: SIZE; VAR name: ARRAY OF CHAR): BOOLEAN; 
+	END Translation; 
+
+	Action* = PROCEDURE {DELEGATE}(o: Object); 
+
+	Class* = ENUM Char* = 0, Object* = 1, String* = 2, Integer* = 3, Float* = 4, Boolean* = 5, Enum* = 6, Name* = 7, Range* = 8, Set* = 9 END; 
+
+	Name = ARRAY 128 OF CHAR; 
+
+	Content* = OBJECT 
+	VAR 
+		class*: Class; 
+		name*, type*: Name; 
+		string*: Strings.String; 
+		persistent*: BOOLEAN; 
+		object*: Object; 
+		char*: CHAR; 
+		integer*: HUGEINT; 
+		float*: LONGREAL; 
+		boolean*: BOOLEAN; 
+		translation*: Translation; 
+		range*: RANGE; 
+		set*: SET; 
+		success*: BOOLEAN; 
+
+		PROCEDURE ^ SetClass*(class: Class; persistent: BOOLEAN); 
+		PROCEDURE ^ GetChar*(VAR char: CHAR); 
+		PROCEDURE ^ SetChar*(char: CHAR); 
+		PROCEDURE ^ GetString*(VAR string: Strings.String); 
+		PROCEDURE ^ SetString*(string: Strings.String); 
+		PROCEDURE ^ SetAsString*(CONST s: ARRAY OF CHAR); 
+		PROCEDURE ^ Equals*(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ GetName*(VAR name: ARRAY OF CHAR); 
+		PROCEDURE ^ SetName*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ GetInteger*(VAR integer: HUGEINT); 
+		PROCEDURE ^ SetInteger*(integer: SIZE); 
+		PROCEDURE ^ GetSet*(VAR set: SET); 
+		PROCEDURE ^ SetSet*(set: SET); 
+		PROCEDURE ^ GetEnum*(translation: Translation; VAR integer: HUGEINT); 
+		PROCEDURE ^ SetEnum*(translation: Translation; integer: HUGEINT); 
+		PROCEDURE ^ GetRange*(VAR range: RANGE); 
+		PROCEDURE ^ SetRange*(CONST range: RANGE); 
+		PROCEDURE ^ GetFloat*(VAR float: LONGREAL); 
+		PROCEDURE ^ SetFloat*(float: LONGREAL); 
+		PROCEDURE ^ GetBoolean*(VAR boolean: BOOLEAN); 
+		PROCEDURE ^ SetBoolean*(boolean: BOOLEAN); 
+		PROCEDURE ^ GetObject*(VAR object: Object); 
+		PROCEDURE ^ SetObject*(object: Object; CONST optionalType: ARRAY OF CHAR); 
+	END Content; 
+
+	Enumerator* = PROCEDURE {DELEGATE}(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+
+	Interpretation* = POINTER TO RECORD 
+		name-, str-: Strings.String; 
+		next-: Interpretation; 
+	END; 
+
+	Object* = OBJECT 
+	CONST 
+		StrType = \"type"\; 
+	VAR 
+		reader: Reader; 
+		writer: Writer; 
+		content: Content; 
+		action: Action; 
+		firstTranslation-: Interpretation; 
+		type*: ARRAY 64 OF CHAR; 
+
+		PROCEDURE ^  & InitObject*; 
+		PROCEDURE ^ ActionEnumerator(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ AddTranslation*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ FindTranslation*(CONST name: ARRAY OF CHAR; VAR translation: Interpretation): BOOLEAN; 
+		PROCEDURE ^ RemoveTranslation*(CONST name: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ ReadContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ WriteContent*(CONST name: ARRAY OF CHAR; array: BOOLEAN); 
+		PROCEDURE ^ Write*(w: Writer); 
+		PROCEDURE ^ Read*(r: Reader): BOOLEAN; 
+		PROCEDURE ^ Dump*(log: Streams.Writer; CONST name: ARRAY OF CHAR); 
+	END Object; 
+
+	ObjectList* = OBJECT (Object)
+	VAR 
+		list*: FoxBasic.List; 
+		baseType*: Name; 
+
+		PROCEDURE ^  & InitList*(initialSize: LONGINT; CONST baseType: ARRAY OF CHAR); 
+		PROCEDURE ^ Length*(): LONGINT; 
+		PROCEDURE ^ GetElement*(i: LONGINT): Object; 
+		PROCEDURE ^ SetElement*(i: LONGINT; o: Object); 
+		PROCEDURE ^ Enumerate*(enum: Enumerator); 
+		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Set*(CONST name: ARRAY OF CHAR; index: LONGINT; c: Content); 
+		PROCEDURE ^ Add*(o: Object); 
+		PROCEDURE ^ Contains*(o: Object): BOOLEAN; 
+		PROCEDURE ^ Traverse*(action: Action); 
+		PROCEDURE ^ IndexOf*(o: Object): LONGINT; 
+	END ObjectList; 
+
+	Generator = PROCEDURE {DELEGATE}(CONST type: ARRAY OF CHAR):Object; 
+
+	Reader* = OBJECT 
+	VAR 
+		generator: Generator; 
+		error: Streams.Writer; 
+		err-: BOOLEAN; 
+		filename*: Files.FileName; 
+
+		PROCEDURE ^  & InitReader(gen: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ NeedsTranslation(CONST s: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ AttributeNeedingTranslation*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ NameAttribute*(CONST name: ARRAY OF CHAR; VAR str: ARRAY OF CHAR): BOOLEAN; 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; VAR value: BOOLEAN): BOOLEAN; 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; VAR value: LONGREAL): BOOLEAN; 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; VAR value: HUGEINT): BOOLEAN; 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; VAR value: RANGE): BOOLEAN; 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; VAR set: SET): BOOLEAN; 
+	END Reader; 
+
+	Writer* = OBJECT 
+
+		PROCEDURE ^  & InitWriter*; 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+		PROCEDURE ^ StartObjectArray*(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; str: Strings.String); 
+		PROCEDURE ^ IntegerAttribute*(CONST name: ARRAY OF CHAR; value: HUGEINT); 
+		PROCEDURE ^ FloatAttribute*(CONST name: ARRAY OF CHAR; value: LONGREAL); 
+		PROCEDURE ^ BooleanAttribute*(CONST name: ARRAY OF CHAR; value: BOOLEAN); 
+		PROCEDURE ^ EnumAttribute*(CONST name: ARRAY OF CHAR; translation: Translation; value: HUGEINT); 
+		PROCEDURE ^ RangeAttribute*(CONST name: ARRAY OF CHAR; value: RANGE); 
+		PROCEDURE ^ SetAttribute*(CONST name: ARRAY OF CHAR; value: SET); 
+	END Writer; 
+
+	WrittenTable = OBJECT (Basic.HashTable)
+	TYPE 
+		ObjectId = POINTER TO RECORD 
+			num: LONGINT; 
+		END; 
+	VAR 
+		length: LONGINT; 
+
+		PROCEDURE ^ Enter(o: Object; VAR entry: LONGINT): BOOLEAN; 
+	END WrittenTable; 
+
+	XMLWriter* = OBJECT (Writer)
+	VAR 
+		w: Streams.Writer; 
+		document-: XML.Document; 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		written: WrittenTable; 
+
+		PROCEDURE ^  & InitXMLWriter*(writer: Streams.Writer); 
+		PROCEDURE ^ Close*; 
+		PROCEDURE ^ NameAttribute*(CONST name, str: ARRAY OF CHAR); 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; o: Object); 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ WriteObject*(CONST name: ARRAY OF CHAR; index: LONGINT; o: Object); 
+	END XMLWriter; 
+
+	ReadTable = OBJECT (Basic.List)
+
+		PROCEDURE ^ Enter(o: Object); 
+		PROCEDURE ^ GetObject(index: HUGEINT): Object; 
+	END ReadTable; 
+
+	Element = POINTER TO RECORD 
+		index: LONGINT; 
+		e: XML.Element; 
+		next: Element; 
+	END; 
+
+	Symbol = POINTER TO RECORD 
+		name: LONGINT; 
+		first, last: Element; 
+		numberElements: LONGINT; 
+		next: Symbol; 
+	END; 
+
+	Stack = POINTER TO RECORD 
+		container: XML.Container; 
+		symbols: Basic.HashTableInt; 
+		firstSymbol: Symbol; 
+		used: Basic.HashTable; 
+		next: Stack; 
+	END; 
+
+	Scope = OBJECT 
+	VAR 
+		stack: Stack; 
+
+		PROCEDURE ^  & InitScope(c: XML.Container); 
+		PROCEDURE ^ Enter(c: XML.Container); 
+		PROCEDURE ^ Register(c: XML.Container); 
+		PROCEDURE ^ Exit(VAR c: XML.Container); 
+		PROCEDURE ^ Use(o: ANY); 
+		PROCEDURE ^ Used(o: ANY): BOOLEAN; 
+		PROCEDURE ^ AddSymbol(CONST name: ARRAY OF CHAR): Symbol; 
+		PROCEDURE ^ FindElement(CONST name: ARRAY OF CHAR; index: LONGINT): XML.Element; 
+		PROCEDURE ^ PutElement(symbol: Symbol; element: Element); 
+		PROCEDURE ^ EnterElement(e: XML.Element); 
+		PROCEDURE ^ Write(w: Streams.Writer); 
+	END Scope; 
+
+	XMLReader* = OBJECT (Reader)
+	VAR 
+		element: XML.Element; 
+		current: XML.Container; 
+		scope: Scope; 
+		read: ReadTable; 
+
+		PROCEDURE ^ ReportXMLError(pos, line, col: LONGINT; CONST msg: ARRAY OF CHAR); 
+		PROCEDURE ^  & InitXMLReader*(reader: Streams.Reader; generator: Generator); 
+		PROCEDURE ^ Error(CONST s1, s2: ARRAY OF CHAR); 
+		PROCEDURE ^ StringAttribute*(CONST name: ARRAY OF CHAR; VAR str: Strings.String): BOOLEAN; 
+		PROCEDURE ^ Enter(CONST name: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+		PROCEDURE ^ Exit(CONST name: ARRAY OF CHAR); 
+		PROCEDURE ^ CheckUse(o: ANY); 
+		PROCEDURE ^ ReadObject*(CONST name, optionalType: ARRAY OF CHAR; index: LONGINT; VAR o: Object): BOOLEAN; 
+	END XMLReader; 
+
+	PROCEDURE ^ NewXMLWriter*(w: Streams.Writer): Writer; 
+	PROCEDURE ^ NewXMLReader*(r: Streams.Reader; generator: Generator): Reader; 
+	PROCEDURE ^ Clone*(o: Object; gen: Generator): Object; 
+	PROCEDURE ^ Trace*(o: Object); 
+BEGIN
+END PersistentObjects.

Win32/bin/PrecisionTimer.SymW

@@ -0,0 +1,11 @@
+MODULE PrecisionTimer;
+	IMPORT SYSTEM, Kernel32, KernelLog;
+CONST 
+TYPE 
+	Counter* = HUGEINT; 
+
+	PROCEDURE ^ GetCounter*(): Counter; 
+	PROCEDURE ^ GetFrequency*(): Counter; 
+	PROCEDURE ^ InitMod; 
+BEGIN
+END PrecisionTimer.

Win64/bin/AdaptiveHuffman.SymWw

@@ -0,0 +1,81 @@
+MODULE AdaptiveHuffman;
+	IMPORT Streams;
+CONST 
+	AlphabetSize = 256; 
+	BlockSize* = (8 * 1024); 
+	ScaleLimit = (4 * 1024); 
+	Encode = 0; 
+	Decode = 1; 
+TYPE 
+	BitReader = OBJECT 
+	VAR 
+		in: Streams.Reader; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(r: Streams.Reader); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Bit(): LONGINT; 
+	END BitReader; 
+
+	BitWriter = OBJECT 
+	VAR 
+		out: Streams.Writer; 
+		curByte, curBit: LONGINT; 
+
+		PROCEDURE ^  & New(w: Streams.Writer); 
+		PROCEDURE ^ Bit(bit: LONGINT); 
+		PROCEDURE ^ Finish; 
+	END BitWriter; 
+
+	HuffmanCoder = OBJECT 
+	TYPE 
+		Index = INTEGER; 
+
+		Pattern = INTEGER; 
+
+		Node = RECORD 
+			weight: INTEGER; 
+			pattern: Pattern; 
+			up: Index; 
+			down: Index; 
+		END; 
+	VAR 
+		mode: SHORTINT; 
+		in: BitReader; 
+		out: BitWriter; 
+		esc: Index; 
+		root: Index; 
+		map: ARRAY AlphabetSize OF Index; 
+		table: ARRAY ((2 * AlphabetSize) + 2) OF Node; 
+
+		PROCEDURE ^  & New(m: SHORTINT; input: Streams.Reader; output: Streams.Writer); 
+		PROCEDURE ^ Initialize; 
+		PROCEDURE ^ Finish; 
+		PROCEDURE ^ GetPattern(): Pattern; 
+		PROCEDURE ^ PutPattern(patt: Pattern); 
+		PROCEDURE ^ AddPattern(patt: Pattern): Index; 
+		PROCEDURE ^ GroupLeader(node: Index): Index; 
+		PROCEDURE ^ SlideNode(node: Index): Index; 
+		PROCEDURE ^ IncrementWeight(node: Index); 
+		PROCEDURE ^ Scale; 
+		PROCEDURE ^ EncodeByte(ch: CHAR); 
+		PROCEDURE ^ ExtractByte(): CHAR; 
+	END HuffmanCoder; 
+
+	Encoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Writer); 
+		PROCEDURE ^ CompressBlock*(CONST source: ARRAY OF CHAR; len: LONGINT); 
+	END Encoder; 
+
+	Decoder* = OBJECT 
+	VAR 
+		huff: HuffmanCoder; 
+
+		PROCEDURE ^  & New*(archive: Streams.Reader); 
+		PROCEDURE ^ ExtractBlock*(VAR buf: ARRAY OF CHAR; len: LONGINT); 
+	END Decoder; 
+BEGIN
+END AdaptiveHuffman.