Add proper type definition for fingerprint values

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

source/FoxAMD64Assembler.Mod

@@ -2647,7 +2647,7 @@ TYPE
 	BEGIN  InitMem128 (operand,reg, displacement); RETURN operand
 	END NewMem128;
 
-	PROCEDURE SetSymbol*(VAR operand: Operand; symbol: Sections.SectionName; fingerprint: LONGINT; symbolOffset, displacement: LONGINT);
+	PROCEDURE SetSymbol*(VAR operand: Operand; symbol: Sections.SectionName; fingerprint: Basic.Fingerprint; symbolOffset, displacement: LONGINT);
 	BEGIN
 		operand.symbol.name := symbol;
 		operand.symbol.fingerprint := fingerprint;

source/FoxARMBackend.Mod

@@ -195,7 +195,7 @@ TYPE
 		identifier: ObjectFile.Identifier;
 		symbolOffset: LONGINT; (* offset to the symbol in IR units *)
 
-		PROCEDURE & InitSym(s: Sections.SectionName; fp: LONGINT; offs: LONGINT);
+		PROCEDURE & InitSym(s: Sections.SectionName; fp: Basic.Fingerprint; offs: LONGINT);
 		BEGIN
 			Init(4);
 			identifier.name := s;
@@ -258,7 +258,7 @@ TYPE
 			RETURN reference;
 		END AddReference;
 
-		PROCEDURE AddSymbol(symbol: Sections.SectionName; fingerprint: LONGINT; symbolOffset: LONGINT; pc: LONGINT; bits: LONGINT);
+		PROCEDURE AddSymbol(symbol: Sections.SectionName; fingerprint: Basic.Fingerprint; symbolOffset: LONGINT; pc: LONGINT; bits: LONGINT);
 		VAR
 			reference, foundReference: Reference; symbolReference: SymbolReference;
 		BEGIN
@@ -1209,7 +1209,7 @@ TYPE
 
 		(** get an ARM register that contains the address of a symbol/section
 		- use register hint if provided **)
-		PROCEDURE RegisterFromSymbol(symbol: Sections.SectionName; fingerprint: LONGINT; resolved: Sections.Section; symbolOffset: LONGINT; CONST registerHint: Operand): Operand;
+		PROCEDURE RegisterFromSymbol(symbol: Sections.SectionName; fingerprint: Basic.Fingerprint; resolved: Sections.Section; symbolOffset: LONGINT; CONST registerHint: Operand): Operand;
 		VAR
 			address: LONGINT;
 			result: Operand;

source/FoxAssembler.Mod

@@ -361,7 +361,7 @@ TYPE
 			RETURN TRUE
 		END ConstantSymbol;
 
-		PROCEDURE GetFingerprint(symbol: SyntaxTree.Symbol): LONGINT;
+		PROCEDURE GetFingerprint(symbol: SyntaxTree.Symbol): Basic.Fingerprint;
 		BEGIN
 			IF (symbol # NIL) THEN RETURN symbol.fingerprint.shallow END;
 		END GetFingerprint;

source/FoxBasic.Mod

@@ -57,6 +57,7 @@ TYPE
 	
 	ErrorCode*=LONGINT;
 
+	Fingerprint* = ObjectFile.Fingerprint;
 
 	List* = OBJECT  (* by Luc Bläser *)
 	VAR

source/FoxBinaryCode.Mod

@@ -110,7 +110,7 @@ TYPE
 			SELF.offset := offset;
 		END SetFixupOffset;
 
-		PROCEDURE SetSymbol*(symbol: Sections.SectionName; fp: LONGINT; symbolOffset: LONGINT; displacement: Unit);
+		PROCEDURE SetSymbol*(symbol: Sections.SectionName; fp: ObjectFile.Fingerprint; symbolOffset: LONGINT; displacement: Unit);
 		BEGIN
 			SELF.symbol.name := symbol;
 			SELF.symbol.fingerprint := fp;

source/FoxCodeGenerators.Mod

@@ -334,7 +334,7 @@ TYPE
 			VAR
 				parSize: LONGINT; sectionName: Basic.SegmentedName; source: Sections.Section; op: IntermediateCode.Operand;
 				instruction: IntermediateCode.Instruction;
-				symbol: SyntaxTree.Symbol; fp: LONGINT;
+				symbol: SyntaxTree.Symbol; fp: Basic.Fingerprint;
 				hasDestination: BOOLEAN;
 
 				PROCEDURE Emit(instruction: IntermediateCode.Instruction; CONST str: ARRAY OF CHAR);

source/FoxFingerprinter.Mod

@@ -131,7 +131,7 @@ CONST
 TYPE
 	Fingerprinter*= OBJECT (SyntaxTree.Visitor)
 	VAR
-		fp-: LONGINT; (* temporary fingerprint for values etc. *)
+		fp-: Basic.Fingerprint; (* temporary fingerprint for values etc. *)
 		fingerprint: SyntaxTree.Fingerprint;
 		deep: BOOLEAN; (* public / private field of FP needed ? *)
 		traceLevel: LONGINT;
@@ -153,7 +153,7 @@ TYPE
 		BEGIN
 		END VisitBasicType;
 
-		PROCEDURE SetTypeFingerprint(x: SyntaxTree.Type; fp: LONGINT);
+		PROCEDURE SetTypeFingerprint(x: SyntaxTree.Type; fp: Basic.Fingerprint);
 		VAR fingerprint: SyntaxTree.Fingerprint;
 		BEGIN
 			fingerprint := x.fingerprint;
@@ -278,7 +278,7 @@ TYPE
 			fp enumeration type
 		**)
 		PROCEDURE VisitEnumerationType*(x: SyntaxTree.EnumerationType);
-		VAR fingerprint: SyntaxTree.Fingerprint; enumerator: SyntaxTree.Constant; fp: LONGINT;
+		VAR fingerprint: SyntaxTree.Fingerprint; enumerator: SyntaxTree.Constant; fp: Basic.Fingerprint;
 		BEGIN
 			fingerprint := x.fingerprint;
 
@@ -332,7 +332,7 @@ TYPE
 		PrivateFP(ArrayType)       = FP(arrayType).
 		*)
 		PROCEDURE VisitArrayType*(x: SyntaxTree.ArrayType);
-		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: LONGINT;
+		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: Basic.Fingerprint;
 		BEGIN
 			IF Trace THEN TraceEnter("ArrayType") END;
 			fingerprint := x.fingerprint;
@@ -381,7 +381,7 @@ TYPE
 		PrivateFP(MathArrayType)   = FP(arrayType).
 		*)
 		PROCEDURE VisitMathArrayType*(x: SyntaxTree.MathArrayType);
-		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: LONGINT;
+		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: Basic.Fingerprint;
 		BEGIN
 			fingerprint := x.fingerprint;
 			deep := SELF.deep;
@@ -427,7 +427,7 @@ TYPE
 		(*
 			fp = fp [ -> Name(moduleName) -> Name(typeName) ]
 		*)
-		PROCEDURE TypeName(VAR fp: LONGINT; x:SyntaxTree.Type);
+		PROCEDURE TypeName(VAR fp: Basic.Fingerprint; x:SyntaxTree.Type);
 		VAR  typeDeclaration: SyntaxTree.TypeDeclaration;
 		BEGIN
 			IF (x.scope # NIL) THEN
@@ -480,7 +480,7 @@ TYPE
 		PrivateFP(PointerType)     = 0.
 		*)
 		PROCEDURE VisitPointerType*(x: SyntaxTree.PointerType);
-		VAR fp: LONGINT; deep: BOOLEAN;
+		VAR fp: Basic.Fingerprint; deep: BOOLEAN;
 		BEGIN
 			IF Trace THEN TraceEnter("PointerType");  END;
 			fingerprint := x.fingerprint;
@@ -522,7 +522,7 @@ TYPE
 		PrivateFP(PortType)     = 0.
 		*)
 		PROCEDURE VisitPortType*(x: SyntaxTree.PortType);
-		VAR fingerprint: SyntaxTree.Fingerprint; fp: LONGINT; deep: BOOLEAN;
+		VAR fingerprint: SyntaxTree.Fingerprint; fp: Basic.Fingerprint; deep: BOOLEAN;
 		BEGIN
 			IF Trace THEN TraceEnter("PortType");  END;
 			fingerprint := x.fingerprint;
@@ -550,8 +550,8 @@ TYPE
 		(*
 		FP(Method)  = 0 <*> fpModeMethod -> Name(methodName) -> Signature(method).
 		*)
-		PROCEDURE FPrintMethod(VAR private,public: LONGINT; procedure,body: SyntaxTree.Procedure);
-		VAR fingerprint: SyntaxTree.Fingerprint; fp: LONGINT; name: ARRAY 256 OF CHAR;
+		PROCEDURE FPrintMethod(VAR private,public: Basic.Fingerprint; procedure,body: SyntaxTree.Procedure);
+		VAR fingerprint: SyntaxTree.Fingerprint; fp: Basic.Fingerprint; name: ARRAY 256 OF CHAR;
 		BEGIN
 			IF Trace THEN TraceEnter("Method");
 				D.Address(SYSTEM.VAL(ADDRESS,procedure));
@@ -589,7 +589,7 @@ TYPE
 		END FPrintMethod;
 
 		PROCEDURE VisitCellType*(x: SyntaxTree.CellType);
-		VAR fingerprint: SyntaxTree.Fingerprint; fp:LONGINT;
+		VAR fingerprint: SyntaxTree.Fingerprint; fp: Basic.Fingerprint;
 		BEGIN
 			fingerprint := x.fingerprint;
 			deep := SELF.deep;
@@ -615,7 +615,7 @@ TYPE
 		                            {<*> PrivateFP(fieldType) <*> offset(field) <*> FP(field)}
 		*)
 		PROCEDURE VisitRecordType*(x: SyntaxTree.RecordType);
-		VAR scope: SyntaxTree.RecordScope; fp: LONGINT; variable: SyntaxTree.Variable;
+		VAR scope: SyntaxTree.RecordScope; fp: Basic.Fingerprint; variable: SyntaxTree.Variable;
 			fingerprint,variableFingerprint,variableTypeFingerprint,baseFingerprint: SyntaxTree.Fingerprint;flags: SET;
 			symbol: SyntaxTree.Symbol; procedure: SyntaxTree.Procedure;  baseType: SyntaxTree.Type;
 			body: SyntaxTree.Body; name: ARRAY 256 OF CHAR;
@@ -763,7 +763,7 @@ TYPE
 		PrivateFP(ProcedureType)   = FP(arrayType)-> Signature(procedureType).
 		*)
 		PROCEDURE VisitProcedureType*(x: SyntaxTree.ProcedureType);
-		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: LONGINT;
+		VAR fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: Basic.Fingerprint;
 		BEGIN
 			IF Trace THEN TraceEnter("ProcedureType") END;
 
@@ -866,7 +866,7 @@ TYPE
 		BEGIN FPString(SELF.fp,x.value^) END VisitStringValue;
 
 		(* fp = fp & FP(x) *)
-		PROCEDURE FPValue(VAR fp: LONGINT; x: SyntaxTree.Expression);
+		PROCEDURE FPValue(VAR fp: Basic.Fingerprint; x: SyntaxTree.Expression);
 		BEGIN
 			SELF.fp := fp;
 			IF x.resolved # NIL THEN
@@ -877,7 +877,7 @@ TYPE
 			fp := SELF.fp
 		END FPValue;
 
-		PROCEDURE FPType(VAR fp: LONGINT; t: SyntaxTree.Type);
+		PROCEDURE FPType(VAR fp: Basic.Fingerprint; t: SyntaxTree.Type);
 		BEGIN
 			INC(level); ASSERT(level <= 100);
 			IF t = NIL THEN FPNumber(fp,fpTypeNone);
@@ -890,11 +890,11 @@ TYPE
 	                      { <*> (fpModeVarParameter | fpModeConstParameter | fpModePar)
 	                      <*> FP(parameterType) [-> Name(parameterName)]  }
 		 *)
-		PROCEDURE FPSignature(VAR fp: LONGINT; t: SyntaxTree.ProcedureType; isOperator: BOOLEAN);
+		PROCEDURE FPSignature(VAR fp: Basic.Fingerprint; t: SyntaxTree.ProcedureType; isOperator: BOOLEAN);
 		VAR par,self: SyntaxTree.Parameter; deep: BOOLEAN;
 
 			(* fp = fp & (fpModeVarPar | fpModeConstPar | fpModePar) [ & Name ] *)
-			PROCEDURE FPPar(VAR fp: LONGINT;  par: SyntaxTree.Parameter);
+			PROCEDURE FPPar(VAR fp: Basic.Fingerprint;  par: SyntaxTree.Parameter);
 			VAR deep: BOOLEAN;
 			BEGIN
 				IF par.kind = SyntaxTree.VarParameter THEN  FPNumber(fp, fpModeVarPar)
@@ -977,7 +977,7 @@ TYPE
 			FP(TypeDeclaration)        = 0 <*> fpModeType -> Name -> Visibility <*> FP(Type).
 		*)
 		PROCEDURE VisitTypeDeclaration*(x: SyntaxTree.TypeDeclaration);
-		VAR fp: LONGINT;
+		VAR fp: Basic.Fingerprint;
 			fingerprint, typeFP: SyntaxTree.Fingerprint; deep: BOOLEAN;
 		BEGIN
 			fingerprint := x.fingerprint;
@@ -1023,7 +1023,7 @@ TYPE
 		PROCEDURE VisitConstant*(x: SyntaxTree.Constant);
 		VAR access: SET;
 			fingerprint: SyntaxTree.Fingerprint;
-			fp: LONGINT;
+			fp: Basic.Fingerprint;
 			deep: BOOLEAN;
 		BEGIN
 			fingerprint := x.fingerprint;
@@ -1117,7 +1117,7 @@ TYPE
 		                            | 0 <*> fpModeExportedProcedure -> Name -> Visibility <*> FP(Type)
 		*)
 		PROCEDURE VisitProcedure*(x: SyntaxTree.Procedure);
-		VAR fp: LONGINT; access: SET; fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; code: SyntaxTree.Code; i: LONGINT;
+		VAR fp: Basic.Fingerprint; access: SET; fingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; code: SyntaxTree.Code; i: LONGINT;
 			size,value: LONGINT; name: ARRAY 256 OF CHAR;
 		BEGIN
 			IF x.scope IS SyntaxTree.RecordScope THEN (* method *)
@@ -1174,7 +1174,7 @@ TYPE
 		END VisitOperator;
 		
 		PROCEDURE VisitModule*(x: SyntaxTree.Module);
-		VAR fingerprint, symbolFingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: LONGINT; symbol: SyntaxTree.Symbol; scope: SyntaxTree.ModuleScope;
+		VAR fingerprint, symbolFingerprint: SyntaxTree.Fingerprint; deep: BOOLEAN; fp: Basic.Fingerprint; symbol: SyntaxTree.Symbol; scope: SyntaxTree.ModuleScope;
 		BEGIN
 			fingerprint := x.fingerprint;
 			deep := SELF.deep;
@@ -1315,23 +1315,23 @@ TYPE
 	END IsOberonProcedure;
 
 	(* fp = fp <*> val *)
-	PROCEDURE FPNumber*(VAR fp: LONGINT; val: LONGINT);
+	PROCEDURE FPNumber*(VAR fp: Basic.Fingerprint; val: LONGINT);
 	BEGIN
 		fp:=SYSTEM.VAL(LONGINT, SYSTEM.VAL(SET, ROT(fp, 7)) / SYSTEM.VAL(SET, val))
 	END FPNumber;
 
 	(* fp = fp <*> set *)
-	PROCEDURE FPSet*(VAR fp: LONGINT; set: SET);
+	PROCEDURE FPSet*(VAR fp: Basic.Fingerprint; set: SET);
 	BEGIN FPNumber(fp, SYSTEM.VAL(LONGINT, set))
 	END FPSet;
 
 	(* fp = fp <*> real *)
-	PROCEDURE FPReal*(VAR fp: LONGINT; real: REAL);
+	PROCEDURE FPReal*(VAR fp: Basic.Fingerprint; real: REAL);
 	BEGIN FPNumber(fp, SYSTEM.VAL(LONGINT, real))
 	END FPReal;
 
 	(* fp = fp <*> low <*> high *)
-	PROCEDURE FPLongReal*(VAR fp: LONGINT; lr: LONGREAL);
+	PROCEDURE FPLongReal*(VAR fp: Basic.Fingerprint; lr: LONGREAL);
 		VAR l, h: LONGINT;
 	BEGIN
 		SYSTEM.GET(ADDRESSOF(lr)+4, l); SYSTEM.GET(ADDRESSOF(lr), h);
@@ -1339,7 +1339,7 @@ TYPE
 	END FPLongReal;
 
 	(* fp = fp <*> low <*> high *)
-	PROCEDURE FPHugeInt*(VAR fp: LONGINT; huge: HUGEINT);
+	PROCEDURE FPHugeInt*(VAR fp: Basic.Fingerprint; huge: HUGEINT);
 	VAR l, h: LONGINT;
 	BEGIN
 		SYSTEM.GET(ADDRESSOF(huge)+4, l); SYSTEM.GET(ADDRESSOF(huge), h);
@@ -1347,7 +1347,7 @@ TYPE
 	END FPHugeInt;
 
 	(* fp = fp -> String *)
-	PROCEDURE FPName*(VAR fp: LONGINT; x: SyntaxTree.Identifier);
+	PROCEDURE FPName*(VAR fp: Basic.Fingerprint; x: SyntaxTree.Identifier);
 	VAR name: Scanner.IdentifierString;
 	BEGIN
 		Basic.GetString(x,name);
@@ -1355,13 +1355,13 @@ TYPE
 	END FPName;
 
 	(* fp = fp {<*> str[i]} *)
-	PROCEDURE FPString*(VAR fp: LONGINT; CONST str: ARRAY OF CHAR);
+	PROCEDURE FPString*(VAR fp: Basic.Fingerprint; CONST str: ARRAY OF CHAR);
 	VAR i: INTEGER; ch: CHAR;
 	BEGIN i:=0; REPEAT ch:=str[i]; FPNumber(fp, ORD(ch)); INC(i) UNTIL ch=0X
 	END FPString;
 
 	(* fp = fp <*> (fpExtern | fpExternR | fpIntern | fpOther + vis) *)
-	PROCEDURE FPVisibility*(VAR fp: LONGINT; vis: SET);
+	PROCEDURE FPVisibility*(VAR fp: Basic.Fingerprint; vis: SET);
 	BEGIN
 		IF SyntaxTree.PublicWrite IN vis THEN  FPNumber(fp, fpExtern)
 		ELSIF SyntaxTree.PublicRead IN vis THEN  FPNumber(fp, fpExternR)

source/FoxGenericObjectFile.Mod

@@ -344,8 +344,8 @@ TYPE ObjectFileFormat* = OBJECT (Formats.ObjectFileFormat)
 
 	END ObjectFileFormat;
 
-	PROCEDURE GetFingerprint (section: Sections.Section; fingerprinter: Fingerprinter.Fingerprinter): LONGINT;
-	VAR fingerprint: SyntaxTree.Fingerprint; fp: LONGINT; string: Basic.SectionName;
+	PROCEDURE GetFingerprint (section: Sections.Section; fingerprinter: Fingerprinter.Fingerprinter): ObjectFile.Fingerprint;
+	VAR fingerprint: SyntaxTree.Fingerprint; fp: ObjectFile.Fingerprint; string: Basic.SectionName;
 	BEGIN
 		IF section.fingerprint # 0 THEN
 			fp := section.fingerprint

source/FoxIntermediateBackend.Mod

@@ -3909,7 +3909,7 @@ TYPE
 
 		(* needed for old binary object file format*)
 		PROCEDURE EnsureSymbol(CONST moduleName,procedureName: SyntaxTree.IdentifierString);
-		VAR r: Operand; procedure: SyntaxTree.Procedure; module: SyntaxTree.Module; s: ARRAY 128 OF CHAR; fp: LONGINT;
+		VAR r: Operand; procedure: SyntaxTree.Procedure; module: SyntaxTree.Module; s: ARRAY 128 OF CHAR; fp: Basic.Fingerprint;
 		BEGIN
 			IF AddImport(moduleName,module,TRUE) THEN
 				procedure := module.moduleScope.FindProcedure(SyntaxTree.NewIdentifier(procedureName));
@@ -12343,7 +12343,7 @@ TYPE
 			END;
 		END InitVariables;
 
-		PROCEDURE GetFingerprint(symbol: SyntaxTree.Symbol): LONGINT;
+		PROCEDURE GetFingerprint(symbol: SyntaxTree.Symbol): Basic.Fingerprint;
 		BEGIN
 			IF (symbol # NIL) THEN
 				RETURN fingerprinter.SymbolFP(symbol).public

source/FoxIntermediateCode.Mod

@@ -958,7 +958,7 @@ TYPE
 		op.offset := offset
 	END SetOffset;
 
-	PROCEDURE SetSymbol*(VAR op: Operand; symbol: Sections.SectionName; fp: LONGINT);
+	PROCEDURE SetSymbol*(VAR op: Operand; symbol: Sections.SectionName; fp: Basic.Fingerprint);
 	BEGIN
 		op.symbol.name := symbol;
 		op.symbol.fingerprint := fp;
@@ -988,14 +988,14 @@ TYPE
 		op.type := type;
 	END MakeAddress;
 
-	PROCEDURE InitAddress*(VAR op: Operand; type: Type; symbol: Sections.SectionName; fp: LONGINT; symbolOffset: LONGINT);
+	PROCEDURE InitAddress*(VAR op: Operand; type: Type; symbol: Sections.SectionName; fp: Basic.Fingerprint; symbolOffset: LONGINT);
 	BEGIN
 		Assert(symbol # "","forbidden nil symbol");
 		ASSERT(symbol[0] # 0); (* not initialized *)
 		InitImmediate(op,type,0); op.symbol.name := symbol; op.symbol.fingerprint := fp; op.type := type; op.symbolOffset := symbolOffset
 	END InitAddress;
 
-	PROCEDURE Address*(type: Type; symbol: Sections.SectionName; fp: LONGINT; offset: LONGINT): Operand;
+	PROCEDURE Address*(type: Type; symbol: Sections.SectionName; fp: Basic.Fingerprint; offset: LONGINT): Operand;
 	VAR op: Operand;
 	BEGIN InitAddress(op,type,symbol,fp, offset); RETURN op
 	END Address;

source/FoxSections.Mod

@@ -31,7 +31,7 @@ TYPE
 
 		fixed-: BOOLEAN; (* whether the position of the section is fixed, as opposed to being restricted by an alignment *)
 		positionOrAlignment-: LONGINT; (* the alignment OR the position *)
-		fingerprint-: LONGINT; (* fingerprint of the corresponding syntax tree node *)
+		fingerprint-: Basic.Fingerprint; (* fingerprint of the corresponding syntax tree node *)
 		bitsPerUnit-: LONGINT; (* the unit size given in bits *)
 
 		symbol-: SyntaxTree.Symbol; (* corresponding symbol in AST *)
@@ -83,7 +83,7 @@ TYPE
 		BEGIN RETURN UnknownSize
 		END GetSize;
 
-		PROCEDURE SetFingerprint*(fingerprint: LONGINT);
+		PROCEDURE SetFingerprint*(fingerprint: Basic.Fingerprint);
 		BEGIN SELF.fingerprint := fingerprint
 		END SetFingerprint;
 

source/FoxSyntaxTree.Mod

@@ -476,7 +476,7 @@ TYPE
 	END;
 
 	Fingerprint*= RECORD
-		shallow*,public*, private*: LONGINT;
+		shallow*,public*, private*: Basic.Fingerprint;
 		shallowAvailable*, deepAvailable*: BOOLEAN;
 	END;
 

source/ObjectFile.Mod

@@ -31,6 +31,8 @@ TYPE
 	Unit* = LONGINT;
 	Bits* = LONGINT;
 
+	Fingerprint* = LONGINT;
+
 	SectionType = INTEGER;
 
 	SegmentedName*= ARRAY SegmentedNameLength OF StringPool.Index;
@@ -56,7 +58,7 @@ TYPE
 
 	Identifier*= RECORD
 		name*: SegmentedName;
-		fingerprint*: LONGINT;
+		fingerprint*: Fingerprint;
 	END;
 
 	Pattern*= POINTER TO RECORD (* this is the same for many fixups *)
@@ -1158,7 +1160,7 @@ VAR
 	END AddPatch;
 	*)
 
-	PROCEDURE AddFixup*(VAR fixups: LONGINT; VAR fixup: Fixups; CONST name: SegmentedName; fingerprint: LONGINT; mode: INTEGER; scale: LONGINT; patterns: LONGINT; pattern: FixupPatterns): LONGINT;
+	PROCEDURE AddFixup*(VAR fixups: LONGINT; VAR fixup: Fixups; CONST name: SegmentedName; fingerprint: Fingerprint; mode: INTEGER; scale: LONGINT; patterns: LONGINT; pattern: FixupPatterns): LONGINT;
 	VAR i: LONGINT; newFixups, index: LONGINT; newFixup: Fixups;
 	BEGIN
 		FOR i := 0 TO fixups-1 DO
@@ -1188,7 +1190,7 @@ VAR
 		RETURN index;
 	END AddFixup;
 
-	PROCEDURE AddAlias*(VAR aliases: LONGINT; VAR alias: Aliases; CONST name: SegmentedName; fingerprint, offset: LONGINT): LONGINT;
+	PROCEDURE AddAlias*(VAR aliases: LONGINT; VAR alias: Aliases; CONST name: SegmentedName; fingerprint: Fingerprint; offset: LONGINT): LONGINT;
 	VAR i: LONGINT; newAliases, index: LONGINT; newAlias: Aliases;
 	BEGIN
 		newAliases := aliases+1;