recompiled release

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

Win64G/bin/ADVAPI32.SymWw

@@ -1,8 +1,8 @@
 MODULE ADVAPI32;
 	IMPORT SYSTEM, Kernel32, Modules, KernelLog;
 CONST 
-	HKEYClassesRoot* = LONGINT(80000000H); 
-	HKEYCurrentUser* = LONGINT(80000001H); 
+	HKEYClassesRoot* = LONGINT(2147483648); 
+	HKEYCurrentUser* = LONGINT(2147483649); 
 	RegNone* = 0; 
 	RegSZ* = 1; 
 	KeyQueryValue* = 0; 

Win64G/bin/CRC.SymWw

@@ -2,7 +2,7 @@ MODULE CRC;
 	IMPORT SYSTEM, Streams;
 CONST 
 	Init16 =  -1; 
-	Init32 = LONGINT(0FFFFFFFFH); 
+	Init32 = LONGINT(4294967295); 
 TYPE 
 	CRC16Stream* = OBJECT (Streams.Writer)
 	VAR 

Win64G/bin/CSS2Properties.SymWw

@@ -1,22 +1,22 @@
 MODULE CSS2Properties;
 	IMPORT DynamicStrings, XMLObjects, CSS2, WMWindowManager, WMGraphics, Raster, GfxImages, GfxFonts, Gfx;
 CONST 
-	Aqua* = LONGINT(0FF00FFFFH); 
-	Black* = LONGINT(0FF000000H); 
-	Blue* = LONGINT(0FF0000FFH); 
-	Fuchsia* = LONGINT(0FFFF00FFH); 
-	Gray* = LONGINT(0FF808080H); 
-	Green* = LONGINT(0FF008000H); 
-	Lime* = LONGINT(0FF00FF00H); 
-	Maroon* = LONGINT(0FF800000H); 
-	Navy* = LONGINT(0FF000080H); 
-	Olive* = LONGINT(0FF808000H); 
-	Purple* = LONGINT(0FF800080H); 
-	Red* = LONGINT(0FFFF0000H); 
-	Silver* = LONGINT(0FFC0C0C0H); 
-	Teal* = LONGINT(0FF008080H); 
-	White* = LONGINT(0FFFFFFFFH); 
-	Yellow* = LONGINT(0FFFFFF00H); 
+	Aqua* = LONGINT(4278255615); 
+	Black* = LONGINT(4278190080); 
+	Blue* = LONGINT(4278190335); 
+	Fuchsia* = LONGINT(4294902015); 
+	Gray* = LONGINT(4286611584); 
+	Green* = LONGINT(4278222848); 
+	Lime* = LONGINT(4278255360); 
+	Maroon* = LONGINT(4286578688); 
+	Navy* = LONGINT(4278190208); 
+	Olive* = LONGINT(4286611456); 
+	Purple* = LONGINT(4286578816); 
+	Red* = LONGINT(4294901760); 
+	Silver* = LONGINT(4290822336); 
+	Teal* = LONGINT(4278222976); 
+	White* = LONGINT(4294967295); 
+	Yellow* = LONGINT(4294967040); 
 	Transparent* = 0; 
 	XXSmall* = 0; 
 	XSmall* = 1; 

Win64G/bin/Compiler.SymWw

@@ -31,6 +31,7 @@ TYPE
 		documentation*: Backend.Backend; 
 		srcPath, destPath: Files.FileName; 
 		replacements: SemanticChecker.Replacement; 
+		platformCallingConvention: SyntaxTree.CallingConvention; 
 	END; 
 VAR 
 	platforms: Options.Defaults; 

Win64G/bin/CryptoAES.SymWw

@@ -5,18 +5,18 @@ CONST
 	ECB = Ciphers.ECB; 
 	CBC = Ciphers.CBC; 
 	CTR = Ciphers.CTR; 
-	b0 = S.VAL(SET, 255); 
-	b1 = S.VAL(SET, 65280); 
-	b2 = S.VAL(SET, 16711680); 
-	b3 = S.VAL(SET, 0FF000000H); 
+	b0 = S.VAL(SET32, 255); 
+	b1 = S.VAL(SET32, 65280); 
+	b2 = S.VAL(SET32, 16711680); 
+	b3 = S.VAL(SET32, 4278190080); 
 TYPE 
-	RTable = ARRAY 256 OF SET; 
+	RTable = ARRAY 256 OF SET32; 
 
-	RKeys = ARRAY (4 * (MaxRounds + 1)) OF SET; 
+	RKeys = ARRAY (4 * (MaxRounds + 1)) OF SET32; 
 
 	Cipher* = OBJECT (Ciphers.Cipher)
 	TYPE 
-		Block = ARRAY 4 OF SET; 
+		Block = ARRAY 4 OF SET32; 
 
 		Ind4 = RECORD 
 			a, b, c, d: LONGINT; 
@@ -33,7 +33,7 @@ TYPE
 		PROCEDURE ^ Decrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
 		PROCEDURE ^ RoundE(VAR b: Block); 
 		PROCEDURE ^ RoundD(VAR b: Block); 
-		PROCEDURE  - split(s: SET; VAR b: Ind4);
+		PROCEDURE  - split(s: SET32; VAR b: Ind4);
 		BEGIN
 			b.a := (S.VAL(LONGINT, s) MOD 256); 
 			b.b := ((S.VAL(LONGINT, s) DIV 256) MOD 256); 
@@ -49,7 +49,7 @@ TYPE
 VAR 
 	e0, e1, e2, e3, e4: RTable; 
 	d0, d1, d2, d3, d4: RTable; 
-	rcon: ARRAY 10 OF SET; 
+	rcon: ARRAY 10 OF SET32; 
 
 	PROCEDURE ^ NewCipher*(): Ciphers.Cipher; 
 	PROCEDURE ^ Initialize; 

Win64G/bin/CryptoBlowfish.SymWw

@@ -3,12 +3,12 @@ MODULE CryptoBlowfish;
 CONST 
 	N = 16; 
 TYPE 
-	TP = ARRAY (N + 2) OF SET; 
+	TP = ARRAY (N + 2) OF SET32; 
 
 	TS = RECORD 
 		a: ARRAY 256 OF LONGINT; 
 		b: ARRAY 256 OF LONGINT; 
-		c: ARRAY 256 OF SET; 
+		c: ARRAY 256 OF SET32; 
 		d: ARRAY 256 OF LONGINT; 
 	END; 
 
@@ -16,7 +16,7 @@ TYPE
 	VAR 
 		p: TP; 
 		s: TS; 
-		ivl, ivr: SET; 
+		ivl, ivr: SET32; 
 
 		PROCEDURE ^ InitKey*(CONST src: ARRAY OF CHAR; keybits: LONGINT); 
 		PROCEDURE ^ SetIV*(CONST src: ARRAY OF CHAR; mode: SHORTINT); 
@@ -24,9 +24,9 @@ TYPE
 		PROCEDURE ^ Decrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
 		PROCEDURE ^ EncryptBlock(VAR buf: ARRAY OF CHAR; pos: LONGINT); 
 		PROCEDURE ^ DecryptBlock(VAR buf: ARRAY OF CHAR; pos: LONGINT); 
-		PROCEDURE ^ F(x: LONGINT): SET; 
-		PROCEDURE ^ encrypt0(xl, xr: SET; VAR yl, yr: SET); 
-		PROCEDURE ^ decrypt0(xl, xr: SET; VAR yl, yr: SET); 
+		PROCEDURE ^ F(x: LONGINT): SET32; 
+		PROCEDURE ^ encrypt0(xl, xr: SET32; VAR yl, yr: SET32); 
+		PROCEDURE ^ decrypt0(xl, xr: SET32; VAR yl, yr: SET32); 
 		PROCEDURE ^  & Init*; 
 	END Cipher; 
 VAR 

Win64G/bin/CryptoCAST.SymWw

@@ -14,7 +14,7 @@ TYPE
 		data: ARRAY 16 OF Key; 
 	END; 
 
-	Block = ARRAY 2 OF SET; 
+	Block = ARRAY 2 OF SET32; 
 
 	Cipher* = OBJECT (Ciphers.Cipher)
 	VAR 
@@ -31,13 +31,13 @@ TYPE
 	END Cipher; 
 VAR 
 	T0, T1, T2, T3: ARRAY 256 OF LONGINT; 
-	T4, T5, T6, T7: ARRAY 256 OF SET; 
+	T4, T5, T6, T7: ARRAY 256 OF SET32; 
 
 	PROCEDURE ^ NewCipher*(): Ciphers.Cipher; 
 	PROCEDURE ^ InitKeys(VAR keys: Keys; CONST src: ARRAY OF CHAR; len: LONGINT); 
-	PROCEDURE ^ CAST1(VAR k: Key; VAR L, R: SET); 
-	PROCEDURE ^ CAST2(VAR k: Key; VAR L, R: SET); 
-	PROCEDURE ^ CAST3(VAR k: Key; VAR L, R: SET); 
+	PROCEDURE ^ CAST1(VAR k: Key; VAR L, R: SET32); 
+	PROCEDURE ^ CAST2(VAR k: Key; VAR L, R: SET32); 
+	PROCEDURE ^ CAST3(VAR k: Key; VAR L, R: SET32); 
 	PROCEDURE ^ encrypt(VAR k: Keys; VAR b: Block); 
 	PROCEDURE ^ decrypt(VAR k: Keys; VAR b: Block); 
 	PROCEDURE ^ Init; 

Win64G/bin/CryptoDES.SymWw

@@ -1,15 +1,15 @@
 MODULE CryptoDES;
 	IMPORT S := SYSTEM, U := CryptoUtils, Ciphers := CryptoCiphers;
 CONST 
-	Mask01 = S.VAL(SET, 0AAAAAAAAH); 
-	Mask02 = S.VAL(SET, 858993459); 
-	Mask04 = S.VAL(SET, 252645135); 
-	Mask08 = S.VAL(SET, 16711935); 
-	Mask16 = S.VAL(SET, 65535); 
+	Mask01 = S.VAL(SET32, 2863311530); 
+	Mask02 = S.VAL(SET32, 858993459); 
+	Mask04 = S.VAL(SET32, 252645135); 
+	Mask08 = S.VAL(SET32, 16711935); 
+	Mask16 = S.VAL(SET32, 65535); 
 TYPE 
-	Sandbox = ARRAY 64 OF SET; 
+	Sandbox = ARRAY 64 OF SET32; 
 
-	BitSwap = ARRAY 16 OF SET; 
+	BitSwap = ARRAY 16 OF SET32; 
 
 	Ind4* = RECORD 
 		a-, b-, c-, d-: LONGINT; 
@@ -17,23 +17,23 @@ TYPE
 
 	Cipher* = OBJECT (Ciphers.Cipher)
 	VAR 
-		ske, skd: ARRAY 32 OF SET; 
+		ske, skd: ARRAY 32 OF SET32; 
 		ki: LONGINT; 
-		ivx, ivy: SET; 
+		ivx, ivy: SET32; 
 
 		PROCEDURE ^ InitKey*(CONST src: ARRAY OF CHAR; keybits: LONGINT); 
 		PROCEDURE ^ SetIV*(CONST src: ARRAY OF CHAR; mode: SHORTINT); 
 		PROCEDURE ^ Encrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
 		PROCEDURE ^ Decrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
-		PROCEDURE ^ RoundE*(VAR x, y: SET); 
-		PROCEDURE ^ RoundD*(VAR x, y: SET); 
+		PROCEDURE ^ RoundE*(VAR x, y: SET32); 
+		PROCEDURE ^ RoundD*(VAR x, y: SET32); 
 		PROCEDURE ^  & Init*; 
 	END Cipher; 
 VAR 
 	sb1-, sb2-, sb3-, sb4-, sb5-, sb6-, sb7-, sb8-: Sandbox; 
 	LHs, RHs: BitSwap; 
 
-	PROCEDURE  - Split*(x: SET; VAR i4: Ind4);
+	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); 
@@ -41,9 +41,9 @@ VAR
 		i4.d := ((S.VAL(LONGINT, x) DIV 16777216) MOD 64)
 	END Split; 
 	PROCEDURE ^ NewCipher*(): Ciphers.Cipher; 
-	PROCEDURE ^ IP*(VAR x, y: SET); 
-	PROCEDURE ^ FP*(VAR x, y: SET); 
-	PROCEDURE ^ ComputeSubkeys*(x, y: SET; VAR sk: ARRAY OF SET; ofs: LONGINT); 
+	PROCEDURE ^ IP*(VAR x, y: SET32); 
+	PROCEDURE ^ FP*(VAR x, y: SET32); 
+	PROCEDURE ^ ComputeSubkeys*(x, y: SET32; VAR sk: ARRAY OF SET32; ofs: LONGINT); 
 	PROCEDURE ^ InitializeSandboxes; 
 BEGIN
 END CryptoDES.

Win64G/bin/CryptoDES3.SymWw

@@ -4,16 +4,16 @@ CONST
 TYPE 
 	Cipher* = OBJECT (Ciphers.Cipher)
 	VAR 
-		ske, skd: ARRAY 96 OF SET; 
+		ske, skd: ARRAY 96 OF SET32; 
 		ski: LONGINT; 
-		ivx, ivy: SET; 
+		ivx, ivy: SET32; 
 
 		PROCEDURE ^ InitKey*(CONST src: ARRAY OF CHAR; keybits: LONGINT); 
 		PROCEDURE ^ SetIV*(CONST src: ARRAY OF CHAR; mode: SHORTINT); 
 		PROCEDURE ^ Encrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
 		PROCEDURE ^ Decrypt*(VAR buf: ARRAY OF CHAR; ofs, len: LONGINT); 
-		PROCEDURE ^ RoundE*(VAR x, y: SET); 
-		PROCEDURE ^ RoundD*(VAR x, y: SET); 
+		PROCEDURE ^ RoundE*(VAR x, y: SET32); 
+		PROCEDURE ^ RoundD*(VAR x, y: SET32); 
 		PROCEDURE ^  & Init*; 
 	END Cipher; 
 

Win64G/bin/CryptoDiffieHellman.SymWw

@@ -6,7 +6,7 @@ TYPE
 	VAR 
 		p, g: B.BigNumber; 
 		priv: B.BigNumber; 
-		initstate: SET; 
+		initstate: SET32; 
 
 		PROCEDURE ^  & Init*(prkeybits: INTEGER; CONST pname: ARRAY OF CHAR); 
 		PROCEDURE ^ ComputeKey*(pub: B.BigNumber): B.BigNumber; 

Win64G/bin/CryptoKeccakF1600.SymWw

@@ -7,7 +7,7 @@ CONST
 	nrLanes = 25; 
 TYPE 
 	Lane = RECORD 
-		low, high: SET; 
+		low, high: SET32; 
 	END; 
 
 	State = ARRAY nrLanes OF Lane; 
@@ -38,6 +38,6 @@ VAR
 	PROCEDURE ^ Round(VAR a: State; r: LONGINT); 
 	PROCEDURE ^ InitializeRoundConstants; 
 	PROCEDURE ^ InitializeRhoOffsets; 
-	PROCEDURE ^ LFSR86540(VAR LFSR: SET): BOOLEAN; 
+	PROCEDURE ^ LFSR86540(VAR LFSR: SET32): BOOLEAN; 
 BEGIN
 END CryptoKeccakF1600.

Win64G/bin/CryptoSHA1.SymWw

@@ -20,24 +20,24 @@ TYPE
 	END Hash; 
 
 	PROCEDURE ^ NewHash*(): Hashes.Hash; 
-	PROCEDURE  - tr0019(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET);
+	PROCEDURE  - tr0019(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET32);
 	BEGIN
-		f := ((((S.VAL(LONGINT, x) + e) + 1518500249) + ROT(a, 5)) + S.VAL(LONGINT, (((S.VAL(SET, c) / S.VAL(SET, d)) * S.VAL(SET, b)) / S.VAL(SET, d)))); 
+		f := ((((S.VAL(LONGINT, x) + e) + 1518500249) + ROT(a, 5)) + S.VAL(LONGINT, (((S.VAL(SET32, c) / S.VAL(SET32, d)) * S.VAL(SET32, b)) / S.VAL(SET32, d)))); 
 		b := ROT(b, 30)
 	END tr0019; 
-	PROCEDURE  - tr2039(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET);
+	PROCEDURE  - tr2039(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET32);
 	BEGIN
-		f := ((((S.VAL(LONGINT, x) + e) + 1859775393) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET, b) / S.VAL(SET, c)) / S.VAL(SET, d)))); 
+		f := ((((S.VAL(LONGINT, x) + e) + 1859775393) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET32, b) / S.VAL(SET32, c)) / S.VAL(SET32, d)))); 
 		b := ROT(b, 30)
 	END tr2039; 
-	PROCEDURE  - tr4059(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET);
+	PROCEDURE  - tr4059(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET32);
 	BEGIN
-		f := ((((S.VAL(LONGINT, x) + e) + LONGINT(8F1BBCDCH)) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET, b) * S.VAL(SET, c)) + ((S.VAL(SET, b) + S.VAL(SET, c)) * S.VAL(SET, d))))); 
+		f := ((((S.VAL(LONGINT, x) + e) + LONGINT(2400959708)) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET32, b) * S.VAL(SET32, c)) + ((S.VAL(SET32, b) + S.VAL(SET32, c)) * S.VAL(SET32, d))))); 
 		b := ROT(b, 30)
 	END tr4059; 
-	PROCEDURE  - tr6079(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET);
+	PROCEDURE  - tr6079(a: LONGINT; VAR b: LONGINT; c, d, e: LONGINT; VAR f: LONGINT; x: SET32);
 	BEGIN
-		f := ((((S.VAL(LONGINT, x) + e) + LONGINT(0CA62C1D6H)) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET, b) / S.VAL(SET, c)) / S.VAL(SET, d)))); 
+		f := ((((S.VAL(LONGINT, x) + e) + LONGINT(3395469782)) + ROT(a, 5)) + S.VAL(LONGINT, ((S.VAL(SET32, b) / S.VAL(SET32, c)) / S.VAL(SET32, d)))); 
 		b := ROT(b, 30)
 	END tr6079; 
 	PROCEDURE ^ HashBlock(VAR state: State; CONST buf: ARRAY OF CHAR; pos: LONGINT); 

Win64G/bin/CryptoSHA256.SymWw

@@ -21,10 +21,10 @@ VAR
 	K256: ARRAY 64 OF LONGINT; 
 
 	PROCEDURE ^ NewHash*(): Hashes.Hash; 
-	PROCEDURE ^ Sigma0Maj(x: SET; y, z: LONGINT): LONGINT; 
-	PROCEDURE ^ Sigma1Ch(x: SET; y, z: LONGINT): LONGINT; 
-	PROCEDURE ^ sigma0(x: SET): LONGINT; 
-	PROCEDURE ^ sigma1(x: SET): LONGINT; 
+	PROCEDURE ^ Sigma0Maj(x: SET32; y, z: LONGINT): LONGINT; 
+	PROCEDURE ^ Sigma1Ch(x: SET32; y, z: LONGINT): LONGINT; 
+	PROCEDURE ^ sigma0(x: SET32): LONGINT; 
+	PROCEDURE ^ sigma1(x: SET32): LONGINT; 
 	PROCEDURE ^ InitializeK; 
 BEGIN
 END CryptoSHA256.