rebuilt all releases

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

Linux32/bin/CryptoDES.SymU

@@ -33,13 +33,7 @@ VAR
 	sb1-, sb2-, sb3-, sb4-, sb5-, sb6-, sb7-, sb8-: Sandbox; 
 	LHs, RHs: BitSwap; 
 
-	PROCEDURE  - Split*(x: SET32; VAR i4: Ind4);
-	BEGIN
-		i4.a := (S.VAL(LONGINT, x) MOD 64); 
-		i4.b := ((S.VAL(LONGINT, x) DIV 256) MOD 64); 
-		i4.c := ((S.VAL(LONGINT, x) DIV 65536) MOD 64); 
-		i4.d := ((S.VAL(LONGINT, x) DIV 16777216) MOD 64)
-	END Split; 
+	PROCEDURE ^ Split*(x: SET32; VAR i4: Ind4); 
 	PROCEDURE ^ NewCipher*(): Ciphers.Cipher; 
 	PROCEDURE ^ IP*(VAR x, y: SET32); 
 	PROCEDURE ^ FP*(VAR x, y: SET32); 

Linux32/bin/DisplayRefresher.SymU

@@ -7,6 +7,7 @@ VAR
 
 	PROCEDURE ^ Handle(VAR msg: WMMessages.Message; VAR discard: BOOLEAN); 
 	PROCEDURE ^ Install*; 
+	PROCEDURE ^ Refresh*; 
 	PROCEDURE ^ Cleanup; 
 BEGIN
 END DisplayRefresher.

Linux32/bin/FoxAMDBackend.SymU

@@ -155,6 +155,7 @@ TYPE
 		PROCEDURE ^ SpecialMove(op, back: LONGINT; canStoreToMemory: BOOLEAN; VAR dest, src: Assembler.Operand; type: IntermediateCode.Type); 
 		PROCEDURE ^ ModifyStackPointer(sizeInBytes: HUGEINT); 
 		PROCEDURE ^ IsFloat(CONST operand: IntermediateCode.Operand): BOOLEAN; 
+		PROCEDURE ^ IsVector(CONST operand: IntermediateCode.Operand): BOOLEAN; 
 		PROCEDURE ^ IsComplex(CONST operand: IntermediateCode.Operand): BOOLEAN; 
 		PROCEDURE ^ Generate*(VAR instruction: IntermediateCode.Instruction); 
 		PROCEDURE ^ PostGenerate*(CONST instruction: IntermediateCode.Instruction); 

Linux32/bin/FoxArrayBase.SymU

@@ -54,21 +54,21 @@ CONST
 	MatVec8x8 = SYSTEM.VAL(LONGINT, {SmallMatrixFlag, SmallVectorFlag, Size8Flag}); 
 	SmallArrayMask = {SmallMatrixFlag, SmallVectorFlag, Size2Flag, Size3Flag, Size4Flag, Size5Flag, Size6Flag, Size7Flag, Size8Flag}; 
 TYPE 
-	GenericUnaryAALoopS = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: SHORTINT):SHORTINT); 
+	GenericUnaryAALoopS = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: SHORTINT):SHORTINT); 
 
-	GenericUnaryAALoopI = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: INTEGER):INTEGER); 
+	GenericUnaryAALoopI = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: INTEGER):INTEGER); 
 
-	GenericUnaryAALoopL = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGINT):LONGINT); 
+	GenericUnaryAALoopL = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGINT):LONGINT); 
 
-	GenericUnaryAALoopH = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: HUGEINT):HUGEINT); 
+	GenericUnaryAALoopH = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: HUGEINT):HUGEINT); 
 
-	GenericUnaryAALoopR = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: REAL):REAL); 
+	GenericUnaryAALoopR = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: REAL):REAL); 
 
-	GenericUnaryAALoopX = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGREAL):LONGREAL); 
+	GenericUnaryAALoopX = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGREAL):LONGREAL); 
 
-	GenericUnaryAALoopZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: COMPLEX):COMPLEX); 
+	GenericUnaryAALoopZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: COMPLEX):COMPLEX); 
 
-	GenericUnaryAALoopLZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
+	GenericUnaryAALoopLZ = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGCOMPLEX):LONGCOMPLEX); 
 
 	UnaryAALoop = PROCEDURE (ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
 
@@ -235,14 +235,14 @@ VAR
 	PROCEDURE ^ Reverse(src: ADDRESS; dim: SIZE); 
 	PROCEDURE ^ CopyUpCompatible(dest, src: ADDRESS; VAR modes: SET); 
 	PROCEDURE ^ AllocateTemp(dest: ADDRESS; src: ADDRESS; Size: SIZE): ANY; 
-	PROCEDURE ^ ApplyGenericUnaryAAOpS(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopS; op: PROCEDURE (x: SHORTINT):SHORTINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpI(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopI; op: PROCEDURE (x: INTEGER):INTEGER); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpL(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopL; op: PROCEDURE (x: LONGINT):LONGINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpH(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopH; op: PROCEDURE (x: HUGEINT):HUGEINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpR(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopR; op: PROCEDURE (x: REAL):REAL); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpX(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopX; op: PROCEDURE (x: LONGREAL):LONGREAL); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopZ; op: PROCEDURE (x: COMPLEX):COMPLEX); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpLZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopLZ; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpS(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopS; op: PROCEDURE {DELEGATE}(x: SHORTINT):SHORTINT); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpI(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopI; op: PROCEDURE {DELEGATE}(x: INTEGER):INTEGER); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpL(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopL; op: PROCEDURE {DELEGATE}(x: LONGINT):LONGINT); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpH(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopH; op: PROCEDURE {DELEGATE}(x: HUGEINT):HUGEINT); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpR(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopR; op: PROCEDURE {DELEGATE}(x: REAL):REAL); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpX(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopX; op: PROCEDURE {DELEGATE}(x: LONGREAL):LONGREAL); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopZ; op: PROCEDURE {DELEGATE}(x: COMPLEX):COMPLEX); 
+	PROCEDURE ^ ApplyGenericUnaryAAOpLZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: GenericUnaryAALoopLZ; op: PROCEDURE {DELEGATE}(x: LONGCOMPLEX):LONGCOMPLEX); 
 	PROCEDURE ^ ApplyUnaryAAOp*(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; elementSize: SIZE; Loop: UnaryAALoop); 
 	PROCEDURE ^ ApplyUnaryASOp*(dest: ADDRESS; CONST left: UnsafeArrayT; Loop: UnaryASLoop); 
 	PROCEDURE ^ ApplyUnarySAOp*(VAR dest: UnsafeArrayT; right: ADDRESS; Loop: UnarySALoop); 
@@ -314,14 +314,14 @@ VAR
 	OPERATOR ^ "@Convert"-(CONST src: ARRAY [?] OF SIZE): ARRAY [?] OF REAL; 
 	PROCEDURE ^ NotLoopAB(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
 	OPERATOR ^ "~"-(CONST src: ARRAY [?] OF BOOLEAN): ARRAY [?] OF BOOLEAN; 
-	PROCEDURE ^ GenericLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: SHORTINT):SHORTINT); 
-	PROCEDURE ^ GenericLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: INTEGER):INTEGER); 
-	PROCEDURE ^ GenericLoopL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGINT):LONGINT); 
-	PROCEDURE ^ GenericLoopH(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: HUGEINT):HUGEINT); 
-	PROCEDURE ^ GenericLoopR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: REAL):REAL); 
-	PROCEDURE ^ GenericLoopX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGREAL):LONGREAL); 
-	PROCEDURE ^ GenericLoopZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: COMPLEX):COMPLEX); 
-	PROCEDURE ^ GenericLoopLZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
+	PROCEDURE ^ GenericLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: SHORTINT):SHORTINT); 
+	PROCEDURE ^ GenericLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: INTEGER):INTEGER); 
+	PROCEDURE ^ GenericLoopL(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGINT):LONGINT); 
+	PROCEDURE ^ GenericLoopH(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: HUGEINT):HUGEINT); 
+	PROCEDURE ^ GenericLoopR(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: REAL):REAL); 
+	PROCEDURE ^ GenericLoopX(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGREAL):LONGREAL); 
+	PROCEDURE ^ GenericLoopZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: COMPLEX):COMPLEX); 
+	PROCEDURE ^ GenericLoopLZ(ladr, dadr: ADDRESS; linc, dinc, len: SIZE; op: PROCEDURE {DELEGATE}(x: LONGCOMPLEX):LONGCOMPLEX); 
 	PROCEDURE ^ MinusLoopS(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
 	OPERATOR ^ "-"-(CONST src: ARRAY [?] OF SHORTINT): ARRAY [?] OF SHORTINT; 
 	PROCEDURE ^ MinusLoopI(ladr, dadr: ADDRESS; linc, dinc, len: SIZE); 
@@ -1165,13 +1165,13 @@ VAR
 	PROCEDURE ^ RangeFromInteger*(CONST integer: SIZE): RANGE; 
 	PROCEDURE ^ ExpandDimensions*(CONST sourceArray: ARRAY [?] ; CONST keptDimensions: ARRAY [*] OF BOOLEAN): ARRAY [?] ; 
 	OPERATOR ^ "LEN"-(CONST range: RANGE): SIZE; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF SHORTINT; op: PROCEDURE (x: SHORTINT):SHORTINT): ARRAY [?] OF SHORTINT; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF INTEGER; op: PROCEDURE (x: INTEGER):INTEGER): ARRAY [?] OF INTEGER; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGINT; op: PROCEDURE (x: LONGINT):LONGINT): ARRAY [?] OF LONGINT; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF HUGEINT; op: PROCEDURE (x: HUGEINT):HUGEINT): ARRAY [?] OF HUGEINT; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF REAL; op: PROCEDURE (x: REAL):REAL): ARRAY [?] OF REAL; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGREAL; op: PROCEDURE (x: LONGREAL):LONGREAL): ARRAY [?] OF LONGREAL; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF COMPLEX; op: PROCEDURE (x: COMPLEX):COMPLEX): ARRAY [?] OF COMPLEX; 
-	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGCOMPLEX; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF SHORTINT; op: PROCEDURE {DELEGATE}(x: SHORTINT):SHORTINT): ARRAY [?] OF SHORTINT; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF INTEGER; op: PROCEDURE {DELEGATE}(x: INTEGER):INTEGER): ARRAY [?] OF INTEGER; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGINT; op: PROCEDURE {DELEGATE}(x: LONGINT):LONGINT): ARRAY [?] OF LONGINT; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF HUGEINT; op: PROCEDURE {DELEGATE}(x: HUGEINT):HUGEINT): ARRAY [?] OF HUGEINT; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF REAL; op: PROCEDURE {DELEGATE}(x: REAL):REAL): ARRAY [?] OF REAL; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGREAL; op: PROCEDURE {DELEGATE}(x: LONGREAL):LONGREAL): ARRAY [?] OF LONGREAL; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF COMPLEX; op: PROCEDURE {DELEGATE}(x: COMPLEX):COMPLEX): ARRAY [?] OF COMPLEX; 
+	OPERATOR ^ "ALL"-(CONST x: ARRAY [?] OF LONGCOMPLEX; op: PROCEDURE {DELEGATE}(x: LONGCOMPLEX):LONGCOMPLEX): ARRAY [?] OF LONGCOMPLEX; 
 BEGIN
 END FoxArrayBase.

Linux32/bin/FoxBasic.SymU

@@ -18,7 +18,6 @@ CONST
 	NumberTooLarge* = 270; 
 	IdentifierTooLong* = 271; 
 	StringTooLong* = 272; 
-	InitListSize = 4; 
 	InitErrMsgSize = 300; 
 	invalidString* =  -1; 
 	InvalidCode* =  -1; 
@@ -39,8 +38,6 @@ TYPE
 
 	ObjectArray = POINTER TO ARRAY OF ANY; 
 
-	IntegerArray = POINTER TO ARRAY OF LONGINT; 
-
 	ErrorMsgs = POINTER TO ARRAY OF StringPool.Index; 
 
 	ComparisonFunction = PROCEDURE {DELEGATE}(object1, object2: ANY):BOOLEAN; 
@@ -64,16 +61,16 @@ TYPE
 		PROCEDURE ^  & InitList*(initialSize: LONGINT); 
 		PROCEDURE ^ Length*(): LONGINT; 
 		PROCEDURE ^ Grow; 
-		PROCEDURE ^ Get*(i: LONGINT): ANY; 
-		PROCEDURE ^ Set*(i: LONGINT; x: ANY); 
+		PROCEDURE ^ Get*(i: SIZE): ANY; 
+		PROCEDURE ^ Set*(i: SIZE; x: ANY); 
 		PROCEDURE ^ Add*(x: ANY); 
 		PROCEDURE ^ Prepend*(x: ANY); 
 		PROCEDURE ^ Append*(x: List); 
 		PROCEDURE ^ Remove*(x: ANY); 
-		PROCEDURE ^ RemoveByIndex*(i: LONGINT); 
-		PROCEDURE ^ Insert*(i: LONGINT; x: ANY); 
+		PROCEDURE ^ RemoveByIndex*(i: SIZE); 
+		PROCEDURE ^ Insert*(i: SIZE; x: ANY); 
 		PROCEDURE ^ Replace*(x, y: ANY); 
-		PROCEDURE ^ ReplaceByIndex*(i: LONGINT; x: ANY); 
+		PROCEDURE ^ ReplaceByIndex*(i: SIZE; x: ANY); 
 		PROCEDURE ^ IndexOf*(x: ANY): LONGINT; 
 		PROCEDURE ^ Contains*(x: ANY): BOOLEAN; 
 		PROCEDURE ^ Clear*; 
@@ -82,58 +79,6 @@ TYPE
 		PROCEDURE ^ QuickSort(comparisonFunction: ComparisonFunction; lo, hi: LONGINT); 
 	END List; 
 
-	IntegerList* = OBJECT 
-	VAR 
-		list: IntegerArray; 
-		count-: LONGINT; 
-
-		PROCEDURE ^  & InitList*(initialSize: LONGINT); 
-		PROCEDURE ^ Length*(): LONGINT; 
-		PROCEDURE ^ Grow; 
-		PROCEDURE ^ Get*(i: LONGINT): LONGINT; 
-		PROCEDURE ^ Set*(i: LONGINT; x: LONGINT); 
-		PROCEDURE ^ Add*(x: LONGINT); 
-		PROCEDURE ^ Prepend*(x: LONGINT); 
-		PROCEDURE ^ Append*(x: IntegerList); 
-		PROCEDURE ^ Remove*(x: LONGINT); 
-		PROCEDURE ^ RemoveByIndex*(i: LONGINT); 
-		PROCEDURE ^ Insert*(i, x: LONGINT); 
-		PROCEDURE ^ Replace*(x, y: LONGINT); 
-		PROCEDURE ^ IndexOf*(x: LONGINT): LONGINT; 
-		PROCEDURE ^ Contains*(x: LONGINT): BOOLEAN; 
-		PROCEDURE ^ Clear*; 
-	END IntegerList; 
-
-	Bag* = OBJECT 
-	VAR 
-		count-: LONGINT; 
-		list: List; 
-
-		PROCEDURE ^  & InitBag*; 
-		PROCEDURE ^ Length*(): LONGINT; 
-		PROCEDURE ^ Get*(i: LONGINT): ANY; 
-		PROCEDURE ^ Add*(x: ANY); 
-		PROCEDURE ^ Append*(x: Bag); 
-		PROCEDURE ^ Remove*(x: ANY); 
-		PROCEDURE ^ Contains*(x: ANY): BOOLEAN; 
-		PROCEDURE ^ Clear*; 
-	END Bag; 
-
-	IntegerBag* = OBJECT 
-	VAR 
-		count-: LONGINT; 
-		list: IntegerList; 
-
-		PROCEDURE ^  & InitBag*; 
-		PROCEDURE ^ Length*(): LONGINT; 
-		PROCEDURE ^ Get*(i: LONGINT): LONGINT; 
-		PROCEDURE ^ Add*(x: LONGINT); 
-		PROCEDURE ^ Append*(x: IntegerBag); 
-		PROCEDURE ^ Remove*(x: LONGINT); 
-		PROCEDURE ^ Contains*(x: LONGINT): BOOLEAN; 
-		PROCEDURE ^ Clear*; 
-	END IntegerBag; 
-
 	HashEntryAny = RECORD 
 		key, value: ANY; 
 		valueInt: LONGINT; 
@@ -221,150 +166,6 @@ TYPE
 		PROCEDURE ^ Grow; 
 	END HashTableSegmentedName; 
 
-	HashTable2D* = OBJECT (HashTable)
-	VAR 
-		initialSize: LONGINT; 
-
-		PROCEDURE ^  & Init*(initialSize: LONGINT); 
-		PROCEDURE ^ Get2D*(key1, key2: ANY): ANY; 
-		PROCEDURE ^ Put2D*(key1, key2, value: ANY); 
-		PROCEDURE ^ Has2D*(key1, key2: ANY): BOOLEAN; 
-	END HashTable2D; 
-
-	Stack* = OBJECT 
-	VAR 
-		list: List; 
-
-		PROCEDURE ^  & Init*; 
-		PROCEDURE ^ Push*(x: ANY); 
-		PROCEDURE ^ Peek*(): ANY; 
-		PROCEDURE ^ Pop*(): ANY; 
-		PROCEDURE ^ RemoveTop*; 
-		PROCEDURE ^ Empty*(): BOOLEAN; 
-		PROCEDURE ^ Length*(): LONGINT; 
-	END Stack; 
-
-	IntegerStack* = OBJECT 
-	VAR 
-		list: IntegerList; 
-
-		PROCEDURE ^  & Init*; 
-		PROCEDURE ^ Push*(x: LONGINT); 
-		PROCEDURE ^ Peek*(): LONGINT; 
-		PROCEDURE ^ Pop*(): LONGINT; 
-		PROCEDURE ^ RemoveTop*; 
-		PROCEDURE ^ Empty*(): BOOLEAN; 
-		PROCEDURE ^ Length*(): LONGINT; 
-	END IntegerStack; 
-
-	QueueEntry = POINTER TO RECORD 
-		value: ANY; 
-		next: QueueEntry; 
-	END; 
-
-	Queue* = OBJECT 
-	VAR 
-		top, last: QueueEntry; 
-
-		PROCEDURE ^  & Init*; 
-		PROCEDURE ^ Append*(x: ANY); 
-		PROCEDURE ^ Peek*(): ANY; 
-		PROCEDURE ^ Pop*(): ANY; 
-		PROCEDURE ^ Empty*(): BOOLEAN; 
-	END Queue; 
-
-	PQItem = RECORD 
-		key: LONGINT; 
-		value: ANY; 
-	END; 
-
-	PQItemList = POINTER TO ARRAY OF PQItem; 
-
-	PriorityQueue* = OBJECT 
-	VAR 
-		heap: PQItemList; 
-		count-: LONGINT; 
-
-		PROCEDURE ^  & Init(size: LONGINT); 
-		PROCEDURE ^ Min*(): ANY; 
-		PROCEDURE ^ RemoveMin*(): ANY; 
-		PROCEDURE ^ Insert*(key: LONGINT; value: ANY); 
-		PROCEDURE ^ Empty*(): BOOLEAN; 
-		PROCEDURE ^ BubbleUp(VAR index: LONGINT); 
-		PROCEDURE ^ BubbleDown(index: LONGINT); 
-	END PriorityQueue; 
-
-	IndexList = POINTER TO ARRAY OF LONGINT; 
-
-	Edge* = OBJECT 
-	VAR 
-		from-, to-: Block; 
-
-		PROCEDURE ^ Accept(v: GraphVisitor); 
-	END Edge; 
-
-	Graph* = OBJECT 
-	VAR 
-		firstBlock*, lastBlock-: Block; 
-		blocks*: BlockList; 
-		edges-: EdgeList; 
-		edgesLookup: HashTable2D; 
-
-		PROCEDURE ^  & Init*; 
-		PROCEDURE ^ AddBlock*(block: Block); 
-		PROCEDURE ^ Connect*(from, to: Block); 
-		PROCEDURE ^ Split*(from, to: Block); 
-		PROCEDURE ^ ReIndex*; 
-		PROCEDURE ^ CalculateDominance*; 
-	END Graph; 
-
-	BlockList* = OBJECT (List)
-
-		PROCEDURE ^ GetBlock*(i: LONGINT): Block; 
-		PROCEDURE ^ GetIndex*(i: LONGINT): LONGINT; 
-	END BlockList; 
-
-	EdgeList* = OBJECT (List)
-
-		PROCEDURE ^ GetEdge*(i: LONGINT): Edge; 
-	END EdgeList; 
-
-	Block* = OBJECT 
-	VAR 
-		predecessors-, successors-, dominanceFrontier-: BlockList; 
-		index*, immediateDominator*: LONGINT; 
-
-		PROCEDURE ^  & Init*; 
-		PROCEDURE ^ Accept(v: GraphVisitor); 
-		PROCEDURE ^ PredecessorIndex*(block: Block): LONGINT; 
-	END Block; 
-
-	ContentFunction = PROCEDURE {DELEGATE}(block: Block); 
-
-	GraphVisitor* = OBJECT 
-	VAR 
-		block-: Block; 
-		edge-: Edge; 
-		graph-: Graph; 
-
-		PROCEDURE ^ VisitEdge*(edge: Edge); 
-		PROCEDURE ^ VisitBlock*(block: Block); 
-		PROCEDURE ^ VisitGraph*(graph: Graph); 
-	END GraphVisitor; 
-
-	GraphPrinter* = OBJECT (GraphVisitor)
-	VAR 
-		active-: Block; 
-		writer-: Streams.Writer; 
-		content: ContentFunction; 
-
-		PROCEDURE ^ VisitEdge*(edge: Edge); 
-		PROCEDURE ^ VisitBlock*(block: Block); 
-		PROCEDURE ^ VisitGraph*(graph: Graph); 
-		PROCEDURE ^ SetWriter*(w: Streams.Writer); 
-		PROCEDURE ^  & Init*(c: ContentFunction); 
-	END GraphPrinter; 
-
 	IntegerObject = OBJECT 
 	END IntegerObject; 
 

Linux32/bin/FoxCSharpScanner.SymU

@@ -137,7 +137,7 @@ TYPE
 		identifierString*: IdentifierString; 
 		string*: StringType; 
 		stringLength*: LONGINT; 
-		numberType*: LONGINT; 
+		numberType*: FoxScanner.SubType; 
 		integer*: LONGINT; 
 		hugeint*: HUGEINT; 
 		character*: CHAR; 

Linux32/bin/FoxGlobal.SymU

@@ -234,6 +234,7 @@ TYPE
 		PROCEDURE ^ GenerateParameterOffsets*(procedure: SyntaxTree.Procedure; nestedProcedure: BOOLEAN): BOOLEAN; 
 		PROCEDURE ^ SizeOf*(type: SyntaxTree.Type): LONGINT; 
 		PROCEDURE ^ SizeOfParameter*(par: SyntaxTree.Parameter): LONGINT; 
+		PROCEDURE ^ SizeOfVariable*(var: SyntaxTree.Variable): LONGINT; 
 		PROCEDURE ^ AlignmentOf*(CONST alignment: Alignment; type: SyntaxTree.Type): LONGINT; 
 		PROCEDURE ^ AlignedSizeOf*(type: SyntaxTree.Type): LONGINT; 
 		PROCEDURE ^ IsLynx*(): BOOLEAN; 

Linux32/bin/FoxIntermediateBackend.SymU

@@ -205,22 +205,6 @@ TYPE
 		PROCEDURE ^ GetFreeVariable(type: SyntaxTree.Type; untraced: BOOLEAN; VAR pos: LONGINT): SyntaxTree.Variable; 
 	END Variables; 
 
-	SymbolMap = POINTER TO RECORD 
-		this: SyntaxTree.Symbol; 
-		to, tag: SyntaxTree.Expression; 
-		next: SymbolMap; 
-		isAddress: BOOLEAN; 
-	END; 
-
-	SymbolMapper = OBJECT 
-	VAR 
-		first: SymbolMap; 
-
-		PROCEDURE ^  & Init; 
-		PROCEDURE ^ Add(this: SyntaxTree.Symbol; to, tag: SyntaxTree.Expression; isAddress: BOOLEAN); 
-		PROCEDURE ^ Get(this: SyntaxTree.Symbol): SymbolMap; 
-	END SymbolMapper; 
-
 	ImplementationVisitor = OBJECT (SyntaxTree.Visitor)
 	TYPE 
 		Context = RECORD 
@@ -245,7 +229,6 @@ TYPE
 		position: Position; 
 		moduleSelf: SyntaxTree.Variable; 
 		currentScope: SyntaxTree.Scope; 
-		constantDeclaration: SyntaxTree.Symbol; 
 		result: Operand; 
 		destination: IntermediateCode.Operand; 
 		arrayDestinationTag: IntermediateCode.Operand; 
@@ -276,7 +259,6 @@ TYPE
 		temporaries: Variables; 
 		canBeLoaded: BOOLEAN; 
 		currentIsInline: BOOLEAN; 
-		currentMapper: SymbolMapper; 
 		currentInlineExit: Label; 
 		moduleBodySection: IntermediateCode.Section; 
 		NeedDescriptor: BOOLEAN; 
@@ -401,8 +383,6 @@ TYPE
 		PROCEDURE ^ VisitIndexDesignator*(x: SyntaxTree.IndexDesignator); 
 		PROCEDURE ^ PrepareTensorDescriptor(expression: SyntaxTree.IndexDesignator): SyntaxTree.Variable; 
 		PROCEDURE ^ PushParameter(expression: SyntaxTree.Expression; parameter: SyntaxTree.Parameter; callingConvention: LONGINT; needsParameterBackup: BOOLEAN; VAR parameterBackup: IntermediateCode.Operand; register: WORD); 
-		PROCEDURE ^ VisitStatementDesignator*(x: SyntaxTree.StatementDesignator); 
-		PROCEDURE ^ InlineProcedureCall(x: SyntaxTree.ProcedureCallDesignator): BOOLEAN; 
 		PROCEDURE ^ VisitInlineCallDesignator*(x: SyntaxTree.InlineCallDesignator); 
 		PROCEDURE ^ VisitProcedureCallDesignator*(x: SyntaxTree.ProcedureCallDesignator); 
 		PROCEDURE ^ TypeDescriptorAdr(t: SyntaxTree.Type): IntermediateCode.Operand; 
@@ -462,7 +442,6 @@ TYPE
 		PROCEDURE ^ VisitCharacterValue*(x: SyntaxTree.CharacterValue); 
 		PROCEDURE ^ VisitSetValue*(x: SyntaxTree.SetValue); 
 		PROCEDURE ^ VisitMathArrayValue*(x: SyntaxTree.MathArrayValue); 
-		PROCEDURE ^ TryConstantDeclaration(): BOOLEAN; 
 		PROCEDURE ^ VisitConstant*(x: SyntaxTree.Constant); 
 		PROCEDURE ^ VisitRealValue*(x: SyntaxTree.RealValue); 
 		PROCEDURE ^ VisitComplexValue*(x: SyntaxTree.ComplexValue); 
@@ -484,6 +463,7 @@ TYPE
 		PROCEDURE ^ AssignMathArray(left, right: SyntaxTree.Expression); 
 		PROCEDURE ^ ModifyAssignments(CONST value: IntermediateCode.Operand); 
 		PROCEDURE ^ CopySize(left: SyntaxTree.Expression; tag: IntermediateCode.Operand): IntermediateCode.Operand; 
+		PROCEDURE ^ AssignReference(left, right: SyntaxTree.Expression); 
 		PROCEDURE ^ Assign(left, right: SyntaxTree.Expression); 
 		PROCEDURE ^ VisitAssignment*(x: SyntaxTree.Assignment); 
 		PROCEDURE ^ EmitCooperativeSwitch; 
@@ -636,6 +616,7 @@ VAR
 	statCoopTraceMethod: LONGINT; 
 	statCoopResetProcedure: LONGINT; 
 	statCoopTraceModule: LONGINT; 
+	ResultDesignatorName: SyntaxTree.Identifier; 
 
 	PROCEDURE ^ ResetStatistics*; 
 	PROCEDURE ^ Statistics*; 
@@ -652,6 +633,7 @@ VAR
 	PROCEDURE ^ GetSymbol*(scope: SyntaxTree.ModuleScope; CONST moduleName, symbolName: ARRAY OF CHAR): SyntaxTree.Symbol; 
 	PROCEDURE ^ InitOperand(VAR op: Operand; mode: SHORTINT); 
 	PROCEDURE ^ GetType*(system: Global.System; type: SyntaxTree.Type): IntermediateCode.Type; 
+	PROCEDURE ^ FindConstant(module: SyntaxTree.Module; value: SyntaxTree.Value): SyntaxTree.Constant; 
 	PROCEDURE ^ BuildConstant(module: SyntaxTree.Module; value: SyntaxTree.Value; VAR adr: LONGINT): SyntaxTree.Constant; 
 	PROCEDURE ^ HasPointers(scope: SyntaxTree.ProcedureScope): BOOLEAN; 
 	PROCEDURE ^ IsVariableParameter(parameter: SyntaxTree.Parameter): BOOLEAN; 
@@ -688,6 +670,7 @@ VAR
 	PROCEDURE ^ ToMemoryUnits*(system: Global.System; size: SIZE): LONGINT; 
 	PROCEDURE ^ Get*(): Backend.Backend; 
 	PROCEDURE ^ Nop(position: Basic.Position): IntermediateCode.Instruction; 
+	PROCEDURE ^ Use(position: Basic.Position; reg: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ Mov(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ MovReplace(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ Conv(position: Basic.Position; dest, src: IntermediateCode.Operand): IntermediateCode.Instruction; 
@@ -721,7 +704,7 @@ VAR
 	PROCEDURE ^ Cas(position: Basic.Position; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ Copy(position: Basic.Position; dest, src, size: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ Fill(position: Basic.Position; dest, size, value: IntermediateCode.Operand): IntermediateCode.Instruction; 
-	PROCEDURE ^ Asm(position: Basic.Position; s: SyntaxTree.SourceCode; inRules, outRules: IntermediateCode.Rules): IntermediateCode.Instruction; 
+	PROCEDURE ^ Asm(position: Basic.Position; s: SyntaxTree.SourceCode; inRules, outRules: IntermediateCode.Rules; scope: SyntaxTree.Scope): IntermediateCode.Instruction; 
 	PROCEDURE ^ Data*(position: Basic.Position; op: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ SpecialInstruction(position: Basic.Position; subtype: SHORTINT; op1, op2, op3: IntermediateCode.Operand): IntermediateCode.Instruction; 
 	PROCEDURE ^ Reserve(position: Basic.Position; units: LONGINT): IntermediateCode.Instruction; 

Linux32/bin/FoxIntermediateCode.SymU

@@ -124,6 +124,7 @@ TYPE
 		subtype-: SHORTINT; 
 		textPosition-: Basic.Position; 
 		pc-: LONGINT; 
+		scope-: SyntaxTree.Scope; 
 		op1*, op2*, op3*: Operand; 
 	END; 
 
@@ -206,6 +207,7 @@ VAR
 	PROCEDURE ^ AddOffset*(VAR op: Operand; offset: LONGINT); 
 	PROCEDURE ^ SetOffset*(VAR op: Operand; offset: LONGINT); 
 	PROCEDURE ^ SetSymbol*(VAR op: Operand; symbol: Sections.SectionName; fp: Basic.Fingerprint); 
+	PROCEDURE ^ SetScope*(VAR instr: Instruction; scope: SyntaxTree.Scope); 
 	PROCEDURE ^ SetIntValue*(VAR op: Operand; intValue: HUGEINT); 
 	PROCEDURE ^ MakeMemory*(VAR op: Operand; type: Type); 
 	PROCEDURE ^ MakeAddress*(VAR op: Operand; CONST type: Type);