Added proper type definition for evaluating constant set expressions

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

source/FoxBasic.Mod

@@ -40,6 +40,8 @@ TYPE
 	SectionName*= ARRAY 256 OF CHAR;
 	MessageString*= ARRAY 256 OF CHAR;
 
+	Set* = SET64;
+
 	ObjectArray = POINTER TO ARRAY OF ANY;
 	IntegerArray = POINTER TO ARRAY OF LONGINT;
 

source/FoxFingerPrinter.Mod

@@ -829,7 +829,7 @@ TYPE
 
 		(* fp = fp & Set *)
 		PROCEDURE VisitSetValue*(x: SyntaxTree.SetValue);
-		BEGIN FPSet(SELF.fp,x.value) END VisitSetValue;
+		BEGIN FPHugeInt(SELF.fp,SYSTEM.VAL(HUGEINT,x.value)) END VisitSetValue;
 
 		PROCEDURE VisitMathArrayExpression*(x: SyntaxTree.MathArrayExpression);
 		VAR element: SyntaxTree.Expression; i: LONGINT;

source/FoxGlobal.Mod

@@ -1464,9 +1464,11 @@ TYPE
 		IF system.SizeOf(type) = 32 THEN RETURN MIN(REAL) ELSE RETURN MIN(LONGREAL) END;
 	END MinFloat;
 
-	PROCEDURE ConvertSet*(this: SET; bits: LONGINT): SET;
+	PROCEDURE ConvertSet*(this: Basic.Set; bits: LONGINT): Basic.Set;
+	VAR i: LONGINT;
 	BEGIN
-		RETURN this * {0 .. MIN (bits - 1, MAX (SET))};
+		WHILE bits <= MAX (Basic.Set) DO EXCL (this, bits); INC (bits) END;
+		RETURN this;
 	END ConvertSet;
 
 	PROCEDURE IsUnsignedInteger*(this: HUGEINT; sizeInBits: LONGINT): BOOLEAN;
@@ -1542,7 +1544,7 @@ TYPE
 		RETURN value
 	END NewBooleanValue;
 	
-	PROCEDURE GetSetType*(system: System; this: SET): SyntaxTree.SetType;
+	PROCEDURE GetSetType*(system: System; this: Basic.Set): SyntaxTree.SetType;
 	BEGIN
 		IF this * {0 .. 7} = this THEN RETURN Set8
 		ELSIF this * { 0 .. 15 } = this THEN RETURN Set16
@@ -1551,7 +1553,7 @@ TYPE
 		END
 	END GetSetType;
 
-	PROCEDURE NewSetValue*(system: System; position: Position; s: SET): SyntaxTree.Value;
+	PROCEDURE NewSetValue*(system: System; position: Position; s: Basic.Set): SyntaxTree.Value;
 	VAR value: SyntaxTree.SetValue;
 	BEGIN
 		value := SyntaxTree.NewSetValue(position,s);

source/FoxIntermediateBackend.Mod

@@ -11542,10 +11542,10 @@ TYPE
 		END Size;
 
 
-		PROCEDURE Set(section: IntermediateCode.Section; value: SET);
+		PROCEDURE Set(section: IntermediateCode.Section; value: Basic.Set);
 		VAR op: IntermediateCode.Operand;
 		BEGIN
-			IntermediateCode.InitImmediate(op,IntermediateCode.GetType(module.system, module.system.longintType),SYSTEM.VAL(LONGINT,value));
+			IntermediateCode.InitImmediate(op,IntermediateCode.GetType(module.system, module.system.sizeType),SYSTEM.VAL(HUGEINT,value));
 			section.Emit(Data(Basic.invalidPosition,op));
 		END Set;
 

source/FoxPrintout.Mod

@@ -829,13 +829,13 @@ TYPE
 		BEGIN
 			w.String("{");
 			i := 0;
-			WHILE (i<MAX(SET)) & ~(i IN x.value)  DO
+			WHILE (i<MAX(Basic.Set)) & ~(i IN x.value)  DO
 				INC(i);
 			END;
-			IF i<MAX(SET) THEN
+			IF i<MAX(Basic.Set) THEN
 				w.Int(i,1);
 				INC(i);
-				WHILE i < MAX(SET) DO
+				WHILE i < MAX(Basic.Set) DO
 					IF i IN x.value THEN w.String(","); w.Int(i,1); END;
 					INC(i)
 				END

source/FoxSemanticChecker.Mod

@@ -1140,7 +1140,7 @@ TYPE
 			numberMethods, int: LONGINT;
 			real: LONGREAL;
 			bool: BOOLEAN;
-			set: SET;
+			set: Basic.Set;
 			v: SyntaxTree.Expression;
 			str: Scanner.StringType;
 			atype: SyntaxTree.ArrayType;
@@ -1962,7 +1962,7 @@ TYPE
 			element: SyntaxTree.Expression;
 			constant: BOOLEAN;
 			elements: SyntaxTree.ExpressionList;
-			s: SET;
+			s: Basic.Set;
 			result: SyntaxTree.Expression;
 			value: SyntaxTree.Value;
 
@@ -2205,7 +2205,7 @@ TYPE
 		PROCEDURE VisitUnaryExpression*(unaryExpression: SyntaxTree.UnaryExpression);
 		VAR
 			left: SyntaxTree.Expression;
-			int: HUGEINT; real, imaginary: LONGREAL; set: SET; operator: LONGINT;
+			int: HUGEINT; real, imaginary: LONGREAL; set: Basic.Set; operator: LONGINT;
 			bool: BOOLEAN;
 			result: SyntaxTree.Expression; type: SyntaxTree.Type; operatorCall: SyntaxTree.Expression;
 			value: SyntaxTree.Value;
@@ -2432,7 +2432,7 @@ 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: SET; char: CHAR; string: Scanner.StringType;
+		VAR result: SyntaxTree.Expression; int: HUGEINT; 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
@@ -2454,7 +2454,7 @@ TYPE
 					result := SyntaxTree.NewComplexValue(expression.position, int, 0);
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.SetType) THEN
-					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(SET,int));
+					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,HUGEINT(int)));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.CharacterType) OR (type IS SyntaxTree.ByteType) THEN
 					result := SyntaxTree.NewCharacterValue(expression.position,SYSTEM.VAL(CHAR,int));
@@ -2509,7 +2509,7 @@ TYPE
 				END
 			ELSIF IsSetValue(expression,set) THEN
 				IF (type IS SyntaxTree.IntegerType) THEN
-					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(LONGINT,set));
+					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(HUGEINT,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)) *)
 					result := SyntaxTree.NewCharacterValue(expression.position,SYSTEM.VAL(CHAR,set));
@@ -2547,7 +2547,7 @@ TYPE
 					result := SyntaxTree.NewIntegerValue(expression.position,SYSTEM.VAL(LONGINT,char));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.SetType) THEN
-					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(SET,char));
+					result := SyntaxTree.NewSetValue(expression.position,SYSTEM.VAL(Basic.Set,HUGEINT(ORD(char))));
 					result.SetType(type);
 				ELSIF (type IS SyntaxTree.CharacterType) THEN
 					result := SyntaxTree.NewCharacterValue(expression.position,char);
@@ -2901,7 +2901,7 @@ 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: SET;  strl,strr: Scanner.StringType;
+			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;
 			cl,cr: CHAR;
 			operator: LONGINT; operatorCall: SyntaxTree.Expression;
 			type: SyntaxTree.Type;
@@ -2918,7 +2918,7 @@ TYPE
 				type := system.booleanType
 			END NewBool;
 
-			PROCEDURE NewSet(v: SET);
+			PROCEDURE NewSet(v: Basic.Set);
 			BEGIN
 				value := Global.NewSetValue(system,binaryExpression.position,v);
 				result.SetResolved(value);
@@ -9577,7 +9577,7 @@ TYPE
 		RETURN result
 	END IsBooleanValue;
 
-	PROCEDURE IsSetValue(x: SyntaxTree.Expression; VAR value: SET): BOOLEAN;
+	PROCEDURE IsSetValue(x: SyntaxTree.Expression; VAR value: Basic.Set): BOOLEAN;
 	VAR result: BOOLEAN;
 	BEGIN
 		IF  (x.resolved # NIL) & (x.resolved IS SyntaxTree.SetValue) THEN

source/FoxSyntaxTree.Mod

@@ -2831,14 +2831,14 @@ TYPE
 	(** <<value =  {1,2,3..5}>> **)
 	SetValue* = OBJECT (Value)
 		VAR
-			value-: SET;
+			value-: Basic.Set;
 
-		PROCEDURE & InitSetValue(position: Position; value: SET);
+		PROCEDURE & InitSetValue(position: Position; value: Basic.Set);
 		BEGIN
 			InitValue(position);  SELF.value := value;
 		END InitSetValue;
 
-		PROCEDURE SetValue*(value: SET);
+		PROCEDURE SetValue*(value: Basic.Set);
 		BEGIN	SELF.value := value
 		END SetValue;
 
@@ -5874,7 +5874,7 @@ VAR
 		NEW( characterValue, position, value);  RETURN characterValue;
 	END NewCharacterValue;
 
-	PROCEDURE NewSetValue*(position: Position; value: SET): SetValue;
+	PROCEDURE NewSetValue*(position: Position; value: Basic.Set): SetValue;
 	VAR setValue: SetValue;
 	BEGIN
 		NEW(setValue, position, value); RETURN setValue