reverted (32-bit Oberon legacy): LEN is treated as LONGINT

Behind the scenes all LEN/DIM/INCR expressions are repsented using type Global.System.lenType -- preparation to switch to (correct) SIZE type one day (at least for MATH Arrays)

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

source/FoxArrayBase.Mod

@@ -24,6 +24,9 @@ TYPE
 	BinaryAASLoop = PROCEDURE ( ladr, radr, dadr: ADDRESS; linc, rinc, len: SIZE );
 	BinaryAABLoop = PROCEDURE ( ladr, radr: ADDRESS; linc, rinc, len: SIZE ): BOOLEAN;
 	BinaryASBLoop = PROCEDURE ( ladr, radr: ADDRESS; linc, len: SIZE ): BOOLEAN;
+	
+	LenType = LONGINT; (* should be SIZE but for legacy reasons we have to use this *)
+	
 CONST
 	debug = FALSE;   (* warning: debug=true -> a lot of output is generated -> traps are not displayed in Oberon (Kernel overflow) *)
 	statistics= FALSE;
@@ -7897,13 +7900,13 @@ TYPE
 
 	(*** LEN: array -> array **)
 
-	OPERATOR "LEN"*(CONST left: ARRAY [?]): ARRAY [*] OF SIZE;
+	OPERATOR "LEN"*(CONST left: ARRAY [?]): ARRAY [*] OF LenType;
 	VAR src: ADDRESS; dim,i: SIZE;
 	BEGIN
 		src := SYSTEM.VAL(ADDRESS,left);
 		dim := GetDim( src );
 		IF (DIM(RESULT)#1) OR (LEN(RESULT,0) # dim) THEN NEW(RESULT,dim) END;
-		FOR i := 0 TO dim-1 DO RESULT[i] := GetLen(src,i) END;
+		FOR i := 0 TO dim-1 DO RESULT[i] := LenType(GetLen(src,i)) END;
 		RETURN RESULT
 	END "LEN";
 

source/FoxGlobal.Mod

@@ -244,7 +244,8 @@ TYPE
 		*)
 
 		addressType-, sizeType-, shortintType-, integerType-, longintType-, hugeintType-, wordType-, longWordType-, characterType-, characterType8-, characterType16-, characterType32-, setType-, booleanType-, anyType-,byteType-,
-		realType-, longrealType-, complexType-, longcomplexType-, objectType-, nilType-, rangeType-: SyntaxTree.Type;
+		realType-, longrealType-, complexType-, longcomplexType-, objectType-, nilType-, rangeType-, lenType-: SyntaxTree.Type;
+
 
 		CanPassInRegister-: PassInRegisterProc;
 		cellsAreObjects-: BOOLEAN;
@@ -770,6 +771,9 @@ TYPE
 		system.sizeType := SyntaxTree.NewSizeType(system.addressSize);
 		system.rangeType := SyntaxTree.NewRangeType(3 * system.SizeOf(system.longintType));
 
+		system.lenType := system.longintType;
+		(* generally, the lenType should be sizeType but for historical (legacy) reasons, it is longint in the current implementation *)
+
 		system.complexType := Complex64;
 		system.longcomplexType := Complex128;
 		system.setType := SyntaxTree.NewSetType(system.addressSize);

source/FoxIntermediateBackend.Mod

@@ -1321,7 +1321,7 @@ TYPE
 
 		(* useful operands and types *)
 		nil,one,fp,sp,ap,lr,true,false: IntermediateCode.Operand;
-		bool,addressType,setType, sizeType, byteType: IntermediateCode.Type;
+		bool,addressType,setType, sizeType, lenType, byteType: IntermediateCode.Type;
 
 		commentPrintout: Printout.Printer;
 		dump: Streams.Writer;
@@ -1379,6 +1379,7 @@ TYPE
 			addressType := IntermediateCode.GetType(system,system.addressType);
 			setType := IntermediateCode.GetType(system,system.setType);
 			sizeType := IntermediateCode.GetType(system, system.sizeType);
+			lenType := IntermediateCode.GetType(system, system.lenType);
 			byteType := IntermediateCode.GetType(system, system.byteType);
 			
 			fp := IntermediateCode.Register(addressType,IntermediateCode.GeneralPurposeRegister,IntermediateCode.FP);
@@ -1790,9 +1791,9 @@ TYPE
 			type := type.resolved;
 			IF operand.mode = ModeReference THEN
 				IF type IS SyntaxTree.RangeType THEN
-					MakeMemory(firstOp, operand.op, IntermediateCode.GetType(system, system.longintType), 0);
-					MakeMemory(lastOp, operand.op, IntermediateCode.GetType(system, system.longintType), ToMemoryUnits(system, system.SizeOf(system.longintType)));
-					MakeMemory(stepOp, operand.op, IntermediateCode.GetType(system, system.longintType), 2 * ToMemoryUnits(system, system.SizeOf(system.longintType)));
+					MakeMemory(firstOp, operand.op, IntermediateCode.GetType(system, system.lenType), 0);
+					MakeMemory(lastOp, operand.op, IntermediateCode.GetType(system, system.lenType), ToMemoryUnits(system, system.SizeOf(system.lenType)));
+					MakeMemory(stepOp, operand.op, IntermediateCode.GetType(system, system.lenType), 2 * ToMemoryUnits(system, system.SizeOf(system.lenType)));
 					ReleaseOperand(operand);
 					operand.op := firstOp;
 					operand.tag := lastOp;
@@ -6718,10 +6719,10 @@ TYPE
 				BreqL(end,result.op,IntermediateCode.Immediate(addressType,0));
 				Emit(MovReplace(position,result.op,IntermediateCode.Memory(addressType,result.op,ToMemoryUnits(system,MathDimOffset*addressType.sizeInBits))));
 				SetLabel(end);
-				Convert(result.op,sizeType);
+				Convert(result.op,lenType);
 			ELSE
 				InitOperand(result,ModeValue);
-				IntermediateCode.InitImmediate(result.op, sizeType, SemanticChecker.Dimension(type,{SyntaxTree.Open, SyntaxTree.Static}));
+				IntermediateCode.InitImmediate(result.op, lenType, SemanticChecker.Dimension(type,{SyntaxTree.Open, SyntaxTree.Static}));
 			END
 		END MathArrayDim;
 
@@ -10162,17 +10163,17 @@ TYPE
 				Designate(left, leftO);(* The order is crucial. Do not reorder emission of left and right *)
 
 				(* first *)
-				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.longintType), 0);
+				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.lenType), 0);
 				Emit(Mov(position,mem, rightO.op));
 				ReleaseIntermediateOperand(mem);
 
 				(* last *)
-				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.longintType), ToMemoryUnits(system, system.SizeOf(system.longintType)));
+				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.lenType), ToMemoryUnits(system, system.SizeOf(system.lenType)));
 				Emit(Mov(position,mem, rightO.tag));
 				ReleaseIntermediateOperand(mem);
 
 				(* step *)
-				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.longintType), 2 * ToMemoryUnits(system, system.SizeOf(system.longintType)));
+				MakeMemory(mem, leftO.op, IntermediateCode.GetType(system, system.lenType), 2 * ToMemoryUnits(system, system.SizeOf(system.lenType)));
 				Emit(Mov(position,mem, rightO.extra));
 				ReleaseIntermediateOperand(mem);
 
@@ -10699,15 +10700,15 @@ TYPE
 						(* array range type *)
 						Evaluate(expression, right);
 
-						MakeMemory(mem, left, IntermediateCode.GetType(system, system.longintType), 0);
+						MakeMemory(mem, left, IntermediateCode.GetType(system, system.lenType), 0);
 						Emit(Mov(position,mem, right.op)); (* first *)
 						ReleaseIntermediateOperand(mem);
 
-						MakeMemory(mem, left, IntermediateCode.GetType(system, system.longintType), ToMemoryUnits(system, system.SizeOf(system.longintType)));
+						MakeMemory(mem, left, IntermediateCode.GetType(system, system.lenType), ToMemoryUnits(system, system.SizeOf(system.lenType)));
 						Emit(Mov(position,mem, right.tag)); (* last *)
 						ReleaseIntermediateOperand(mem);
 
-						MakeMemory(mem, left, IntermediateCode.GetType(system, system.longintType), 2 * ToMemoryUnits(system, system.SizeOf(system.longintType)));
+						MakeMemory(mem, left, IntermediateCode.GetType(system, system.lenType), 2 * ToMemoryUnits(system, system.SizeOf(system.lenType)));
 						Emit(Mov(position,mem, right.extra)); (* step *)
 						ReleaseIntermediateOperand(mem);
 

source/FoxSemanticChecker.Mod

@@ -1416,8 +1416,8 @@ TYPE
 		END TwoToThePowerOf;
 
 		(** check if a LEN operator has a correct signature. i.e.
-		for non-tensors: 'OPERATOR "LEN"(): ARRAY [<Dimensionality>] OF LONGINT;'
-		for tensors (or non-tensors): 'OPERATOR "LEN"(): ARRAY [*] OF LONGINT;'
+		for non-tensors: 'OPERATOR "LEN"(): ARRAY [<Dimensionality>] OF <LENTYPE>;'
+		for tensors (or non-tensors): 'OPERATOR "LEN"(): ARRAY [*] OF <LENTYPE>;'
 		**)
 		PROCEDURE CheckLenOperator(operator: SyntaxTree.Operator; arrayStructure: SyntaxTree.MathArrayType): BOOLEAN;
 		VAR
@@ -1430,7 +1430,7 @@ TYPE
 			IF (procedureType.numberParameters = 0) THEN
 				IF (procedureType.returnType # NIL) & (procedureType.returnType.resolved IS SyntaxTree.MathArrayType) THEN
 					returnedArrayType := procedureType.returnType.resolved(SyntaxTree.MathArrayType);
-					IF system.longintType.SameType(returnedArrayType.arrayBase.resolved) THEN
+					IF system.lenType.SameType(returnedArrayType.arrayBase.resolved) THEN
 						IF returnedArrayType.form = SyntaxTree.Open THEN
 							(* ARRAY [*] OF LONGINT: acceptable for both tensors and non-tensors *)
 							result := TRUE
@@ -1974,7 +1974,7 @@ TYPE
 
 					(* guaranteed by VisitRangeExpression: *)
 					ASSERT((left # NIL) & (right # NIL));
-					ASSERT(system.longintType.SameType(left.type.resolved) & system.longintType.SameType(right.type.resolved));
+					ASSERT(system.lenType.SameType(left.type.resolved) & system.lenType.SameType(right.type.resolved));
 
 				ELSE
 					(* the element is not a range expression *)
@@ -3447,7 +3447,7 @@ TYPE
 				END;
 				first := ResolveExpression(first);
 				IF IsIntegerType(first.type.resolved)  THEN
-					first := NewConversion(first.position, first, system.longintType, NIL)
+					first := NewConversion(first.position, first, system.lenType, NIL)
 				ELSE
 					Error(first.position, "lower bound not integer");
 					hasError := TRUE
@@ -3495,7 +3495,7 @@ TYPE
 				END;
 				last := ResolveExpression(last);
 				IF IsIntegerType(last.type.resolved) THEN
-					last := NewConversion(last.position, last, system.longintType, NIL)
+					last := NewConversion(last.position, last, system.lenType, NIL)
 				ELSE
 					Error(last.position, "upper bound not integer");
 					hasError := TRUE
@@ -3509,7 +3509,7 @@ TYPE
 				END;
 				step := ResolveExpression(step);
 				IF IsIntegerType(step.type.resolved) THEN
-					step := NewConversion(step.position, step, system.longintType, NIL)
+					step := NewConversion(step.position, step, system.lenType, NIL)
 				ELSE
 					Error(step.position, "step size not integer");
 					hasError := TRUE
@@ -3917,9 +3917,9 @@ TYPE
 
 					(* add conversions to size type *)
 					(* TODO: needed? *)
-					rangeExpression.SetFirst(NewConversion(Basic.invalidPosition, first, system.sizeType, NIL));
-					rangeExpression.SetLast(NewConversion(Basic.invalidPosition, last, system.sizeType, NIL));
-					rangeExpression.SetStep(NewConversion(Basic.invalidPosition, step, system.sizeType, NIL));
+					rangeExpression.SetFirst(NewConversion(Basic.invalidPosition, first, system.lenType, NIL));
+					rangeExpression.SetLast(NewConversion(Basic.invalidPosition, last, system.lenType, NIL));
+					rangeExpression.SetStep(NewConversion(Basic.invalidPosition, step, system.lenType, NIL));
 				END;
 
 				IF indexDesignator.hasTensorRange THEN
@@ -5287,7 +5287,7 @@ TYPE
 								REPEAT
 									actualParameter := actualParameters.GetExpression(i);
 									IF CheckSizeType(actualParameter) THEN
-										actualParameter := NewConversion(Basic.invalidPosition,actualParameter,system.longintType,NIL);
+										actualParameter := NewConversion(Basic.invalidPosition,actualParameter,system.lenType,NIL);
 										actualParameters.SetExpression(i,actualParameter);
 									END;
 									INC(i);
@@ -5356,9 +5356,9 @@ TYPE
 									END;
 
 									parameterType := SyntaxTree.NewMathArrayType(Basic.invalidPosition,currentScope,SyntaxTree.Open);
-									parameterType(SyntaxTree.MathArrayType).SetArrayBase(system.sizeType);
+									parameterType(SyntaxTree.MathArrayType).SetArrayBase(system.lenType);
 									IF ~CompatibleTo(system,type1,parameterType) THEN
-										Error(parameter1.position,"parameter incompatible to math array of size");
+										Error(parameter1.position,"parameter incompatible to math array len type");
 										result := SyntaxTree.invalidExpression;
 									ELSE
 										parameter1 := NewConversion(Basic.invalidPosition,parameter1,parameterType,NIL); actualParameters.SetExpression(1,parameter1);
@@ -5537,7 +5537,7 @@ TYPE
 					END;
 				(* ---- LEN ----- *)
 				ELSIF (id = Global.Len) & CheckArity(1,2) THEN
-					type := system.longintType;
+					type := system.lenType;
 					base := type0;
 
 					IF (base IS SyntaxTree.PointerType) & (parameter0 IS SyntaxTree.Designator) THEN
@@ -5572,7 +5572,7 @@ TYPE
 							END;
 						END;
 						IF numberActualParameters=2 THEN
-							parameter1 := NewConversion(parameter1.position,parameter1,system.longintType,NIL);
+							parameter1 := NewConversion(parameter1.position,parameter1,system.lenType,NIL);
 							actualParameters.SetExpression(1,parameter1);
 						ELSIF base IS SyntaxTree.MathArrayType THEN
 							Error(position, "missing dimension specification");
@@ -5599,23 +5599,23 @@ TYPE
 							END;
 						END;
 					ELSE
-						type := system.longintType;
+						type := system.lenType;
 					END;
 				(* ---- FIRST ---- *)
 				ELSIF (id = Global.First) & CheckArity(1,1) THEN
-					type := system.longintType;
+					type := system.lenType;
 					IF CheckRangeType(parameter0) THEN END;
 					result.SetAssignable(parameter0.assignable)
 
 				(* ---- LAST ---- *)
 				ELSIF (id = Global.Last) & CheckArity(1,1) THEN
-					type := system.longintType;
+					type := system.lenType;
 					IF CheckRangeType(parameter0) THEN END;
 					result.SetAssignable(parameter0.assignable)
 
 				(* ---- STEP ---- *)
 				ELSIF (id = Global.Step) & CheckArity(1,1) THEN
-					type := system.longintType;
+					type := system.lenType;
 					IF CheckRangeType(parameter0) THEN END;
 					result.SetAssignable(parameter0.assignable)
 
@@ -6007,7 +6007,7 @@ TYPE
 					type := system.addressType
 				(* ---- INCR ----- *)
 				ELSIF (id = Global.Incr) & CheckArity(1,2) THEN
-					type := system.sizeType;
+					type := system.lenType;
 					base := type0;
 					IF (numberActualParameters =2) & CheckSizeType(parameter1) THEN
 						IF ~IsIntegerValue(parameter1,i1) THEN i1 := 0 END;
@@ -6025,17 +6025,17 @@ TYPE
 								base := SyntaxTree.invalidType;
 							END;
 						END;
-						parameter1 := NewConversion(parameter1.position,parameter1,system.longintType,NIL);
+						parameter1 := NewConversion(parameter1.position,parameter1,system.lenType,NIL);
 						actualParameters.SetExpression(1,parameter1);
 						IF (numberActualParameters =2) & (parameter1 IS SyntaxTree.IntegerValue) THEN
 							mathArrayType := base(SyntaxTree.MathArrayType);
 							IF (mathArrayType.form = SyntaxTree.Static) THEN
 								result := SyntaxTree.NewIntegerValue(position,ToMemoryUnits(system,mathArrayType.staticIncrementInBits));
-								type := system.longintType;
+								type := system.lenType;
 							END;
 						END;
 					ELSE
-						type := system.longintType;
+						type := system.lenType;
 					END;
 
 
@@ -6047,7 +6047,7 @@ TYPE
 					Error(position, "all operator not applicable");
 				(* ---- DIM ----- *)
 				ELSIF (id = Global.Dim) & CheckArity(1,1) THEN
-					type := system.sizeType;
+					type := system.lenType;
 					IF type0 IS SyntaxTree.MathArrayType THEN
 						IF type0(SyntaxTree.MathArrayType).form # SyntaxTree.Tensor THEN
 							i := Dimension(type0,{SyntaxTree.Open,SyntaxTree.Static});