rebuilt releases

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

Linux32/bin/A2Sequencers.SymU

@@ -6,7 +6,7 @@ CONST
 TYPE 
 	Property* = OBJECT 
 	VAR 
-		locks: LONGINT; 
+		locks: WORD; 
 		container*: OBJECT; 
 
 		PROCEDURE ^  & InitProperty; 
@@ -32,15 +32,15 @@ TYPE
 
 	Integer* = OBJECT (Property)
 	VAR 
-		value: LONGINT; 
+		value: WORD; 
 		handlers: ARRAY MaxHandlers OF IntegerHandler; 
 
-		PROCEDURE ^  & InitInteger*(value: LONGINT); 
-		PROCEDURE ^ Get*(): LONGINT; 
-		PROCEDURE ^ Set*(value: LONGINT); 
-		PROCEDURE ^ Inc*(step: LONGINT); 
-		PROCEDURE ^ Dec*(step: LONGINT); 
-		PROCEDURE ^ Changed(value: LONGINT); 
+		PROCEDURE ^  & InitInteger*(value: WORD); 
+		PROCEDURE ^ Get*(): WORD; 
+		PROCEDURE ^ Set*(value: WORD); 
+		PROCEDURE ^ Inc*(step: WORD); 
+		PROCEDURE ^ Dec*(step: WORD); 
+		PROCEDURE ^ Changed(value: WORD); 
 		PROCEDURE ^ AddHandler*(handler: IntegerHandler); 
 	END Integer; 
 
@@ -64,8 +64,8 @@ TYPE
 		PROCEDURE ^  & InitSet*(value: SET); 
 		PROCEDURE ^ Get*(): SET; 
 		PROCEDURE ^ Set*(value: SET); 
-		PROCEDURE ^ Incl*(element: LONGINT); 
-		PROCEDURE ^ Excl*(element: LONGINT); 
+		PROCEDURE ^ Incl*(element: WORD); 
+		PROCEDURE ^ Excl*(element: WORD); 
 		PROCEDURE ^ Changed(value: SET); 
 		PROCEDURE ^ AddHandler*(handler: SetHandler); 
 	END Set; 
@@ -75,7 +75,7 @@ TYPE
 		value: POINTER TO ARRAY OF CHAR; 
 		handlers: ARRAY MaxHandlers OF StringHandler; 
 
-		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR; length: LONGINT); 
+		PROCEDURE ^  & InitString*(CONST value: ARRAY OF CHAR; length: SIZE); 
 		PROCEDURE ^ Get*(VAR value: ARRAY OF CHAR); 
 		PROCEDURE ^ Set*(CONST value: ARRAY OF CHAR); 
 		PROCEDURE ^ Changed(CONST value: ARRAY OF CHAR); 
@@ -110,19 +110,19 @@ TYPE
 
 	IntegerMessage* = OBJECT (Message)
 	VAR 
-		value: LONGINT; 
+		value: WORD; 
 		procedure: IntegerProcedure; 
 
-		PROCEDURE ^  & InitIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^  & InitIntegerMessage*(value: WORD; procedure: IntegerProcedure); 
 		PROCEDURE ^ Handle*; 
 	END IntegerMessage; 
 
 	IntegerIntegerMessage* = OBJECT (Message)
 	VAR 
-		value0, value1: LONGINT; 
+		value0, value1: WORD; 
 		procedure: IntegerIntegerProcedure; 
 
-		PROCEDURE ^  & InitIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^  & InitIntegerIntegerMessage*(value0, value1: WORD; procedure: IntegerIntegerProcedure); 
 		PROCEDURE ^ Handle*; 
 	END IntegerIntegerMessage; 
 
@@ -164,10 +164,10 @@ TYPE
 
 	IntegerRequest* = OBJECT {EXCLUSIVE} (Request)
 	VAR 
-		value: LONGINT; 
+		value: WORD; 
 		procedure: IntegerProcedure; 
 
-		PROCEDURE ^  & InitIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^  & InitIntegerRequest*(value: WORD; procedure: IntegerProcedure); 
 		PROCEDURE ^ Handle*; 
 	END IntegerRequest; 
 
@@ -183,7 +183,7 @@ TYPE
 	RequestInteger* = OBJECT {EXCLUSIVE} (Request)
 	VAR 
 		procedure: ProcedureInteger; 
-		result-: LONGINT; 
+		result-: WORD; 
 
 		PROCEDURE ^  & InitRequestInteger*(procedure: ProcedureInteger); 
 		PROCEDURE ^ Handle*; 
@@ -200,11 +200,11 @@ TYPE
 
 	IntegerRequestBoolean* = OBJECT {EXCLUSIVE} (Request)
 	VAR 
-		value: LONGINT; 
+		value: WORD; 
 		procedure: IntegerProcedureBoolean; 
 		result-: BOOLEAN; 
 
-		PROCEDURE ^  & InitIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean); 
+		PROCEDURE ^  & InitIntegerRequestBoolean*(value: WORD; procedure: IntegerProcedureBoolean); 
 		PROCEDURE ^ Handle*; 
 	END IntegerRequestBoolean; 
 
@@ -212,7 +212,7 @@ TYPE
 	VAR 
 		value: REAL; 
 		procedure: RealProcedureInteger; 
-		result-: LONGINT; 
+		result-: WORD; 
 
 		PROCEDURE ^  & InitRealRequestInteger*(value: REAL; procedure: RealProcedureInteger); 
 		PROCEDURE ^ Handle*; 
@@ -230,17 +230,17 @@ TYPE
 		PROCEDURE ^ Add*(message: Message; time: LONGINT); 
 		PROCEDURE ^ AddMessage*(procedure: Procedure); 
 		PROCEDURE ^ AddBooleanMessage*(value: BOOLEAN; procedure: BooleanProcedure); 
-		PROCEDURE ^ AddIntegerMessage*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddIntegerMessage*(value: WORD; procedure: IntegerProcedure); 
 		PROCEDURE ^ AddRealMessage*(value: REAL; procedure: RealProcedure); 
 		PROCEDURE ^ AddSetMessage*(value: SET; procedure: SetProcedure); 
 		PROCEDURE ^ AddStringMessage*(CONST value: ARRAY OF CHAR; procedure: StringProcedure); 
-		PROCEDURE ^ AddIntegerIntegerMessage*(value0, value1: LONGINT; procedure: IntegerIntegerProcedure); 
-		PROCEDURE ^ AddIntegerRequest*(value: LONGINT; procedure: IntegerProcedure); 
+		PROCEDURE ^ AddIntegerIntegerMessage*(value0, value1: WORD; procedure: IntegerIntegerProcedure); 
+		PROCEDURE ^ AddIntegerRequest*(value: WORD; procedure: IntegerProcedure); 
 		PROCEDURE ^ AddRequestBoolean*(procedure: ProcedureBoolean): BOOLEAN; 
-		PROCEDURE ^ AddRequestInteger*(procedure: ProcedureInteger): LONGINT; 
+		PROCEDURE ^ AddRequestInteger*(procedure: ProcedureInteger): WORD; 
 		PROCEDURE ^ AddRequestReal*(procedure: ProcedureReal): REAL; 
-		PROCEDURE ^ AddIntegerRequestBoolean*(value: LONGINT; procedure: IntegerProcedureBoolean): BOOLEAN; 
-		PROCEDURE ^ AddRealRequestInteger*(value: REAL; procedure: RealProcedureInteger): LONGINT; 
+		PROCEDURE ^ AddIntegerRequestBoolean*(value: WORD; procedure: IntegerProcedureBoolean): BOOLEAN; 
+		PROCEDURE ^ AddRealRequestInteger*(value: REAL; procedure: RealProcedureInteger): WORD; 
 		PROCEDURE ^ Remove*(message: Message); 
 		PROCEDURE ^ Handle*; 
 		PROCEDURE ^ Wakeup; 
@@ -250,7 +250,7 @@ TYPE
 
 	BooleanHandler = PROCEDURE {DELEGATE}(property: Boolean; value: BOOLEAN); 
 
-	IntegerHandler = PROCEDURE {DELEGATE}(property: Integer; value: LONGINT); 
+	IntegerHandler = PROCEDURE {DELEGATE}(property: Integer; value: WORD); 
 
 	RealHandler = PROCEDURE {DELEGATE}(property: Real; value: REAL); 
 
@@ -262,9 +262,9 @@ TYPE
 
 	BooleanProcedure = PROCEDURE {DELEGATE}(value: BOOLEAN); 
 
-	IntegerProcedure = PROCEDURE {DELEGATE}(value: LONGINT); 
+	IntegerProcedure = PROCEDURE {DELEGATE}(value: WORD); 
 
-	IntegerIntegerProcedure = PROCEDURE {DELEGATE}(value0, value1: LONGINT); 
+	IntegerIntegerProcedure = PROCEDURE {DELEGATE}(value0, value1: WORD); 
 
 	RealProcedure = PROCEDURE {DELEGATE}(value: REAL); 
 
@@ -274,13 +274,13 @@ TYPE
 
 	ProcedureBoolean = PROCEDURE {DELEGATE}():BOOLEAN; 
 
-	ProcedureInteger = PROCEDURE {DELEGATE}():LONGINT; 
+	ProcedureInteger = PROCEDURE {DELEGATE}():WORD; 
 
 	ProcedureReal = PROCEDURE {DELEGATE}():REAL; 
 
-	IntegerProcedureBoolean = PROCEDURE {DELEGATE}(value: LONGINT):BOOLEAN; 
+	IntegerProcedureBoolean = PROCEDURE {DELEGATE}(value: WORD):BOOLEAN; 
 
-	RealProcedureInteger = PROCEDURE {DELEGATE}(value: REAL):LONGINT; 
+	RealProcedureInteger = PROCEDURE {DELEGATE}(value: REAL):WORD; 
 
 	PROCEDURE ^ Delay*(delay: LONGINT): LONGINT; 
 BEGIN

Linux32/bin/Commands.SymU

@@ -19,7 +19,7 @@ TYPE
 		in-, arg-: Streams.Reader; 
 		out-, error-: Streams.Writer; 
 		caller-: OBJECT; 
-		result*: LONGINT; 
+		result*: WORD; 
 
 		PROCEDURE ^  & Init*(in, arg: Streams.Reader; out, error: Streams.Writer; caller: OBJECT); 
 	END Context; 
@@ -53,11 +53,11 @@ TYPE
 		msg: ARRAY 128 OF CHAR; 
 		res: WORD; 
 		module: Modules.Module; 
-		state: LONGINT; 
+		state: WORD; 
 		exception: BOOLEAN; 
 
 		PROCEDURE ^  & Init*(CONST moduleName, commandName: Modules.Name; context: Context); 
-		PROCEDURE ^ Join(this: LONGINT; VAR res: WORD; VAR msg: ARRAY OF CHAR); 
+		PROCEDURE ^ Join(this: WORD; VAR res: WORD; VAR msg: ARRAY OF CHAR); 
 	BEGIN{ACTIVE, SAFE} 
 	END Runner; 
 VAR 

Linux32/bin/Debugging.SymU

@@ -16,10 +16,10 @@ VAR
 	PROCEDURE ^ Str*(CONST name: ARRAY OF CHAR); 
 	PROCEDURE ^ String*(CONST name: ARRAY OF CHAR); 
 	PROCEDURE ^ Address*(i: ADDRESS); 
-	PROCEDURE ^ Int*(i, j: LONGINT); 
+	PROCEDURE ^ Int*(i: HUGEINT; j: WORD); 
 	PROCEDURE ^ Set*(set: SET); 
-	PROCEDURE ^ Float*(r: LONGREAL; len: LONGINT); 
-	PROCEDURE ^ Hex*(i: HUGEINT; j: LONGINT); 
+	PROCEDURE ^ Float*(r: LONGREAL; len: WORD); 
+	PROCEDURE ^ Hex*(i: HUGEINT; j: WORD); 
 	PROCEDURE ^ HIntHex*(x: HUGEINT); 
 	PROCEDURE ^ Char*(c: CHAR); 
 	PROCEDURE ^ Update*; 

Linux32/bin/Diagnostics.SymU

@@ -16,7 +16,7 @@ TYPE
 	END Diagnostics; 
 
 	Entry* = POINTER TO RECORD 
-		type*: LONGINT; 
+		type*: WORD; 
 		source*: ARRAY 128 OF CHAR; 
 		position*, errorCode*: LONGINT; 
 		message*: ARRAY 256 OF CHAR; 
@@ -30,10 +30,10 @@ TYPE
 	DiagnosticsList* = OBJECT {EXCLUSIVE} (Diagnostics)
 	VAR 
 		entries-: Entry; 
-		nofErrors-: LONGINT; 
-		nofWarnings-: LONGINT; 
-		nofInformations-: LONGINT; 
-		nofMessages-: LONGINT; 
+		nofErrors-: SIZE; 
+		nofWarnings-: SIZE; 
+		nofInformations-: SIZE; 
+		nofMessages-: SIZE; 
 
 		PROCEDURE ^ Error*(CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR); 
 		PROCEDURE ^ Warning*(CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR); 
@@ -42,8 +42,8 @@ TYPE
 		PROCEDURE ^  & Reset*; 
 		PROCEDURE ^ ForAll*(proc: EnumProc); 
 		PROCEDURE ^ GetEntries*(): EntryArray; 
-		PROCEDURE ^ InsertSorted(type: LONGINT; CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR; VAR counter: LONGINT); 
-		PROCEDURE ^ NewEntry*(type: LONGINT; CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR; next: Entry): Entry; 
+		PROCEDURE ^ InsertSorted(type: WORD; CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR; VAR counter: SIZE); 
+		PROCEDURE ^ NewEntry*(type: WORD; CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR; next: Entry): Entry; 
 	END DiagnosticsList; 
 
 	StreamDiagnostics* = OBJECT (Diagnostics)
@@ -56,6 +56,6 @@ TYPE
 		PROCEDURE ^ Information*(CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; CONST message: ARRAY OF CHAR); 
 	END StreamDiagnostics; 
 
-	PROCEDURE ^ Print(w: Streams.Writer; CONST source: ARRAY OF CHAR; position, errorCode, type: LONGINT; CONST message: ARRAY OF CHAR); 
+	PROCEDURE ^ Print(w: Streams.Writer; CONST source: ARRAY OF CHAR; position, errorCode: LONGINT; type: WORD; CONST message: ARRAY OF CHAR); 
 BEGIN
 END Diagnostics.

Linux32/bin/FoxArrayBase.SymU

@@ -216,7 +216,7 @@ VAR
 	PROCEDURE ^ Align(value: ADDRESS): ADDRESS; 
 	PROCEDURE ^ GetPtr(base: UnsafeArray): ANY; 
 	PROCEDURE ^ SafePut(VAR dest: ANY; src: ANY); 
-	PROCEDURE ^ PutPtr(CONST base: UnsafeArray; value: ANY); 
+	PROCEDURE ^ PutPtr(CONST base: UnsafeArrayT; value: ANY); 
 	PROCEDURE ^ GetSize(base: UnsafeArray): SIZE; 
 	PROCEDURE ^ PutSize(base: UnsafeArray; val: SIZE); 
 	PROCEDURE ^ GetDim(base: UnsafeArray): SIZE; 
@@ -233,16 +233,16 @@ 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: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopS; op: PROCEDURE (x: SHORTINT):SHORTINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpI(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopI; op: PROCEDURE (x: INTEGER):INTEGER); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpL(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopL; op: PROCEDURE (x: LONGINT):LONGINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpH(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopH; op: PROCEDURE (x: HUGEINT):HUGEINT); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpR(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopR; op: PROCEDURE (x: REAL):REAL); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpX(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopX; op: PROCEDURE (x: LONGREAL):LONGREAL); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopZ; op: PROCEDURE (x: COMPLEX):COMPLEX); 
-	PROCEDURE ^ ApplyGenericUnaryAAOpLZ(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: GenericUnaryAALoopLZ; op: PROCEDURE (x: LONGCOMPLEX):LONGCOMPLEX); 
-	PROCEDURE ^ ApplyUnaryAAOp(VAR dest: UnsafeArrayT; CONST left: UnsafeArray; elementSize: SIZE; Loop: UnaryAALoop); 
-	PROCEDURE ^ ApplyUnaryASOp(dest: ADDRESS; CONST left: UnsafeArray; Loop: UnaryASLoop); 
+	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 ^ 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); 
 	PROCEDURE ^ ApplyBinaryAAAOp(VAR dest: UnsafeArrayT; CONST left, right: UnsafeArrayT; elementSize: SIZE; Loop: BinaryAAALoop); 
 	PROCEDURE ^ ApplyBinaryASAOp(VAR dest: UnsafeArrayT; CONST left: UnsafeArrayT; right: ADDRESS; elementSize: SIZE; Loop: BinaryASALoop); 
@@ -1139,7 +1139,7 @@ VAR
 	OPERATOR ^ "`"-(CONST left: ARRAY [*, *] OF LONGREAL): ARRAY [*, *] OF LONGREAL; 
 	PROCEDURE ^ CheckTensorGeometry(left, right, dest: ADDRESS; ldim, rdim: SIZE): BOOLEAN; 
 	PROCEDURE ^ DoReshape*(VAR dest: UnsafeArrayT; CONST src: UnsafeArrayT; CONST shape: ARRAY [*] OF SIZE); 
-	PROCEDURE ^ AllocateTensorA*(CONST a: ARRAY OF SIZE; elementSize: SIZE; tag: ADDRESS; VAR dest: UnsafeArray); 
+	PROCEDURE ^ AllocateTensorA*(CONST a: ARRAY OF SIZE; elementSize: SIZE; tag: ADDRESS; VAR dest: UnsafeArrayT); 
 	PROCEDURE ^ AllocateArrayA*(CONST a: ARRAY OF SIZE; elementSize: SIZE; tag: ADDRESS; dest: UnsafeArray); 
 	PROCEDURE ^ DoAllocateTensorX*(VAR dest: UnsafeArrayT; CONST a: ARRAY [*] OF SIZE; Size: SIZE; tag: ADDRESS); 
 	PROCEDURE ^ AllocateTensorX(VAR dest: ARRAY [?] OF SIZE; CONST a: ARRAY [*] OF SIZE; Size: SIZE; tag: ADDRESS); 

Linux32/bin/In.SymU

@@ -3,7 +3,7 @@ MODULE In;
 
 	PROCEDURE ^ GetArg*(): Streams.Reader; 
 	PROCEDURE ^ Char*(VAR ch: CHAR): BOOLEAN; 
-	PROCEDURE ^ Int*(VAR i: LONGINT; hex= TRUE: BOOLEAN): BOOLEAN; 
+	PROCEDURE ^ Int*(VAR i: WORD; hex= TRUE: BOOLEAN): BOOLEAN; 
 	PROCEDURE ^ Real*(VAR f: LONGREAL): BOOLEAN; 
 	PROCEDURE ^ String*(VAR s: ARRAY OF CHAR): BOOLEAN; 
 BEGIN

Linux32/bin/Joysticks.SymU

@@ -133,7 +133,7 @@ VAR
 	registry-: Plugins.Registry; 
 	nextId: LONGINT; 
 
-	PROCEDURE ^ EventHandler(event: LONGINT; plugin: Plugins.Plugin); 
+	PROCEDURE ^ EventHandler(event: WORD; plugin: Plugins.Plugin); 
 	PROCEDURE ^ GetId(): LONGINT; 
 	PROCEDURE ^ Round(value: REAL): LONGINT; 
 	PROCEDURE ^ GetAxisName*(axisNbr: LONGINT; VAR name: ARRAY OF CHAR); 

Linux32/bin/KernelLog.SymU

@@ -7,21 +7,20 @@ VAR
 	traceBufAdr: ADDRESS; 
 	traceBufSize: SIZE; 
 	traceHead, traceTail: ADDRESS; 
-	column*: LONGINT; 
 
 	PROCEDURE ^ Send*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT; propagate: BOOLEAN; VAR res: WORD); 
 	PROCEDURE ^ String*(CONST s: ARRAY OF CHAR); 
 	PROCEDURE ^ Ln*; 
 	PROCEDURE ^ Char*(c: CHAR); 
-	PROCEDURE ^ Int*(x: HUGEINT; w: LONGINT); 
+	PROCEDURE ^ Int*(x: HUGEINT; w: WORD); 
 	PROCEDURE ^ Boolean*(x: BOOLEAN); 
-	PROCEDURE ^ IntSuffix*(x, w: LONGINT; CONST suffix: ARRAY OF CHAR); 
-	PROCEDURE ^ Hex*(x: HUGEINT; w: LONGINT); 
+	PROCEDURE ^ IntSuffix*(x: HUGEINT; w: WORD; CONST suffix: ARRAY OF CHAR); 
+	PROCEDURE ^ Hex*(x: HUGEINT; w: WORD); 
 	PROCEDURE ^ Address*(x: ADDRESS); 
-	PROCEDURE ^ HIntHex*(x: HUGEINT; w: LONGINT); 
+	PROCEDURE ^ HIntHex*(x: HUGEINT; w: WORD); 
 	PROCEDURE ^ Memory*(adr: ADDRESS; size: SIZE); 
-	PROCEDURE ^ Buffer*(CONST buf: ARRAY OF CHAR; ofs, len: LONGINT); 
-	PROCEDURE ^ Bits*(x: SET; ofs, n: LONGINT); 
+	PROCEDURE ^ Buffer*(CONST buf: ARRAY OF CHAR; ofs, len: SIZE); 
+	PROCEDURE ^ Bits*(x: SET; ofs, n: WORD); 
 	PROCEDURE ^ Set*(x: SET); 
 	PROCEDURE ^ Enter*; 
 	PROCEDURE ^ Exit*; 

Linux32/bin/Locks.SymU

@@ -15,7 +15,7 @@ TYPE
 
 	RecursiveLock* = OBJECT {EXCLUSIVE} 
 	VAR 
-		lockLevel: LONGINT; 
+		lockLevel: SIZE; 
 		lockedBy: ANY; 
 
 		PROCEDURE ^  & New*; 
@@ -28,27 +28,27 @@ TYPE
 
 	ReaderLockInfo = RECORD 
 		owner: ANY; 
-		lockLevel: LONGINT; 
+		lockLevel: SIZE; 
 	END; 
 
 	ReaderLockList = POINTER TO ARRAY OF ReaderLockInfo; 
 
 	RWLock* = OBJECT {EXCLUSIVE} 
 	VAR 
-		lockLevel: LONGINT; 
+		lockLevel: SIZE; 
 		lockedBy: ANY; 
 		lastReader: ANY; 
-		nofReaders: LONGINT; 
+		nofReaders: SIZE; 
 		readers: ReaderLockList; 
 		wlReleaseHandler: LockReleasedHandler; 
 		DEADLOCK: BOOLEAN; 
-		nofReadLocks, nofWriteLocks: LONGINT; 
+		nofReadLocks, nofWriteLocks: SIZE; 
 
 		PROCEDURE ^  & New*; 
 		PROCEDURE ^ AcquireWrite*; 
 		PROCEDURE ^ ReleaseWrite*; 
 		PROCEDURE ^ HasWriteLock*(): BOOLEAN; 
-		PROCEDURE ^ GetWLockLevel*(): LONGINT; 
+		PROCEDURE ^ GetWLockLevel*(): SIZE; 
 		PROCEDURE ^ SetLockReleasedHandler*(handler: LockReleasedHandler); 
 		PROCEDURE ^ AcquireRead*; 
 		PROCEDURE ^ ReleaseRead*; 

Linux32/bin/Out.SymU

@@ -6,9 +6,9 @@ MODULE Out;
 	PROCEDURE ^ Char*(c: CHAR); 
 	PROCEDURE ^ Ln*; 
 	PROCEDURE ^ Set*(s: SET); 
-	PROCEDURE ^ Int*(i: HUGEINT; n= 1: LONGINT); 
-	PROCEDURE ^ Hex*(i: HUGEINT; n=  -16: LONGINT); 
+	PROCEDURE ^ Int*(i: HUGEINT; n= 1: WORD); 
+	PROCEDURE ^ Hex*(i: HUGEINT; n=  -16: WORD); 
 	PROCEDURE ^ Address*(a: ADDRESS); 
-	PROCEDURE ^ Float*(x: LONGREAL; n= 4, f= 3, d= 0: LONGINT); 
+	PROCEDURE ^ Float*(x: LONGREAL; n= 4, f= 3, d= 0: WORD); 
 BEGIN
 END Out.

Linux32/bin/PartitionsLib.SymU

@@ -108,7 +108,7 @@ TYPE
 		PROCEDURE ^ UpdateDiskInternal(i: LONGINT); 
 		PROCEDURE ^ Acquire*; 
 		PROCEDURE ^ Release*; 
-		PROCEDURE ^ DiskEventHandler(event: LONGINT; plugin: Plugins.Plugin); 
+		PROCEDURE ^ DiskEventHandler(event: WORD; plugin: Plugins.Plugin); 
 		PROCEDURE ^ GetTableGeometry(dev: AosDisks.Device; VAR hds, spt: LONGINT): BOOLEAN; 
 		PROCEDURE ^ GetGeometry(disk: Disk; VAR geo: AosDisks.GetGeometryMsg; VAR res: WORD); 
 		PROCEDURE ^ NewFree(type: LONGINT; VAR table: AosDisks.PartitionTable; start, size, ptblock: LONGINT; flags: SET); 

Linux32/bin/Plugins.SymU

@@ -23,7 +23,7 @@ TYPE
 
 	PluginHandler* = PROCEDURE {DELEGATE}(p: Plugin); 
 
-	EventHandler* = PROCEDURE {DELEGATE}(event: LONGINT; plugin: Plugin); 
+	EventHandler* = PROCEDURE {DELEGATE}(event: WORD; plugin: Plugin); 
 
 	EventHandlerList = POINTER TO RECORD 
 		next: EventHandlerList; 
@@ -35,7 +35,7 @@ TYPE
 	Registry* = OBJECT {EXCLUSIVE} (Plugin)
 	VAR 
 		root: Plugin; 
-		added: LONGINT; 
+		added: SIZE; 
 		handlers: EventHandlerList; 
 
 		PROCEDURE ^ Get*(CONST name: ARRAY OF CHAR): Plugin; 
@@ -51,7 +51,7 @@ TYPE
 VAR 
 	main*: Registry; 
 
-	PROCEDURE ^ AppendInt(x: LONGINT; VAR to: ARRAY OF CHAR); 
-	PROCEDURE ^ GenName(n: LONGINT; VAR registry, plugin: Name); 
+	PROCEDURE ^ AppendInt(x: SIZE; VAR to: ARRAY OF CHAR); 
+	PROCEDURE ^ GenName(n: SIZE; VAR registry, plugin: Name); 
 BEGIN
 END Plugins.

Linux32/bin/Reflection.SymU

@@ -80,7 +80,7 @@ TYPE
 	Search = RECORD 
 		name: ARRAY 256 OF CHAR; 
 		nameOffset: SIZE; 
-		minLevel: LONGINT; 
+		minLevel: SIZE; 
 		pc: ADDRESS; 
 		pos: SIZE; 
 		found: BOOLEAN; 
@@ -125,12 +125,12 @@ VAR
 	PROCEDURE ^ SkipTypeDeclaration*(refs: Modules.Bytes; VAR offset: SIZE); 
 	PROCEDURE ^ SkipModule*(refs: Modules.Bytes; VAR offset: SIZE); 
 	PROCEDURE ^ SkipScope*(refs: Modules.Bytes; VAR offset: SIZE); 
-	PROCEDURE ^ FindString(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
-	PROCEDURE ^ FindInProcedure(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
-	PROCEDURE ^ FindInVariable(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
-	PROCEDURE ^ FindInTypeDeclaration(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
-	PROCEDURE ^ FindInModule(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
-	PROCEDURE ^ FindInScope(refs: Modules.Bytes; VAR offset: SIZE; level: LONGINT; VAR find: Search); 
+	PROCEDURE ^ FindString(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
+	PROCEDURE ^ FindInProcedure(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
+	PROCEDURE ^ FindInVariable(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
+	PROCEDURE ^ FindInTypeDeclaration(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
+	PROCEDURE ^ FindInModule(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
+	PROCEDURE ^ FindInScope(refs: Modules.Bytes; VAR offset: SIZE; level: SIZE; VAR find: Search); 
 	PROCEDURE ^ InitSearch(VAR search: Search); 
 	PROCEDURE ^ FindByName*(refs: Modules.Bytes; offset: SIZE; CONST name: ARRAY OF CHAR; skipFirstSymbol: BOOLEAN): SIZE; 
 	PROCEDURE ^ FindByAdr*(refs: Modules.Bytes; offset: SIZE; pc: ADDRESS): SIZE; 

Linux32/bin/RelativeFileSystem.SymU

@@ -14,10 +14,10 @@ TYPE
 		PROCEDURE ^ New0*(name: ARRAY OF CHAR): Files.File; 
 		PROCEDURE ^ Old0*(name: ARRAY OF CHAR): Files.File; 
 		PROCEDURE ^ CreateDirectory0*(name: ARRAY OF CHAR; VAR res: WORD); 
-		PROCEDURE ^ Delete0*(name: ARRAY OF CHAR; VAR key, res: LONGINT); 
+		PROCEDURE ^ Delete0*(name: ARRAY OF CHAR; VAR key: LONGINT; VAR res: WORD); 
 		PROCEDURE ^ Enumerate0*(mask: ARRAY OF CHAR; flags: SET; enum: Files.Enumerator); 
 		PROCEDURE ^ FileKey*(name: ARRAY OF CHAR): LONGINT; 
-		PROCEDURE ^ RemoveDirectory0*(name: ARRAY OF CHAR; force: BOOLEAN; VAR key, res: LONGINT); 
+		PROCEDURE ^ RemoveDirectory0*(name: ARRAY OF CHAR; force: BOOLEAN; VAR key: LONGINT; VAR res: WORD); 
 		PROCEDURE ^ Rename0*(old, new: ARRAY OF CHAR; f: Files.File; VAR res: WORD); 
 	END FileSystem; 
 

Linux32/bin/Streams.SymU

@@ -66,8 +66,8 @@ TYPE
 		PROCEDURE ^ Pair(ch: CHAR; x: LONGINT); 
 		PROCEDURE ^ Date*(t, d: LONGINT); 
 		PROCEDURE ^ Date822*(t, d, tz: LONGINT); 
-		PROCEDURE ^ Float*(x: LONGREAL; n: LONGINT); 
-		PROCEDURE ^ FloatFix*(x: LONGREAL; n, f, D: LONGINT); 
+		PROCEDURE ^ Float*(x: LONGREAL; n: WORD); 
+		PROCEDURE ^ FloatFix*(x: LONGREAL; n, f, D: WORD); 
 	END Writer; 
 
 	StringWriter* = OBJECT (Writer)

Linux32/bin/Strings.SymU

@@ -29,20 +29,20 @@ VAR
 	PROCEDURE ^ Length*(CONST string: ARRAY OF CHAR): LONGINT; 
 	PROCEDURE ^ Find*(CONST string: ARRAY OF CHAR; pos: LONGINT; ch: CHAR): LONGINT; 
 	PROCEDURE ^ Count*(CONST string: ARRAY OF CHAR; ch: CHAR): LONGINT; 
-	PROCEDURE ^ Truncate*(VAR string: ARRAY OF CHAR; length: LONGINT); 
+	PROCEDURE ^ Truncate*(VAR string: ARRAY OF CHAR; length: SIZE); 
 	PROCEDURE ^ Pos*(CONST pattern, string: ARRAY OF CHAR): LONGINT; 
 	PROCEDURE ^ GenericPos*(CONST pattern: ARRAY OF CHAR; from: LONGINT; CONST string: ARRAY OF CHAR; ignoreCase, backwards: BOOLEAN): LONGINT; 
 	PROCEDURE ^ Match*(CONST mask, name: ARRAY OF CHAR): BOOLEAN; 
-	PROCEDURE ^ Move*(CONST src: ARRAY OF CHAR; soff, len: LONGINT; VAR dst: ARRAY OF CHAR; doff: LONGINT); 
+	PROCEDURE ^ Move*(CONST src: ARRAY OF CHAR; soff, len: SIZE; VAR dst: ARRAY OF CHAR; doff: SIZE); 
 	PROCEDURE ^ Concat*(CONST s1, s2: ARRAY OF CHAR; VAR s: ARRAY OF CHAR); 
 	PROCEDURE ^ ConcatX*(CONST s1, s2: ARRAY OF CHAR; VAR s: ARRAY OF CHAR); 
 	PROCEDURE ^ Append*(VAR s: ARRAY OF CHAR; CONST appendix: ARRAY OF CHAR); 
 	PROCEDURE ^ AppendX*(VAR s: ARRAY OF CHAR; CONST appendix: ARRAY OF CHAR); 
 	PROCEDURE ^ AppendInt*(VAR s: ARRAY OF CHAR; num: HUGEINT); 
 	PROCEDURE ^ AppendChar*(VAR s: ARRAY OF CHAR; ch: CHAR); 
-	PROCEDURE ^ Copy*(CONST src: ARRAY OF CHAR; index, len: LONGINT; VAR dst: ARRAY OF CHAR); 
-	PROCEDURE ^ Delete*(VAR s: ARRAY OF CHAR; index, count: LONGINT); 
-	PROCEDURE ^ Insert*(CONST src: ARRAY OF CHAR; VAR dst: ARRAY OF CHAR; index: LONGINT); 
+	PROCEDURE ^ Copy*(CONST src: ARRAY OF CHAR; index, len: SIZE; VAR dst: ARRAY OF CHAR); 
+	PROCEDURE ^ Delete*(VAR s: ARRAY OF CHAR; index, count: SIZE); 
+	PROCEDURE ^ Insert*(CONST src: ARRAY OF CHAR; VAR dst: ARRAY OF CHAR; index: SIZE); 
 	PROCEDURE ^ TrimLeft*(VAR string: ARRAY OF CHAR; c: CHAR); 
 	PROCEDURE ^ TrimRight*(VAR string: ARRAY OF CHAR; c: CHAR); 
 	PROCEDURE ^ Trim*(VAR string: ARRAY OF CHAR; c: CHAR); 
@@ -59,7 +59,7 @@ VAR
 	PROCEDURE ^ IntToStr*(x: HUGEINT; VAR s: ARRAY OF CHAR); 
 	PROCEDURE ^ StrToInt*(CONST str: ARRAY OF CHAR; VAR val: LONGINT); 
 	PROCEDURE ^ StrToIntPos*(CONST str: ARRAY OF CHAR; VAR val, i: LONGINT); 
-	PROCEDURE ^ IntToHexStr*(h: HUGEINT; width: LONGINT; VAR s: ARRAY OF CHAR); 
+	PROCEDURE ^ IntToHexStr*(h: HUGEINT; width: WORD; VAR s: ARRAY OF CHAR); 
 	PROCEDURE ^ HexStrToInt*(CONST string: ARRAY OF CHAR; VAR val, res: LONGINT); 
 	PROCEDURE ^ FloatToStr*(x: LONGREAL; n, f, D: LONGINT; VAR str: ARRAY OF CHAR); 
 	PROCEDURE ^ AddressToStr*(adr: ADDRESS; VAR str: ARRAY OF CHAR); 

Linux32/bin/WMComponents.SymU

@@ -373,6 +373,8 @@ TYPE
 		timer: Kernel.Timer; 
 		onChanged-: WMEvents.EventSource; 
 		lock: Locks.RecursiveLock; 
+		rectOwner: ANY; 
+		rect: Rectangles.Rectangle; 
 
 		PROCEDURE ^  & Init; 
 		PROCEDURE ^ Reset(this: VisualComponent);