Added proper type definition for evaluating constant integer expressions

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

source/FoxAMD64Assembler.Mod

@@ -1651,7 +1651,7 @@ TYPE
 					IF (scopeSymbol.type.resolved IS SyntaxTree.CharacterType) & (scopeSymbol.type.resolved.sizeInBits=8)  THEN
 						x := ORD(scopeSymbol(SyntaxTree.Constant).value.resolved(SyntaxTree.CharacterValue).value)
 					ELSIF scopeSymbol.type.resolved IS SyntaxTree.IntegerType THEN
-						x := scopeSymbol(SyntaxTree.Constant).value.resolved(SyntaxTree.IntegerValue).value
+						x := LONGINT (scopeSymbol(SyntaxTree.Constant).value.resolved(SyntaxTree.IntegerValue).value) (* TODO: fix explicit integer truncation *)
 					ELSE
 						Error("number expected");
 						RETURN FALSE;

source/FoxAssembler.Mod

@@ -347,7 +347,7 @@ TYPE
 				result.valueR := result.value;
 				result.type := ConstantInteger;
 			ELSIF constant.type.resolved IS SyntaxTree.IntegerType THEN
-				result.value := constant.value.resolved(SyntaxTree.IntegerValue).hvalue;
+				result.value := constant.value.resolved(SyntaxTree.IntegerValue).value;
 				result.valueR := result.value;
 				result.type := ConstantInteger;
 			ELSIF constant.type.resolved IS SyntaxTree.FloatType THEN

source/FoxBasic.Mod

@@ -40,6 +40,7 @@ TYPE
 	SectionName*= ARRAY 256 OF CHAR;
 	MessageString*= ARRAY 256 OF CHAR;
 
+	Integer* = SIGNED64;
 	Set* = SET64;
 
 	ObjectArray = POINTER TO ARRAY OF ANY;

source/FoxBinarySymbolFile.Mod

@@ -312,7 +312,7 @@ TYPE
 			check enumeration scope: enter symbols and check for duplicate names
 		**)
 		PROCEDURE CheckEnumerationScope(x: SyntaxTree.EnumerationScope);
-		VAR e: SyntaxTree.Constant; lowest, highest,value: LONGINT;
+		VAR e: SyntaxTree.Constant; lowest, highest,value: Basic.Integer;
 		BEGIN
 			lowest := 0; highest := 0;
 			e := x.firstConstant;
@@ -1642,9 +1642,7 @@ TYPE
 				ELSIF type = Global.Char16 THEN  w.RawNum(ORD(v(SyntaxTree.CharacterValue).value));
 				ELSIF type = Global.Char32 THEN w.RawNum(ORD(v(SyntaxTree.CharacterValue).value));
 				*)
-				ELSIF (type IS SyntaxTree.IntegerType) & (type.sizeInBits = 64) THEN w.RawHInt(v(SyntaxTree.IntegerValue).hvalue);
-				ELSIF (type IS SyntaxTree.IntegerType) & (type.sizeInBits = 32) & ~type(SyntaxTree.IntegerType).signed  THEN w.RawHInt(v(SyntaxTree.IntegerValue).hvalue);
-				ELSIF (type IS SyntaxTree.IntegerType) & (type.sizeInBits <= 32)  THEN w.RawNum(v(SyntaxTree.IntegerValue).value);
+				ELSIF type IS SyntaxTree.IntegerType THEN w.RawHInt(v(SyntaxTree.IntegerValue).value);
 				ELSIF type IS SyntaxTree.SetType THEN   w.RawNum(SYSTEM.VAL(LONGINT,v(SyntaxTree.SetValue).value));
 				ELSIF type IS SyntaxTree.FloatType THEN
 					IF type.sizeInBits = 32 THEN w.RawReal(SHORT(v(SyntaxTree.RealValue).value));
@@ -1653,7 +1651,7 @@ TYPE
 				ELSIF type IS SyntaxTree.StringType THEN  w.RawLInt(v(SyntaxTree.StringValue).length); w.RawString(v(SyntaxTree.StringValue).value^);
 				ELSIF type IS SyntaxTree.NilType THEN
 				ELSIF type IS SyntaxTree.ByteType THEN HALT(100)
-				ELSIF type IS SyntaxTree.EnumerationType THEN w.RawNum(v(SyntaxTree.EnumerationValue).value);
+				ELSIF type IS SyntaxTree.EnumerationType THEN w.RawHInt(v(SyntaxTree.EnumerationValue).value);
 				ELSE HALT(200);
 				END;
 			END Value;

source/FoxDocumentationBackend.Mod

@@ -584,25 +584,8 @@ TYPE
 		END VisitBooleanValue;
 
 		PROCEDURE VisitIntegerValue*(x: SyntaxTree.IntegerValue);
-
-			PROCEDURE InBounds(val: HUGEINT; bits: LONGINT): BOOLEAN;
-			VAR m: HUGEINT;
-			BEGIN
-				m := ASH(HUGEINT(1),bits-1);
-				RETURN (val < m) & (-val <= m)
-			END InBounds;
-		BEGIN
-			(*! use subtype for representation form ?  *)
-			IF x.hvalue = MIN(HUGEINT) THEN
-				(* special case: display 8000000000000000H without leading minus sign
-					to avoid double minus sign for unary expression -8000000000000000H
-				*)
-				w.Char("0"); w.Hex(x.hvalue,-16); w.Char("H");
-			ELSIF InBounds(x.hvalue,32) THEN
-				Int(SHORT(x.hvalue));
-			ELSE
-				Hex(w,x.hvalue); w.Char("H");
-			END;
+		BEGIN
+			w.Int(x.value,1);
 			ToText(w,current.text,ElementType.Default);
 		END VisitIntegerValue;
 

source/FoxFingerPrinter.Mod

@@ -815,12 +815,12 @@ TYPE
 
 		(* fp = fp & (HugeInt | Number) *)
 		PROCEDURE VisitIntegerValue*(x: SyntaxTree.IntegerValue);
-		BEGIN IF x.type.sizeInBits = 64 THEN FPHugeInt(SELF.fp,x.hvalue) ELSE FPNumber(SELF.fp,x.value) END;
+		BEGIN FPHugeInt(SELF.fp,x.value)
 		END VisitIntegerValue;
 
 		(* fp = fp & (HugeInt | Number) *)
 		PROCEDURE VisitEnumerationValue*(x: SyntaxTree.EnumerationValue);
-		BEGIN FPNumber(SELF.fp,x.value)
+		BEGIN FPHugeInt(SELF.fp,x.value)
 		END VisitEnumerationValue;
 
 		(* fp = fp & ORD(char) *)

source/FoxIntermediateBackend.Mod

@@ -586,7 +586,7 @@ TYPE
 			inline, finalizer: BOOLEAN;
 			procedureType: SyntaxTree.ProcedureType;
 			pc: LONGINT;
-			stackSize: LONGINT;
+			memorySize: Basic.Integer; stackSize: LONGINT;
 			name,baseObject: Basic.SegmentedName; ir: IntermediateCode.Section;
 			null,size,src,dest,fp,res: IntermediateCode.Operand;
 			callingConvention: LONGINT;
@@ -617,7 +617,7 @@ TYPE
 				END;
 			END Signature;
 
-			PROCEDURE CheckIntegerValue(x: SyntaxTree.Expression; VAR value: LONGINT): BOOLEAN;
+			PROCEDURE CheckIntegerValue(x: SyntaxTree.Expression; VAR value: Basic.Integer): BOOLEAN;
 			VAR result: BOOLEAN;
 			BEGIN
 				result := FALSE;
@@ -631,7 +631,7 @@ TYPE
 				RETURN result;
 			END CheckIntegerValue;
 
-			PROCEDURE HasValue(modifiers: SyntaxTree.Modifier; CONST name: ARRAY OF CHAR; VAR value: LONGINT): BOOLEAN;
+			PROCEDURE HasValue(modifiers: SyntaxTree.Modifier; CONST name: ARRAY OF CHAR; VAR value: Basic.Integer): BOOLEAN;
 			VAR this: SyntaxTree.Modifier; id: SyntaxTree.Identifier;
 			BEGIN
 				this := modifiers; id := SyntaxTree.NewIdentifier(name);
@@ -688,9 +688,9 @@ TYPE
 			ELSIF (scope.outerScope IS SyntaxTree.CellScope) & (x = scope.outerScope(SyntaxTree.CellScope).bodyProcedure) THEN
 				inline := FALSE;
 				cellType := scope.outerScope(SyntaxTree.CellScope).ownerCell;
-				IF ~HasValue(cellType.modifiers,Global.StringDataMemorySize,stackSize) THEN stackSize := DefaultDataMemorySize END;
+				IF ~HasValue(cellType.modifiers,Global.StringDataMemorySize,memorySize) THEN memorySize := DefaultDataMemorySize END;
 				AddBodyCallStub(x);
-				AddStackAllocation(x,stackSize);
+				AddStackAllocation(x,memorySize);
 				ir := implementationVisitor.NewSection(module.allSections,Sections.BodyCodeSection, name,x,dump);
 				ir.SetExported(IsExported(x));
 			ELSIF (scope.outerScope IS SyntaxTree.CellScope) & (x.isConstructor) THEN
@@ -968,7 +968,7 @@ TYPE
 			END;
 		END AddBodyCallStub;
 
-		PROCEDURE AddStackAllocation(symbol: SyntaxTree.Symbol; initStack: LONGINT); (* code that is only necessary for static linkers *)
+		PROCEDURE AddStackAllocation(symbol: SyntaxTree.Symbol; initStack: Basic.Integer); (* code that is only necessary for static linkers *)
 		VAR name: Basic.SegmentedName;
 			ir: IntermediateCode.Section; op: IntermediateCode.Operand;
 		BEGIN
@@ -7889,7 +7889,7 @@ TYPE
 				END
 			(* ---- HALT, SYSTEM.HALT----- *)
 			|Global.Halt, Global.systemHalt:
-				val := p0.resolved(SyntaxTree.IntegerValue).value;
+				val := LONGINT (p0.resolved(SyntaxTree.IntegerValue).value); (* TODO: fix explicit integer truncation *)
 				EmitTrap (position, val);
 			(* ---- ASSERT ----- *)
 			|Global.Assert:
@@ -7899,7 +7899,7 @@ TYPE
 					Condition(p0,trueL,falseL);
 
 					IF p1 = NIL THEN val := AssertTrap
-					ELSE val := p1.resolved(SyntaxTree.IntegerValue).value;
+					ELSE val := LONGINT(p1.resolved(SyntaxTree.IntegerValue).value); (* TODO: fix explicit integer truncation *)
 					END;
 
 					SetLabel(falseL);
@@ -9452,7 +9452,7 @@ TYPE
 		BEGIN
 			IF Trace THEN TraceEnter("VisitIntegerValue") END;
 			InitOperand(result,ModeValue);
-			IntermediateCode.InitImmediate(result.op,IntermediateCode.GetType(system,x.type),x.hvalue);
+			IntermediateCode.InitImmediate(result.op,IntermediateCode.GetType(system,x.type),x.value);
 			IF ~supportedImmediate(result.op)  &~inData THEN
 				GetImmediateMem(result.op)
 			END;
@@ -9469,7 +9469,7 @@ TYPE
 		BEGIN
 			IF Trace THEN TraceEnter("VisitSetValue") END;
 			InitOperand(result,ModeValue);
-			IntermediateCode.InitImmediate(result.op,IntermediateCode.GetType(system,x.type),SYSTEM.VAL(LONGINT,x.value));
+			IntermediateCode.InitImmediate(result.op,IntermediateCode.GetType(system,x.type),SYSTEM.VAL(Basic.Integer,x.value));
 		END VisitSetValue;
 
 		PROCEDURE VisitMathArrayValue*(x: SyntaxTree.MathArrayValue);
@@ -10486,23 +10486,23 @@ TYPE
 		END VisitWithStatement;
 
 		PROCEDURE VisitCaseStatement*(x: SyntaxTree.CaseStatement);
-		VAR var: Operand; jmp,res,op,tmp: IntermediateCode.Operand; j,i,size: LONGINT; part: SyntaxTree.CasePart; constant: SyntaxTree.CaseConstant;
+		VAR var: Operand; jmp,res,op,tmp: IntermediateCode.Operand; range, j: Basic.Integer; i,size: LONGINT; part: SyntaxTree.CasePart; constant: SyntaxTree.CaseConstant;
 			out,else: Label; label: Label;
 			fixups: POINTER TO ARRAY OF Label; section: IntermediateCode.Section; name: Basic.SegmentedName; string: ARRAY 32 OF CHAR;
 			symbol: SyntaxTree.Symbol;
 		BEGIN
 			(*! split case statement into if-elsif statements for large case label lists *)
 			IF Trace THEN TraceEnter("VisitCaseStatement") END;
-			size := x.max-x.min+1;
-			IF (size<0) OR (size > 1024*1024) THEN Error(x.position,"implementation restriction: case table size too large"); RETURN
+			range := x.max-x.min+1;
+			IF (range<0) OR (range > 1024*1024) THEN Error(x.position,"implementation restriction: case table size too large"); RETURN
 			END;
+			size := LONGINT(range);
 			Evaluate(x.variable,var);
 			ReuseCopy(tmp,var.op);
 			ReleaseIntermediateOperand(var.op);
 			var.op := tmp;
 			Emit(Sub(position,var.op,var.op,IntermediateCode.Immediate(IntermediateCode.GetType(system,x.variable.type),x.min)));
 			Convert(var.op,addressType);
-			size := x.max-x.min+1;
 			else := NewLabel();
 			BrgeL(else,var.op,IntermediateCode.Immediate(addressType,size));
 			(*
@@ -10610,7 +10610,7 @@ TYPE
 
 
 			Assign(temporaryVariableDesignator,x.to);
-			IF x.by = NIL THEN by := 1 ELSE by := x.by.resolved(SyntaxTree.IntegerValue).hvalue END;
+			IF x.by = NIL THEN by := 1 ELSE by := x.by.resolved(SyntaxTree.IntegerValue).value END;
 			IF by > 0 THEN
 				cmp := Scanner.LessEqual
 			ELSE

source/FoxIntermediateCode.Mod

@@ -1037,7 +1037,7 @@ TYPE
 		InitOperand(op); op.mode := ModeImmediate; op.type := type; op.intValue := value;
 	END InitImmediate;
 
-	PROCEDURE Immediate*(type: Type; value: LONGINT): Operand;
+	PROCEDURE Immediate*(type: Type; value: HUGEINT): Operand;
 	VAR op: Operand;
 	BEGIN InitImmediate(op,type,value); RETURN op
 	END Immediate;

source/FoxIntermediateLinker.Mod

@@ -467,7 +467,7 @@ TYPE
 				IF syntaxTreeValue(SyntaxTree.BooleanValue).value THEN hugeintValue := 1 ELSE hugeintValue := 0 END
 			ELSIF syntaxTreeValue IS SyntaxTree.IntegerValue THEN
 				(* INTEGER *)
-				hugeintValue := syntaxTreeValue(SyntaxTree.IntegerValue).hvalue;
+				hugeintValue := syntaxTreeValue(SyntaxTree.IntegerValue).value;
 			ELSE
 				HALT(100)
 			END;

source/FoxPrintout.Mod

@@ -798,25 +798,8 @@ TYPE
 		END Hex;
 
 		PROCEDURE VisitIntegerValue*(x: SyntaxTree.IntegerValue);
-
-			PROCEDURE InBounds(val: HUGEINT; bits: LONGINT): BOOLEAN;
-			VAR m: HUGEINT;
-			BEGIN
-				m := ASH(HUGEINT(1),bits-1);
-				RETURN (val < m) & (-val <= m)
-			END InBounds;
-		BEGIN
-			(*! use subtype for representation form ?  *)
-			IF x.hvalue = MIN(HUGEINT) THEN
-				(* special case: display 8000000000000000H without leading minus sign
-					to avoid double minus sign for unary expression -8000000000000000H
-				*)
-				w.Char("0"); w.Hex(x.hvalue,-16); w.Char("H");
-			ELSIF InBounds(x.hvalue,32) THEN
-				w.Int(SHORT(x.hvalue),1);
-			ELSE
-				Hex(x.hvalue); w.Char("H");
-			END;
+		BEGIN
+			w.Int(x.value,1);
 		END VisitIntegerValue;
 
 		PROCEDURE VisitCharacterValue*(x: SyntaxTree.CharacterValue);

source/FoxSemanticChecker.Mod

@@ -420,8 +420,8 @@ TYPE
 		(**
 			check enumeration scope: enter symbols and check for duplicate names
 		**)
-		PROCEDURE CheckEnumerationScope(x: SyntaxTree.EnumerationScope; VAR highest: LONGINT);
-		VAR e: SyntaxTree.Constant; value: SyntaxTree.Expression; nextHighest: LONGINT; prevScope: SyntaxTree.Scope;
+		PROCEDURE CheckEnumerationScope(x: SyntaxTree.EnumerationScope; VAR highest: Basic.Integer);
+		VAR e: SyntaxTree.Constant; value: SyntaxTree.Expression; nextHighest: Basic.Integer; prevScope: SyntaxTree.Scope;
 		BEGIN
 			prevScope := currentScope;
 			currentScope := x;
@@ -456,7 +456,7 @@ TYPE
 		**)
 		PROCEDURE VisitEnumerationType*(x: SyntaxTree.EnumerationType);
 		VAR position: Position; baseScope: SyntaxTree.EnumerationScope; baseType,resolved: SyntaxTree.Type; enumerationBase: SyntaxTree.EnumerationType;
-			lowest, highest: LONGINT;
+			lowest, highest: Basic.Integer;
 		BEGIN
 			IF TypeNeedsResolution(x) THEN
 				IF x.enumerationBase # NIL THEN
@@ -752,13 +752,13 @@ TYPE
 			- enter port type to list of deferred fixes (to avoid infinite loops in the declaration phase)
 		**)
 		PROCEDURE VisitPortType*(x: SyntaxTree.PortType);
-		VAR value: LONGINT;
+		VAR value: Basic.Integer;
 		BEGIN
 			IF TypeNeedsResolution(x) THEN
 				x.SetCellsAreObjects(cellsAreObjects);
 				x.SetSizeExpression(ResolveExpression(x.sizeExpression));
 				IF (x.sizeExpression # NIL) & CheckPositiveIntegerValue(x.sizeExpression,value,FALSE) THEN
-					x.SetSize(value)
+					x.SetSize(LONGINT(value)) (* TODO: fix explicit integer truncation *)
 				ELSE
 					x.SetSize(system.SizeOf(system.longintType));
 				END;
@@ -823,7 +823,7 @@ TYPE
 			END;
 		END HasFlag;
 
-		PROCEDURE HasValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: Position; VAR value: LONGINT): BOOLEAN;
+		PROCEDURE HasValue(modifiers: SyntaxTree.Modifier; name: SyntaxTree.Identifier; VAR position: Position; VAR value: Basic.Integer): BOOLEAN;
 		VAR prev,this: SyntaxTree.Modifier;
 		BEGIN
 			this := modifiers;prev := NIL;
@@ -922,7 +922,7 @@ TYPE
 			- enter procedure to list of deferred fixes (to avoid infinite loops in the declaration phase)
 		**)
 		PROCEDURE VisitProcedureType*(procedureType: SyntaxTree.ProcedureType);
-		VAR modifiers: SyntaxTree.Modifier; value: LONGINT; position: Position;
+		VAR modifiers: SyntaxTree.Modifier; value: Basic.Integer; position: Position;
 		BEGIN
 			IF TypeNeedsResolution(procedureType) THEN
 				modifiers := procedureType.modifiers;
@@ -945,7 +945,7 @@ TYPE
 				ELSIF HasFlag(modifiers, Global.NameNoReturn,position) THEN
 					procedureType.SetNoReturn(TRUE);
 				END;
-				IF HasValue(modifiers,Global.NameStackAligned,position,value) THEN procedureType.SetStackAlignment(value) END;
+				IF HasValue(modifiers,Global.NameStackAligned,position,value) THEN procedureType.SetStackAlignment(LONGINT (value)) END; (* TODO: fix explicit integer truncation *)
 				IF HasFlag(modifiers, Global.NameDelegate,position) THEN procedureType.SetDelegate(TRUE) END;
 				IF HasFlag(modifiers, Global.NameRealtime,position) THEN procedureType.SetRealtime(TRUE) END;
 				CheckModifiers(modifiers, TRUE);
@@ -972,7 +972,7 @@ TYPE
 			symbol: SyntaxTree.Symbol; isRealtime: BOOLEAN;
 			hasPointers: BOOLEAN;
 			modifiers: SyntaxTree.Modifier;
-			value: LONGINT;
+			value: Basic.Integer;
 
 			PROCEDURE IsPointerToRecord(type: SyntaxTree.Type; VAR recordType: SyntaxTree.RecordType): BOOLEAN;
 			BEGIN
@@ -993,7 +993,7 @@ TYPE
 				hasPointers := FALSE;
 				
 				modifiers := x.modifiers;
-				IF HasValue(modifiers,Global.NameAligned,position,value) THEN x.SetAlignmentInBits(value*system.dataUnit) 
+				IF HasValue(modifiers,Global.NameAligned,position,value) THEN x.SetAlignmentInBits(LONGINT(value)*system.dataUnit) (* TODO: fix explicit integer truncation *)
 				END;
 				IF HasFlag(modifiers,Global.NameAbstract,position) THEN x.SetAbstract(TRUE) END;
 				CheckModifiers(modifiers, TRUE);
@@ -1134,10 +1134,11 @@ TYPE
 		PROCEDURE VisitCellType*(x: SyntaxTree.CellType);
 		VAR
 			symbol: SyntaxTree.Symbol; isRealtime: BOOLEAN; parameter: SyntaxTree.Parameter; type: SyntaxTree.Type; len: LONGINT;
-			modifier: SyntaxTree.Modifier; position: Position; value: LONGINT; isEngine: BOOLEAN; property: SyntaxTree.Property;
+			modifier: SyntaxTree.Modifier; position: Position; value: Basic.Integer; isEngine: BOOLEAN; property: SyntaxTree.Property;
 			qualifiedIdentifier: SyntaxTree.QualifiedIdentifier;
 			recordBase: SyntaxTree.RecordType;
-			numberMethods, int: LONGINT;
+			numberMethods: LONGINT;
+			int: Basic.Integer;
 			real: LONGREAL;
 			bool: BOOLEAN;
 			set: Basic.Set;
@@ -1859,10 +1860,10 @@ TYPE
 
 		(** check and resolve integer value **)
 		PROCEDURE VisitIntegerValue*(value: SyntaxTree.IntegerValue);
-		VAR hugeint: HUGEINT;
+		VAR integer: Basic.Integer;
 		BEGIN
-			hugeint := value(SyntaxTree.IntegerValue).hvalue;
-			value.SetType(Global.GetIntegerType(system,hugeint));
+			integer := value(SyntaxTree.IntegerValue).value;
+			value.SetType(Global.GetIntegerType(system,integer));
 			resolvedExpression := value
 		END VisitIntegerValue;
 
@@ -1970,7 +1971,7 @@ TYPE
 			VAR
 				left, right: SyntaxTree.Expression;
 				elementResult: SyntaxTree.Expression;
-				leftInteger, rightInteger, temp: LONGINT;
+				leftInteger, rightInteger: Basic.Integer;
 			BEGIN
 				(* set context of range *)
 				IF element IS SyntaxTree.RangeExpression THEN
@@ -2205,7 +2206,7 @@ TYPE
 		PROCEDURE VisitUnaryExpression*(unaryExpression: SyntaxTree.UnaryExpression);
 		VAR
 			left: SyntaxTree.Expression;
-			int: HUGEINT; real, imaginary: LONGREAL; set: Basic.Set; operator: LONGINT;
+			int: Basic.Integer; real, imaginary: LONGREAL; set: Basic.Set; operator: LONGINT;
 			bool: BOOLEAN;
 			result: SyntaxTree.Expression; type: SyntaxTree.Type; operatorCall: SyntaxTree.Expression;
 			value: SyntaxTree.Value;
@@ -2240,7 +2241,7 @@ TYPE
 				|Scanner.Minus:
 					IF IsIntegerType(left.type.resolved) THEN
 						IF left.resolved # NIL THEN
-							int := -left.resolved(SyntaxTree.IntegerValue).hvalue;
+							int := -left.resolved(SyntaxTree.IntegerValue).value;
 							value := SyntaxTree.NewIntegerValue(unaryExpression.position,int);
 							result.SetResolved(value);
 							type := Global.GetIntegerType(system,int);
@@ -2432,13 +2433,13 @@ TYPE
 		END MathArrayConversion;
 
 		PROCEDURE ConvertValue(position: Position; expression: SyntaxTree.Value; type: SyntaxTree.Type): SyntaxTree.Expression;
-		VAR result: SyntaxTree.Expression; int: HUGEINT; real, imaginary: LONGREAL; set: Basic.Set; char: CHAR; string: Scanner.StringType;
+		VAR result: SyntaxTree.Expression; int: Basic.Integer; real, imaginary: LONGREAL; set: Basic.Set; char: CHAR; string: Scanner.StringType;
 		BEGIN
 			result := expression; type := type.resolved;
 			IF (type IS SyntaxTree.ArrayType) & (type(SyntaxTree.ArrayType).arrayBase.resolved IS SyntaxTree.ByteType) THEN
 				(* skip, no conversion *)
 			ELSIF (expression IS SyntaxTree.IntegerValue)  THEN
-				int := expression(SyntaxTree.IntegerValue).hvalue;
+				int := expression(SyntaxTree.IntegerValue).value;
 				IF (type IS SyntaxTree.IntegerType) OR (type IS SyntaxTree.SizeType) THEN
 					int := Global.ConvertSigned(int,system.SizeOf(type));
 					result := SyntaxTree.NewIntegerValue(position,int);
@@ -2454,16 +2455,13 @@ TYPE
 					result := SyntaxTree.NewComplexValue(expression.position, int, 0);
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.SetType) THEN
-					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,HUGEINT(int)));
+					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,int));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.CharacterType) OR (type IS SyntaxTree.ByteType) THEN
 					result := SyntaxTree.NewCharacterValue(expression.position,SYSTEM.VAL(CHAR,int));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.EnumerationType) THEN
-					IF (int > MAX(LONGINT)) OR (int < MIN(LONGINT)) THEN
-						Error(position, "huge integer value incompatible to enumeration");
-					END;
-					result := SyntaxTree.NewEnumerationValue(expression.position,SHORT(int));
+					result := SyntaxTree.NewEnumerationValue(expression.position,int);
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.PortType) THEN
 					result := ConvertValue(position, expression, system.integerType);
@@ -2509,9 +2507,9 @@ TYPE
 				END
 			ELSIF IsSetValue(expression,set) THEN
 				IF (type IS SyntaxTree.IntegerType) THEN
-					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(HUGEINT,set));
+					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(Basic.Integer,set));
 					result.SetType(type);
-				ELSIF (type IS SyntaxTree.CharacterType) OR (type IS SyntaxTree.ByteType) THEN (* for example: possible via ch = CHR(SYSTEM.VAL(LONGINT,set)) *)
+				ELSIF (type IS SyntaxTree.CharacterType) OR (type IS SyntaxTree.ByteType) THEN (* for example: possible via ch = CHR(SYSTEM.VAL(Basic.Integer,set)) *)
 					result := SyntaxTree.NewCharacterValue(expression.position,SYSTEM.VAL(CHAR,set));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.PortType) THEN
@@ -2544,10 +2542,10 @@ TYPE
 					result := SyntaxTree.NewCharacterValue(expression.position,char);
 					result.SetType(type)
 				ELSIF (type IS SyntaxTree.IntegerType) THEN
-					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(LONGINT,char));
+					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(Basic.Integer,char));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.SetType) THEN
-					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,HUGEINT(ORD(char))));
+					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,Basic.Integer(ORD(char))));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.CharacterType) THEN
 					result := SyntaxTree.NewCharacterValue(expression.position,char);
@@ -2901,12 +2899,12 @@ TYPE
 		PROCEDURE VisitBinaryExpression*(binaryExpression: SyntaxTree.BinaryExpression);
 		VAR left,right,result: SyntaxTree.Expression;
 			leftType, rightType: SyntaxTree.Type;
-			il,ir: LONGINT; rl,rr,a,b,c,d,divisor: LONGREAL; hl,hr: HUGEINT;bl,br: BOOLEAN; sl,sr: Basic.Set;  strl,strr: Scanner.StringType;
+			il,ir: Basic.Integer; rl,rr,a,b,c,d,divisor: LONGREAL; hl,hr: Basic.Integer;bl,br: BOOLEAN; sl,sr: Basic.Set;  strl,strr: Scanner.StringType;
 			cl,cr: CHAR;
 			operator: LONGINT; operatorCall: SyntaxTree.Expression;
 			type: SyntaxTree.Type;
 			value: SyntaxTree.Value;
-			leftFirst, leftLast, leftStep, rightFirst, rightLast, rightStep: LONGINT;
+			leftFirst, leftLast, leftStep, rightFirst, rightLast, rightStep: Basic.Integer;
 			integerConstantFolding: BOOLEAN;
 			list: SyntaxTree.ExpressionList;
 
@@ -2925,7 +2923,7 @@ TYPE
 				type := value.type;
 			END NewSet;
 
-			PROCEDURE NewInteger(v: HUGEINT; t: SyntaxTree.Type);
+			PROCEDURE NewInteger(v: Basic.Integer; t: SyntaxTree.Type);
 			BEGIN
 				value := Global.NewIntegerValue(system,binaryExpression.position,v);
 
@@ -3165,7 +3163,7 @@ TYPE
 					END;
 				ELSIF IsIntegerType(leftType) THEN
 					IF IsIntegerValue(right,ir) (* & (right.type.sizeInBits < 64) *) THEN
-						hr := right.resolved(SyntaxTree.IntegerValue).hvalue;
+						hr := right.resolved(SyntaxTree.IntegerValue).value;
 						IF (hr=0) & ((operator = Scanner.Mod) OR (operator = Scanner.Div) OR (operator = Scanner.Slash)) THEN
 							Error(binaryExpression.position,"division by zero");
 						ELSIF (hr<0) & ((operator = Scanner.Mod) OR (operator = Scanner.Div))THEN
@@ -3201,8 +3199,8 @@ TYPE
 						END;
 					ELS*)
 					IF IsIntegerValue(left,il) & IsIntegerValue(right,ir) (* bootstrap64 & (type.sizeInBits = 64)*) THEN
-						hl := left.resolved(SyntaxTree.IntegerValue).hvalue;
-						hr := right.resolved(SyntaxTree.IntegerValue).hvalue;
+						hl := left.resolved(SyntaxTree.IntegerValue).value;
+						hr := right.resolved(SyntaxTree.IntegerValue).value;
 						CASE operator OF
 						|Scanner.Plus: NewInteger(hl+hr,left.type);
 						|Scanner.Minus: NewInteger(hl-hr,left.type);
@@ -3834,7 +3832,7 @@ TYPE
 		END VisitSelectorDesignator;
 
 		PROCEDURE IndexCheck(index,length: SyntaxTree.Expression);
-		VAR len,idx: LONGINT;
+		VAR len,idx: Basic.Integer;
 		BEGIN
 			IF (index # NIL) & IsIntegerValue(index,idx) THEN
 				IF idx < 0 THEN
@@ -3895,7 +3893,7 @@ TYPE
 		VAR
 			targetArray: SyntaxTree.MathArrayType;
 			first, last, step: SyntaxTree.Expression;
-			firstValue, lastValue, stepValue, length: LONGINT;
+			firstValue, lastValue, stepValue, length: Basic.Integer;
 			rangeExpression: SyntaxTree.RangeExpression;
 		BEGIN
 			IF indexListItem.type = SyntaxTree.invalidType THEN
@@ -4972,7 +4970,7 @@ TYPE
 			RETURN result
 		END CheckTypeDeclarationType;
 
-		PROCEDURE CheckIntegerValue(x: SyntaxTree.Expression; VAR value: LONGINT): BOOLEAN;
+		PROCEDURE CheckIntegerValue(x: SyntaxTree.Expression; VAR value: Basic.Integer): BOOLEAN;
 		VAR result: BOOLEAN;
 		BEGIN
 			result := FALSE;
@@ -5003,7 +5001,7 @@ TYPE
 		PROCEDURE IsUnsignedValue(x: SyntaxTree.Expression; maxSizeInBits: LONGINT): BOOLEAN;
 		BEGIN
 			IF (x.resolved # NIL) & (x.resolved IS SyntaxTree.IntegerValue) THEN
-				RETURN Global.IsUnsignedInteger(x.resolved(SyntaxTree.IntegerValue).hvalue, maxSizeInBits)
+				RETURN Global.IsUnsignedInteger(x.resolved(SyntaxTree.IntegerValue).value, maxSizeInBits)
 			ELSE
 				RETURN FALSE
 			END;
@@ -5012,7 +5010,7 @@ TYPE
 		PROCEDURE IsAddressValue(x: SyntaxTree.Expression): BOOLEAN;
 		BEGIN
 			IF (x.resolved # NIL) & (x.resolved IS SyntaxTree.IntegerValue) THEN
-				RETURN Global.IsUnsignedInteger(x.resolved(SyntaxTree.IntegerValue).hvalue, system.addressType.sizeInBits)
+				RETURN Global.IsUnsignedInteger(x.resolved(SyntaxTree.IntegerValue).value, system.addressType.sizeInBits)
 			ELSE
 				RETURN FALSE
 			END
@@ -5028,7 +5026,7 @@ TYPE
 			RETURN IsSizeType(x.type.resolved, system.addressSize) OR IsAddressValue(x)
 		END IsSizeExpression;
 
-		PROCEDURE CheckEnumerationValue(x: SyntaxTree.Expression; VAR value: LONGINT): BOOLEAN;
+		PROCEDURE CheckEnumerationValue(x: SyntaxTree.Expression; VAR value: Basic.Integer): BOOLEAN;
 		VAR result: BOOLEAN;
 		BEGIN
 			result := FALSE;
@@ -5060,7 +5058,7 @@ TYPE
 			RETURN result;
 		END CheckCharacterValue;
 
-		PROCEDURE CheckPositiveIntegerValue(x: SyntaxTree.Expression; VAR value: LONGINT; includeZero: BOOLEAN): BOOLEAN;
+		PROCEDURE CheckPositiveIntegerValue(x: SyntaxTree.Expression; VAR value: Basic.Integer; includeZero: BOOLEAN): BOOLEAN;
 		VAR result: BOOLEAN;
 		BEGIN
 			result := FALSE;
@@ -5111,7 +5109,7 @@ TYPE
 			type0,type1,type2: SyntaxTree.Type;
 			type,base,parameterType: SyntaxTree.Type;
 			arrayType: SyntaxTree.ArrayType;
-			i, i0, i1, value: LONGINT;
+			i: LONGINT; i0, i1, value: Basic.Integer;
 			r,r0,r1,im: LONGREAL;
 			c: CHAR;
 			id: LONGINT;
@@ -5121,7 +5119,7 @@ TYPE
 			mathArrayType: SyntaxTree.MathArrayType;
 			customBuiltin: SyntaxTree.CustomBuiltin;
 
-			PROCEDURE CheckArity(from,to: LONGINT): BOOLEAN;
+			PROCEDURE CheckArity(from,to: Basic.Integer): BOOLEAN;
 			VAR resultB: BOOLEAN;
 			BEGIN
 				IF numberActualParameters < from THEN
@@ -5586,7 +5584,7 @@ TYPE
 							Error(position, "invalid dimension");
 							base := SyntaxTree.invalidType;
 						ELSE
-							base := ArrayBase(base,i1);
+							base := ArrayBase(base,LONGINT(i1)); (* TODO: fix explicit integer truncation *)
 							IF (base # NIL) & Indexable(base) THEN
 							ELSE
 								Error(position, "len on no array");
@@ -6042,7 +6040,7 @@ TYPE
 							Error(position, "invalid dimension");
 							base := SyntaxTree.invalidType;
 						ELSE
-							base := ArrayBase(base,i1);
+							base := ArrayBase(base,LONGINT(i1)); (* TODO: fix explicit integer truncation *)
 							IF (base # NIL) & Indexable(base) THEN
 							ELSE
 								Error(position, "len on no array");
@@ -6568,7 +6566,7 @@ TYPE
 			ELSIF  (expression.resolved = NIL) OR ~(expression.resolved IS SyntaxTree.IntegerValue) THEN
 				Error(position, "expression is not integer valued");
 				expression := SyntaxTree.invalidExpression
-			ELSIF (expression.resolved(SyntaxTree.IntegerValue).hvalue <0) THEN
+			ELSIF (expression.resolved(SyntaxTree.IntegerValue).value <0) THEN
 				Error(position, "integer is not greater or equal zero");
 			END;
 			RETURN expression
@@ -6743,7 +6741,7 @@ TYPE
 			- check symbol
 		**)
 		PROCEDURE VisitVariable*(variable: SyntaxTree.Variable);
-		VAR modifiers: SyntaxTree.Modifier; value: LONGINT; position: Position; pointerType: SyntaxTree.PointerType;
+		VAR modifiers: SyntaxTree.Modifier; value: Basic.Integer; position: Position; pointerType: SyntaxTree.PointerType;
 		BEGIN
 			IF Trace THEN D.Str("VisitVariable "); D.Str0(variable.name);  D.Ln;  END;
 			IF SymbolNeedsResolution(variable) THEN
@@ -6772,21 +6770,21 @@ TYPE
 						IF ~PowerOf2(value) THEN
 							Error(position, "forbidden alignment - must be power of two");
 						ELSE
-							AdaptStackAlignment(variable.scope(SyntaxTree.ProcedureScope).ownerProcedure, value);
+							AdaptStackAlignment(variable.scope(SyntaxTree.ProcedureScope).ownerProcedure, LONGINT (value)); (* TODO: fix explicit integer truncation *)
 						END;
 					END;
-					variable.SetAlignment(FALSE,value);
+					variable.SetAlignment(FALSE,LONGINT(value)); (* TODO: fix explicit integer truncation *)
 				ELSIF HasValue(modifiers, Global.NameFixed,position, value) THEN
 					IF (variable.scope IS SyntaxTree.ProcedureScope) THEN
 						Error(position, "fixed position not possible in procedure");
 					END;
-					variable.SetAlignment(TRUE, value);
+					variable.SetAlignment(TRUE,LONGINT(value)); (* TODO: fix explicit integer truncation *)
 				ELSIF HasValue(modifiers, Global.NameFictive, position, value) THEN
 					IF (variable.scope IS SyntaxTree.ProcedureScope) THEN
 						Error(position,"fictive offset not possible in procedure");
 					END;
-					variable.SetFictive(value);
-					variable.SetOffset(value*system.dataUnit);
+					variable.SetFictive(LONGINT (value)); (* TODO: fix explicit integer truncation *)
+					variable.SetOffset(LONGINT(value)*system.dataUnit); (* TODO: fix explicit integer truncation *)
 					IF ContainsPointer(variable.type) THEN variable.SetUntraced(TRUE) END;
 				END;
 				IF HasFlag(modifiers, Global.NameRegister, position) THEN variable.SetUseRegister(TRUE) END;
@@ -6884,7 +6882,7 @@ TYPE
 			type: SyntaxTree.Type;
 			selfParameter: SyntaxTree.Parameter; qualifiedIdentifier: SyntaxTree.QualifiedIdentifier;
 			qualifiedType: SyntaxTree.QualifiedType;
-			value: LONGINT;
+			value: Basic.Integer;
 			modifiers: SyntaxTree.Modifier; recentIsRealtime, recentIsBodyProcedure: BOOLEAN;
 			position: Position;
 			fp: SyntaxTree.FingerPrint;
@@ -6921,20 +6919,20 @@ TYPE
 				IF HasFlag(modifiers, Global.NameNoReturn, position) THEN
 					procedureType.SetNoReturn(TRUE);
 				END;
-				IF HasValue(modifiers, Global.NamePcOffset, position, value) THEN procedureType.SetPcOffset(value) END;
+				IF HasValue(modifiers, Global.NamePcOffset, position, value) THEN procedureType.SetPcOffset(LONGINT(value)) (* TODO: fix explicit integer truncation *) END;
 
 				IF HasFlag(modifiers,Global.NameNoPAF,position) THEN procedureType.SetNoPAF(TRUE) END;
 				IF HasFlag(modifiers, Global.NameEntry,position) THEN procedure.SetEntry(TRUE)
 				ELSIF (procedure.scope IS SyntaxTree.ModuleScope) & HasFlag(modifiers, Global.NameExit, position) THEN procedure.SetExit(TRUE)
 				END;
-				IF HasValue(modifiers,Global.NameAligned,position,value) THEN procedure.SetAlignment(FALSE,value)
-				ELSIF HasValue(modifiers,Global.NameFixed,position,value) THEN procedure.SetAlignment(TRUE,value)
+				IF HasValue(modifiers,Global.NameAligned,position,value) THEN procedure.SetAlignment(FALSE,LONGINT(value)) (* TODO: fix explicit integer truncation *)
+				ELSIF HasValue(modifiers,Global.NameFixed,position,value) THEN procedure.SetAlignment(TRUE,LONGINT(value)) (* TODO: fix explicit integer truncation *)
 				END;
 				IF HasValue(modifiers,Global.NameStackAligned, position, value) THEN
 					IF ~PowerOf2(value) THEN
 						Error(position, "forbidden stack alignment - must be power of two");
 					ELSE
-						procedureType.SetStackAlignment(value)
+						procedureType.SetStackAlignment(LONGINT(value)) (* TODO: fix explicit integer truncation *)
 					END;
 				END;
 				IF HasFlag(modifiers,Global.NameRealtime,position) THEN procedureType.SetRealtime(TRUE) END;
@@ -6943,9 +6941,9 @@ TYPE
 				END;
 				IF HasValue(modifiers, Global.NameFingerprint, position, value) THEN 
 					SyntaxTree.InitFingerPrint(fp);
-					fp.shallow := value;
-					fp.public := value;
-					fp.private := value;
+					fp.shallow := LONGINT(value); (* TODO: fix explicit integer truncation *)
+					fp.public := LONGINT(value); (* TODO: fix explicit integer truncation *)
+					fp.private := LONGINT(value); (* TODO: fix explicit integer truncation *)
 					fp.shallowAvailable := TRUE;
 					procedure.SetFingerPrint(fp);
 				END;
@@ -7743,13 +7741,13 @@ TYPE
 			- check 'first' < 'last' and no overlaps between different case labels
 			- check statement sequence
 		**)
-		PROCEDURE CasePart(casePart: SyntaxTree.CasePart; type: SyntaxTree.Type; VAR allcases: SyntaxTree.CaseConstant; VAR min,max: LONGINT);
+		PROCEDURE CasePart(casePart: SyntaxTree.CasePart; type: SyntaxTree.Type; VAR allcases: SyntaxTree.CaseConstant; VAR min,max: Basic.Integer);
 		VAR
 			i: LONGINT;
 			position: Position;
 			expression, left, right: SyntaxTree.Expression;
 			expressionType: SyntaxTree.Type;
-			l, r: LONGINT;
+			l, r: Basic.Integer;
 			cl, cr: CHAR;
 			thiscases: SyntaxTree.CaseConstant;
 		BEGIN
@@ -7836,7 +7834,7 @@ TYPE
 		**)
 		PROCEDURE VisitCaseStatement*(caseStatement: SyntaxTree.CaseStatement);
 		VAR expression: SyntaxTree.Expression; i: LONGINT; type: SyntaxTree.Type; caseList: SyntaxTree.CaseConstant;
-			ch: CHAR; l: LONGINT; min,max: LONGINT; msg: ARRAY 64 OF CHAR;
+			ch: CHAR; l: Basic.Integer; min,max: Basic.Integer; msg: ARRAY 64 OF CHAR;
 		BEGIN
 			expression := ResolveExpression(caseStatement.variable);
 			type := RegularType(expression.position,expression.type);
@@ -7857,7 +7855,7 @@ TYPE
 			END;
 			caseStatement.SetVariable(expression);
 			caseList := NIL;
-			min := MAX(LONGINT); max := MIN(LONGINT);
+			min := MAX(Basic.Integer); max := MIN(Basic.Integer);
 			FOR i := 0 TO caseStatement.CaseParts()-1 DO
 				CasePart(caseStatement.GetCasePart(i),type,caseList,min,max);
 			END;
@@ -7975,7 +7973,7 @@ TYPE
 			IF expression = SyntaxTree.invalidExpression THEN
 			ELSIF  ~CompatibleTo(system,expression.type.resolved,designator.type.resolved) THEN
 				Error(expression.position,"step value of incompatible type");
-			ELSIF (expression.resolved(SyntaxTree.IntegerValue).hvalue = 0) THEN
+			ELSIF (expression.resolved(SyntaxTree.IntegerValue).value = 0) THEN
 				Error(expression.position,"invalid step value");
 			ELSIF type # SyntaxTree.invalidType THEN
 				expression := NewConversion(expression.position,expression,type,NIL)
@@ -8691,7 +8689,7 @@ TYPE
 		**)
 		PROCEDURE Module*(x: SyntaxTree.Module);
 		VAR (* nopov *)
-			import: SyntaxTree.Import; modifier: SyntaxTree.Modifier; value: LONGINT; position: Position; prevIsCellNet: BOOLEAN; prevScope: SyntaxTree.Scope;
+			import: SyntaxTree.Import; modifier: SyntaxTree.Modifier; value: Basic.Integer; position: Position; prevIsCellNet: BOOLEAN; prevScope: SyntaxTree.Scope;
 		BEGIN
 			prevScope := currentScope;
 			prevIsCellNet := currentIsCellNet;
@@ -8893,7 +8891,7 @@ TYPE
 		IF x = NIL THEN RETURN NIL ELSE RETURN x.resolved END;
 	END Resolved;
 
-	PROCEDURE PowerOf2(x: LONGINT): BOOLEAN;
+	PROCEDURE PowerOf2(x: Basic.Integer): BOOLEAN;
 	VAR i: LONGINT;
 	BEGIN
 		i := 1;
@@ -9503,7 +9501,7 @@ TYPE
 		RETURN (type # NIL) & (type IS SyntaxTree.IntegerType) & ~type(SyntaxTree.IntegerType).signed
 	END IsUnsignedIntegerType;
 
-	PROCEDURE IsIntegerValue(x: SyntaxTree.Expression; VAR value: LONGINT): BOOLEAN;
+	PROCEDURE IsIntegerValue(x: SyntaxTree.Expression; VAR value: Basic.Integer): BOOLEAN;
 	VAR result: BOOLEAN;
 	BEGIN
 		IF (x.resolved # NIL) & (x.resolved IS SyntaxTree.IntegerValue) THEN
@@ -9515,7 +9513,7 @@ TYPE
 		RETURN result
 	END IsIntegerValue;
 
-	PROCEDURE IsEnumerationValue(x: SyntaxTree.Expression; VAR value: LONGINT): BOOLEAN;
+	PROCEDURE IsEnumerationValue(x: SyntaxTree.Expression; VAR value: Basic.Integer): BOOLEAN;
 	VAR result: BOOLEAN;
 	BEGIN
 		IF (x.resolved # NIL) & (x.resolved IS SyntaxTree.EnumerationValue) THEN
@@ -10008,7 +10006,7 @@ TYPE
 	END GetConstructor;
 
 	(* enter a case into a list of cases in a sorted way and check for collision *)
-	PROCEDURE EnterCase(VAR root: SyntaxTree.CaseConstant; min,max: LONGINT): BOOLEAN;
+	PROCEDURE EnterCase(VAR root: SyntaxTree.CaseConstant; min,max: Basic.Integer): BOOLEAN;
 	VAR prev,this,new: SyntaxTree.CaseConstant;
 	BEGIN
 		this := root;
@@ -10114,7 +10112,7 @@ TYPE
 		RETURN result
 	END MathArrayStructureOfType;
 
-	PROCEDURE IsStaticRange(x: SyntaxTree.Expression; VAR firstValue, lastValue, stepValue: LONGINT): BOOLEAN;
+	PROCEDURE IsStaticRange(x: SyntaxTree.Expression; VAR firstValue, lastValue, stepValue: Basic.Integer): BOOLEAN;
 	VAR
 		result: BOOLEAN;
 		rangeExpression: SyntaxTree.RangeExpression;

source/FoxSyntaxTree.Mod

@@ -1034,7 +1034,7 @@ TYPE
 	VAR
 		enumerationScope-: EnumerationScope;
 		enumerationBase-: Type;
-		rangeLowest-,rangeHighest-: LONGINT;
+		rangeLowest-,rangeHighest-: Basic.Integer;
 
 		PROCEDURE &InitEnumerationType(position: Position; scope: Scope; enumerationScope: EnumerationScope);
 		BEGIN
@@ -1051,7 +1051,7 @@ TYPE
 		BEGIN enumerationBase := base
 		END SetEnumerationBase;
 
-		PROCEDURE SetRange*(lowest,highest: LONGINT);
+		PROCEDURE SetRange*(lowest,highest: Basic.Integer);
 		BEGIN rangeLowest := lowest; rangeHighest := highest;
 		END SetRange;
 
@@ -1102,7 +1102,7 @@ TYPE
 		BEGIN
 			SELF.length := length;
 			IF (length.resolved # NIL) & (length.resolved IS IntegerValue) THEN
-				staticLength := length.resolved(IntegerValue).value
+				staticLength := LONGINT (length.resolved(IntegerValue).value) (* TODO: staticLength should be of type Basic.Integer too *)
 			END;
 		END SetLength;
 
@@ -1184,7 +1184,7 @@ TYPE
 		BEGIN
 			SELF.length := length;
 			IF (length # NIL) & (length.resolved # NIL) & (length.resolved IS IntegerValue) THEN
-				staticLength := length.resolved(IntegerValue).value;
+				staticLength := LONGINT (length.resolved(IntegerValue).value); (* TODO: staticLength should be of type Basic.Integer too *)
 
 				(* optimization: unless the base type is a dynamic array, make this array static *)
 				IF ~((arrayBase # NIL) & (arrayBase IS MathArrayType) & (arrayBase(MathArrayType).form # Static)) THEN
@@ -2769,22 +2769,21 @@ TYPE
 	(** <<value = 123456>> **)
 	IntegerValue* = OBJECT (Value)
 		VAR
-			hvalue-: HUGEINT;
-			value-: LONGINT;
+			value-: Basic.Integer;
 
-		PROCEDURE & InitIntegerValue(position: Position; hvalue: HUGEINT);
+		PROCEDURE & InitIntegerValue(position: Position; value: Basic.Integer);
 		BEGIN
-			InitValue(position);  SELF.hvalue := hvalue; SELF.value := SHORT(hvalue);
+			InitValue(position);  SELF.value := value;
 		END InitIntegerValue;
 
-		PROCEDURE SetValue*(hvalue: HUGEINT);
-		BEGIN	SELF.hvalue := hvalue; SELF.value := SHORT(hvalue);
+		PROCEDURE SetValue*(value: Basic.Integer);
+		BEGIN	SELF.value := value;
 		END SetValue;
 
 		PROCEDURE Clone(): Expression;
 		VAR copy: IntegerValue;
 		BEGIN
-			NEW(copy, position, hvalue); RETURN copy
+			NEW(copy, position, value); RETURN copy
 		END Clone;
 
 		PROCEDURE Accept*(v: Visitor);
@@ -3043,14 +3042,14 @@ TYPE
 	(** <<value = enum.x >> **)
 	EnumerationValue* = OBJECT (Value)
 	VAR
-		value-: LONGINT;
+		value-: Basic.Integer;
 
-		PROCEDURE & InitEnumerationValue(position: Position; value: LONGINT);
+		PROCEDURE & InitEnumerationValue(position: Position; value: Basic.Integer);
 		BEGIN
 			InitValue(position);  SELF.value := value;
 		END InitEnumerationValue;
 
-		PROCEDURE SetValue*(value: LONGINT);
+		PROCEDURE SetValue*(value: Basic.Integer);
 		BEGIN SELF.value := value
 		END SetValue;
 
@@ -4028,7 +4027,7 @@ TYPE
 
 	END WithStatement;
 
-	CaseConstant*= POINTER TO RECORD min*,max*: LONGINT; next*: CaseConstant END;
+	CaseConstant*= POINTER TO RECORD min*,max*: Basic.Integer; next*: CaseConstant END;
 
 	(** << elements : statements >> **)
 	CasePart* = OBJECT (Part)
@@ -4077,12 +4076,12 @@ TYPE
 			variable-: Expression;
 			elsePart-: StatementSequence;
 			caseParts-: Basic.List;
-			min-,max-: LONGINT;
+			min-,max-: Basic.Integer;
 
 		PROCEDURE & InitCaseStatement( position: Position ; outer: Statement);
 		BEGIN
 			InitStatement(position,outer );  variable := NIL;  elsePart := NIL;  caseParts := NIL;
-			min := MAX(LONGINT); max := MIN(LONGINT);
+			min := MAX(Basic.Integer); max := MIN(Basic.Integer);
 		END InitCaseStatement;
 
 		PROCEDURE SetVariable*( expression: Expression );
@@ -4127,8 +4126,8 @@ TYPE
 		BEGIN position := SELF.position.start; v.VisitCaseStatement(SELF)
 		END Accept;
 
-		PROCEDURE MaxConstant*(): LONGINT;
-		VAR val,i: LONGINT; part: CasePart; const: CaseConstant;
+		PROCEDURE MaxConstant*(): Basic.Integer;
+		VAR val: Basic.Integer; i: LONGINT; part: CasePart; const: CaseConstant;
 		BEGIN
 			val := -1;
 			FOR i := 0 TO CaseParts() - 1 DO
@@ -4142,7 +4141,7 @@ TYPE
 			RETURN val;
 		END MaxConstant;
 
-		PROCEDURE SetMinMax*(min,max: LONGINT);
+		PROCEDURE SetMinMax*(min,max: Basic.Integer);
 		BEGIN
 			SELF.min := min; SELF.max := max;
 		END SetMinMax;
@@ -5862,7 +5861,7 @@ VAR
 		NEW(value,invalidPosition); RETURN value;
 	END NewValue;
 
-	PROCEDURE NewIntegerValue*( position: Position;  value: HUGEINT): IntegerValue;
+	PROCEDURE NewIntegerValue*( position: Position;  value: Basic.Integer): IntegerValue;
 	VAR integerValue: IntegerValue;
 	BEGIN
 		NEW( integerValue, position, value);  RETURN integerValue;
@@ -5915,7 +5914,7 @@ VAR
 		NEW( nilValue, position );  RETURN nilValue
 	END NewNilValue;
 
-	PROCEDURE NewEnumerationValue*( position: Position; value: LONGINT ): EnumerationValue;
+	PROCEDURE NewEnumerationValue*( position: Position; value: Basic.Integer ): EnumerationValue;
 	VAR enumeratorValue: EnumerationValue;
 	BEGIN
 		NEW( enumeratorValue, position, value );  RETURN enumeratorValue

source/FoxTranspilerBackend.Mod

@@ -1062,7 +1062,7 @@ TYPE
 		END VisitAwaitStatement;
 
 		PROCEDURE VisitCaseStatement* (statement: SyntaxTree.CaseStatement);
-		VAR i, value: LONGINT; casePart: SyntaxTree.CasePart; caseConstant: SyntaxTree.CaseConstant;
+		VAR i: LONGINT; value: Basic.Integer; casePart: SyntaxTree.CasePart; caseConstant: SyntaxTree.CaseConstant;
 		BEGIN
 			PrintIndent; writer.String ("switch ("); PrintExpression (statement.variable); writer.Char (')'); writer.Ln;
 			BeginBlock;
@@ -1230,7 +1230,7 @@ TYPE
 		END VisitBooleanValue;
 
 		PROCEDURE VisitIntegerValue* (expression: SyntaxTree.IntegerValue);
-		BEGIN IF expression.value = expression.hvalue THEN writer.Int (expression.value, 0); ELSE writer.String ("0x"); writer.Hex (expression.hvalue, 0); END;
+		BEGIN writer.Int (expression.value, 0);
 		END VisitIntegerValue;
 
 		PROCEDURE VisitCharacterValue* (expression: SyntaxTree.CharacterValue);