Allowed for marking of temporary arguments, used for example in expressions like

A := B` * C
A := ALIAS OF B^
A := ALIAS OF RESHAPE(B,[6])
A := RESHAPE(B,[6]) * RESHAPE(C,[6]);


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

source/FoxArrayBase.Mod

@@ -131,9 +131,13 @@ TYPE
 
 	(* used for optimizations of MatMul with small sizes (Alexey Morozov) *)
 	SmallMatMul* = PROCEDURE(dadr, ladr, radr: LONGINT);
+	
+	
 
 
 VAR
+	temporary*:  T0;
+
 	alloc*: LONGINT;   (* statistics *)
 	allocTemp*: LONGINT;   (* statistics *)
 
@@ -1468,7 +1472,7 @@ Sufficient (but not necessary) conditions:
 		END NewData;
 
 	BEGIN
-		IF dest # NIL THEN Size := GetSize( dest );  ASSERT( Size = elementsize );  END;
+		IF dest # NIL THEN Size := GetSize( dest );  ASSERT ((Size=0) OR (Size = elementsize ));  END;
 		IF debug THEN KernelLog.String( "Allocate same " );  Report( "allocation source", src );  Report( "allocation des", dest );  END;
 		IF dest = NIL THEN  (* NIL pointer, guaranteed to be tensor *)
 			ptr := GetArrayDesc( GetDim( src ) );  dest :=ptr;
@@ -9592,6 +9596,9 @@ TYPE
 			END;
 		ELSIF (dest = 0) THEN  (* is tensor for sure *)
 			NewDescriptor;  NewData;  CopyData;  dest := new;
+		ELSIF (dest = temporary) THEN
+			NewDescriptorForSameData;
+			dest := new;
 		ELSIF TargetContinuous() THEN
 			NewDescriptor; new:=dest;  CopyData;
 		(*todo: check if target continous memory of correct size, if so don't allocate memory*)
@@ -10140,7 +10147,10 @@ TYPE
 	END "ALL";
 
 BEGIN
-	alloc := 0;  SetDefaults();  InitOptimization();  (* CreateTypePool;  *)
+	alloc := 0;  NEW(temporary); 
+	PutFlags(temporary,{TensorFlag});
+	PutDim(temporary, 0);
+	SetDefaults();  InitOptimization();  (* CreateTypePool;  *)
 END FoxArrayBase.
 
 Compiler.Compile FoxArrayBase.Mod ~

source/FoxIntermediateBackend.Mod

@@ -6584,8 +6584,8 @@ TYPE
 			END;
 		END InitFields;
 
-		PROCEDURE InitVariable(VAR variable: SyntaxTree.Variable);
-		VAR type: SyntaxTree.Type; operand: Operand; tmp: IntermediateCode.Operand; reference: SyntaxTree.Expression;
+		PROCEDURE InitVariable(VAR variable: SyntaxTree.Variable; temporary: BOOLEAN);
+		VAR type: SyntaxTree.Type; operand: Operand; tmp, mem: IntermediateCode.Operand; reference: SyntaxTree.Expression; symbol: SyntaxTree.Symbol;
 		BEGIN
 			type := variable.type.resolved;
 			IF (type IS SyntaxTree.MathArrayType) THEN
@@ -6593,11 +6593,24 @@ TYPE
 					IF type.form = SyntaxTree.Open THEN
 						Symbol(variable,operand);
 						InitFields(type, operand.tag,0);
+						IF temporary THEN
+							PutMathArrayField(operand.tag, IntermediateCode.Immediate(addressType,SYSTEM.VAL(LONGINT,{StackFlag})),MathFlagsOffset);
+						END;
 					ELSIF type.form = SyntaxTree.Tensor THEN
 						Symbol(variable, operand);
 						MakeMemory(tmp,operand.op,addressType,0);
 						ReleaseOperand(operand);
-						Emit(Mov(position,tmp, nil ) );
+						IF temporary THEN
+							(* trick -- temporary object from array base *)
+							symbol := GetSymbol(moduleScope,"FoxArrayBase","temporary");
+							Symbol(symbol,operand);
+							MakeMemory(mem,operand.op,addressType,0);
+							ReleaseOperand(operand);
+							Emit(Mov(position,tmp, mem) );
+							ReleaseOperand(operand);
+						ELSE
+							Emit(Mov(position,tmp, nil ) );
+						END;
 						ReleaseIntermediateOperand(tmp);
 					END;
 				END;
@@ -6912,14 +6925,14 @@ TYPE
 					scope.AddVariable(variable(SyntaxTree.Variable));
 					scope.EnterSymbol(variable, duplicate);
 					ASSERT(~duplicate);
-					InitVariable(variable(SyntaxTree.Variable));
+					InitVariable(variable(SyntaxTree.Variable),TRUE);
 				ELSE
 					variable.SetUseRegister(TRUE);
 					variable(SyntaxTree.Variable).SetOffset(0);
 				END;
 			ELSE
 				variable.SetUntraced(untraced);
-				InitVariable(variable(SyntaxTree.Variable));
+				InitVariable(variable(SyntaxTree.Variable),TRUE);
 				(*
 				ASSERT(variable.type.resolved = type.resolved)
 				*)
@@ -10941,7 +10954,7 @@ TYPE
 		BEGIN
 			x := scope.firstVariable;
 			WHILE x # NIL DO
-				InitVariable(x);
+				InitVariable(x,FALSE);
 				x := x.nextVariable;
 			END;
 		END InitVariables;

source/FoxParser.Mod

@@ -645,7 +645,8 @@ TYPE
 				designator := SyntaxTree.NewSelfDesignator(position);
 			ELSIF Optional(Scanner.Result) THEN
 				designator := SyntaxTree.NewResultDesignator(position);
-			ELSIF (Token() = Scanner.Address) OR (Token()=Scanner.Size) OR (Token() = Scanner.Alias) THEN
+			(* ADDRESS AND SIZE can be type identifiers used for type conversion *)
+			ELSIF (Token() = Scanner.Address) OR (Token()=Scanner.Size) THEN
 				identifier := symbol.identifier;
 				designator := SyntaxTree.NewIdentifierDesignator(position,identifier);
 				NextSymbol;
@@ -752,7 +753,7 @@ TYPE
 
 		(** Factor = Number | Character | String | 'nil' | 'imag' | 'true' | 'false' | Set
 			 			  | '(' Expression ')' | '~' Factor | Factor '`' | Designator | MathArray.
-			 			  | 'SIZE' 'OF' Designator | 'ADDRESS' 'OF' Designator
+			 			  | 'SIZE' 'OF' Designator | 'ADDRESS' 'OF' Designator | 'ALIAS' OF Expression
 			 			  **)
 		PROCEDURE Factor( ): SyntaxTree.Expression;
 		VAR factor: SyntaxTree.Expression; position: Position; operator: LONGINT;
@@ -811,14 +812,22 @@ TYPE
 					factor := Factor();
 					factor := SyntaxTree.NewUnaryExpression( position, factor, Scanner.Not );
 					factor.End( symbol.position.end );
-			| Scanner.Address, Scanner.Size, Scanner.Alias:
+			| Scanner.Address, Scanner.Size:
 					operator := Token();
-					factor := Designator();
+					factor := Designator(); (* ADDRESS AND SIZE can be type identifiers used for type conversion *)
 					IF Optional(Scanner.Of) THEN
 						factor := Designator();
 						factor := SyntaxTree.NewUnaryExpression( position, factor, operator );
 					END;
 					factor.End (symbol.position.end)
+			| Scanner.Alias:
+					operator := Token();
+					NextSymbol();
+					IF Mandatory(Scanner.Of) THEN
+						factor := Factor();
+						factor := SyntaxTree.NewUnaryExpression( position, factor, operator );
+					END;
+					factor.End (symbol.position.end)
 			| Scanner.Self, Scanner.Result, Scanner.Identifier, Scanner.New:
 					factor := Designator();
 					factor.End( symbol.position.end );