From a7cee196ec105da88e0871a29a32a93dfb89fc2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kristian=20Stav=C3=A5ker?= Date: Sat, 18 Aug 2007 15:04:24 +0000 Subject: [PATCH] Modified the handling of array for constructors. git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@2872 f25d12d1-65f4-0310-ae8a-bbce733d8d8e --- Compiler/Codegen.mo | 11 +- Compiler/Inst.mo | 282 ++++++++++++++++++++++++++------------------ Compiler/Static.mo | 16 +-- 3 files changed, 185 insertions(+), 124 deletions(-) diff --git a/Compiler/Codegen.mo b/Compiler/Codegen.mo index fdbac3242af..35351882d26 100644 --- a/Compiler/Codegen.mo +++ b/Compiler/Codegen.mo @@ -2518,6 +2518,13 @@ algorithm Algorithm.Else else_; Algorithm.Statement algStmt; Boolean a; + + // Part of ValueBlock implementation, special treatment of _ := VB case + case (Algorithm.ASSIGN(_,Exp.CREF_IDENT("WILDCARD__",{}),exp as Exp.VALUEBLOCK(_,_,_,_)),tnr,context) + equation + (cfn,_,tnr1) = generateExpression(exp, tnr, context); + then (cfn,tnr1); + case (Algorithm.ASSIGN(type_ = typ,componentRef = cref,exp = exp),tnr,context) equation Debug.fprintln("cgas", "generate_algorithm_statement"); @@ -3947,8 +3954,8 @@ algorithm then (cfn,tnr2,tvar); case (Exp.T_ARRAY(_,SOME(_) :: _),_,_,_,_) local - equation - Debug.fprintln("failtrace", "# Codegen: Only 1 dim return arrays from Valueblock implemented"); + equation + Debug.fprintln("failtrace", "# Codegen.addValueblockRetVar failed, N-dim arrays not supported"); then fail(); case (localType,localFunc,localTnr,localResVar,_) local diff --git a/Compiler/Inst.mo b/Compiler/Inst.mo index 43dd1688acc..015aee3a8c4 100644 --- a/Compiler/Inst.mo +++ b/Compiler/Inst.mo @@ -8197,18 +8197,26 @@ algorithm // Absyn.CALL(Absyn.CREF_IDENT("array",{}),Absyn.FOR_ITER_FARG(e1,id,e2))),impl) Absyn.CALL(Absyn.CREF_IDENT("array",{}),Absyn.FOR_ITER_FARG(e1,rangeList))),impl) local - Absyn.Exp e1,e2; + Absyn.Exp e1,vb; Absyn.ForIterators rangeList; - Absyn.Algorithm absynStmt; - list idList; - Absyn.ComponentRef c; + Absyn.ComponentRef c; + list tempLoopVarNames; + list vb_body,tempLoopVarsInit; + list tempLoopVars; + Exp.Exp vb2; equation // rangeList = {(id,e2)}; - idList = extractLoopVars(rangeList,{}); + (tempLoopVarNames,tempLoopVars,tempLoopVarsInit) = createTempLoopVars(rangeList,{},{},{},1); //Transform this function call into a number of nested for-loops - absynStmt = createForIteratorAlgorithm(e1,rangeList,idList,c); - (cache,stmt) = instStatement(cache,env,pre,absynStmt,impl); + vb_body = createForIteratorAlgorithm(e1,rangeList,tempLoopVarNames,tempLoopVarNames,c); + + vb_body = listAppend(tempLoopVarsInit,vb_body); + vb = Absyn.VALUEBLOCK(tempLoopVars,Absyn.VALUEBLOCKALGORITHMS(vb_body),Absyn.BOOL(true)); + (cache,vb2,_,_) = Static.elabExp(cache,env,vb,impl,NONE,true); + + // _ := { ... }, this will be handled in Codegen.algorithmStatement + stmt = Algorithm.ASSIGN(Exp.BOOL(),Exp.CREF_IDENT("WILDCARD__",{}),vb2); then (cache,stmt); @@ -8217,24 +8225,26 @@ algorithm // Absyn.CALL(c2,Absyn.FOR_ITER_FARG(e1,id,e2))),impl) Absyn.CALL(c2,Absyn.FOR_ITER_FARG(e1,rangeList))),impl) local - Absyn.Exp e1,e2,vb; + Absyn.Exp e1,vb; Absyn.ForIterators rangeList; - Absyn.Algorithm absynStmt,temp; - list idList; + Absyn.Algorithm absynStmt; + list tempLoopVarNames; Absyn.ComponentRef c1,c2; - list declList; - list vb_body; + list declList,tempLoopVars; + list vb_body,tempLoopVarsInit; equation // rangeList = {(id,e2)}; - idList = extractLoopVars(rangeList,{}); + (tempLoopVarNames,tempLoopVars,tempLoopVarsInit) = createTempLoopVars(rangeList,{},{},{},1); // Create temporary array to store the result from the for-iterator construct - (cache,declList) = createForIteratorArray(cache,env,e1,idList,rangeList,impl); + (cache,declList) = createForIteratorArray(cache,env,e1,rangeList,impl); + + declList = listAppend(declList,tempLoopVars); // Create for-statements - temp = createForIteratorAlgorithm(e1,rangeList,idList,Absyn.CREF_IDENT("VEC__",{})); + vb_body = createForIteratorAlgorithm(e1,rangeList,tempLoopVarNames,tempLoopVarNames,Absyn.CREF_IDENT("VEC__",{})); - vb_body = Util.listCreate(Absyn.ALGORITHMITEM(temp,NONE())); + vb_body = listAppend(tempLoopVarsInit,vb_body); vb = Absyn.VALUEBLOCK(declList,Absyn.VALUEBLOCKALGORITHMS(vb_body), Absyn.CALL(c2,Absyn.FUNCTIONARGS({Absyn.CREF(Absyn.CREF_IDENT("VEC__",{}))},{}))); absynStmt = Absyn.ALG_ASSIGN(Absyn.CREF(c1),vb); @@ -10013,7 +10023,7 @@ end isTopCall; // array iterator constructors. For instance, // v := { 3*i*j for i in 1:5, j in 1:n } -public function createForIteratorEquations "function: createForIteratorEquations +protected function createForIteratorEquations "function: createForIteratorEquations author: KS Function that creates for equations to be used in the @@ -10057,7 +10067,31 @@ algorithm end matchcontinue; end createForIteratorEquations; -public function createArrayIndexing "function: createArrayIndexing +protected function extractLoopVars "function: extractLoopVars + author: KS" + input Absyn.ForIterators rangeIdList; + input list accList; + output list outList; +algorithm + outList := + matchcontinue (rangeIdList,accList) + local + list localAccList; + list localAccVars2; + case ({},localAccList) + then localAccList; + case ((id,_) :: restIdRange,localAccList) + local + Absyn.ForIterators restIdRange; + Absyn.Ident id; + equation + localAccList = listAppend(localAccList,{id}); + localAccList = extractLoopVars(restIdRange,localAccList); + then localAccList; + end matchcontinue; +end extractLoopVars; + +protected function createArrayIndexing "function: createArrayIndexing author: KS Function that creates a list of subscripts to be used when indexing an array." input list idList; @@ -10082,7 +10116,7 @@ algorithm end matchcontinue; end createArrayIndexing; -public function createArrayReference "function: createArrayReference +protected function createArrayReference "function: createArrayReference author: KS" input Absyn.ComponentRef c; input list subList; @@ -10096,9 +10130,9 @@ algorithm list sl,localSubList; Absyn.Exp c2; equation - sl = listAppend(localSubList,sl); + sl = listAppend(sl,localSubList); c2 = Absyn.CREF(Absyn.CREF_IDENT(id,sl)); - then c2; + then c2; case (Absyn.CREF_QUAL(id,sl,c),localSubList) local Absyn.Ident id; @@ -10106,98 +10140,129 @@ algorithm Absyn.ComponentRef c; Absyn.Exp c2; equation - sl = listAppend(localSubList,sl); + sl = listAppend(sl,localSubList); c2 = Absyn.CREF(Absyn.CREF_QUAL(id,sl,c)); then c2; end matchcontinue; end createArrayReference; -public function extractLoopVars "function: extractLoopVars +protected function createTempLoopVars "function: createTempLoopVars author: KS - Function used for extracting the loop -variables from a list of identifiers and range expressions." + Function used for creating loop variables, used in the for iterator constructs." input Absyn.ForIterators rangeIdList; - input list accList; - output list outList; + input list accTempLoopVars1; + input list accTempLoopVars2; + input list accTempLoopInit; + input Integer count; + output list outList1; + output list outList2; + output list outList3; algorithm - outList := - matchcontinue (rangeIdList,accList) - local - list localAccList; - case ({},localAccList) then localAccList; - case ((id,_) :: restIdRange,localAccList) + (outList1,outList2,outList3) := + matchcontinue (rangeIdList,accTempLoopVars1,accTempLoopVars2,accTempLoopInit,count) + local + list localAccVars1; + list localAccVars2; + list localAccTempLoopInit; + case ({},localAccVars1,localAccVars2,localAccTempLoopInit,_) + then (localAccVars1,localAccVars2,localAccTempLoopInit); + case (_ :: restIdRange,localAccVars1,localAccVars2,localAccTempLoopInit,n) local Absyn.ForIterators restIdRange; - Absyn.Ident id; + Absyn.Ident id2; + Integer n; + list elem; + list elem2; equation - localAccList = listAppend(localAccList,{id}); - localAccList = extractLoopVars(restIdRange,localAccList); - then localAccList; + id2 = stringAppend("LOOPVAR__",intString(n)); + localAccVars1 = listAppend(localAccVars1,{id2}); + elem = {Absyn.ELEMENTITEM(Absyn.ELEMENT( + false,NONE(),Absyn.UNSPECIFIED(),"component", + Absyn.COMPONENTS(Absyn.ATTR(false,Absyn.VAR(),Absyn.BIDIR(),{}), + Absyn.TPATH(Absyn.IDENT("Integer"),NONE()), + {Absyn.COMPONENTITEM(Absyn.COMPONENT(id2,{},NONE()),NONE(),NONE())}), + Absyn.INFO("f",false,0,0,0,0),NONE()))}; + localAccVars2 = listAppend(localAccVars2,elem); + elem2 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(Absyn.CREF(Absyn.CREF_IDENT(id2,{})),Absyn.INTEGER(0)),NONE())}; + localAccTempLoopInit = listAppend(localAccTempLoopInit,elem2); + n = n+1; + (localAccVars1,localAccVars2,localAccTempLoopInit) = createTempLoopVars(restIdRange,localAccVars1,localAccVars2,localAccTempLoopInit,n); + then (localAccVars1,localAccVars2,localAccTempLoopInit); end matchcontinue; -end extractLoopVars; +end createTempLoopVars; -public function createForIteratorAlgorithm "function: createForIteratorAlgorithm +protected function createForIteratorAlgorithm "function: createForIteratorAlgorithm author: KS Function that creates for algorithm statements to be used in the for iterator constructor assignment." input Absyn.Exp iterExp; input Absyn.ForIterators rangeIdList; - input list idList; + input list idList; + input list tempLoopVars; input Absyn.ComponentRef arrayId; - output Absyn.Algorithm outAlg; + output list outAlg; algorithm outAlg := - matchcontinue (iterExp,rangeIdList,idList,arrayId) + matchcontinue (iterExp,rangeIdList,idList,tempLoopVars,arrayId) local - list stmt1; - Absyn.Algorithm stmt2; - Absyn.Ident id; + list stmt1,stmt2,stmt3; + Absyn.Ident id,tempLoopVar; Absyn.Exp rangeExp,localIterExp; - list localIdList; + list localIdList,restTempLoopVars; Absyn.ComponentRef localArrayId; - case (localIterExp,(id,SOME(rangeExp)) :: {},localIdList,localArrayId) + case (localIterExp,(id,SOME(rangeExp)) :: {},localIdList, + tempLoopVar :: _,localArrayId) local list subList; Absyn.Exp arrayRef; equation subList = createArrayIndexing(localIdList,{}); arrayRef = createArrayReference(localArrayId,subList); - stmt1 = Util.listCreate(Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(arrayRef,localIterExp),NONE())); - stmt2 = Absyn.ALG_FOR({(id,SOME(rangeExp))},stmt1); - then stmt2; - case (localIterExp,(id,SOME(rangeExp)) :: rest,localIdList,localArrayId) + stmt1 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})), + Absyn.BINARY(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})),Absyn.ADD(),Absyn.INTEGER(1))),NONE())}; + stmt2 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(arrayRef,localIterExp),NONE())}; + stmt1 = listAppend(stmt1,stmt2); + stmt2 = {Absyn.ALGORITHMITEM(Absyn.ALG_FOR({(id,SOME(rangeExp))},stmt1),NONE())}; + stmt1 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})), + Absyn.INTEGER(0)),NONE())}; + stmt3 = listAppend(stmt2,stmt1); + then stmt3; + case (localIterExp,(id,SOME(rangeExp)) :: rest,localIdList, + tempLoopVar :: restTempLoopVars,localArrayId) local Absyn.ForIterators rest; - Absyn.Algorithm temp; equation - temp = createForIteratorAlgorithm(localIterExp,rest,localIdList,localArrayId); - stmt1 = Util.listCreate(Absyn.ALGORITHMITEM(temp,NONE())); - stmt2 = Absyn.ALG_FOR({(id,SOME(rangeExp))},stmt1); - then stmt2; + stmt2 = createForIteratorAlgorithm(localIterExp,rest,localIdList,restTempLoopVars,localArrayId); + stmt1 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})), + Absyn.BINARY(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})),Absyn.ADD(),Absyn.INTEGER(1))),NONE())}; + stmt1 = listAppend(stmt1,stmt2); + stmt2 = {Absyn.ALGORITHMITEM(Absyn.ALG_FOR({(id,SOME(rangeExp))},stmt1),NONE())}; + stmt1 = {Absyn.ALGORITHMITEM(Absyn.ALG_ASSIGN(Absyn.CREF(Absyn.CREF_IDENT(tempLoopVar,{})), + Absyn.INTEGER(0)),NONE())}; + stmt3 = listAppend(stmt2,stmt1); + then stmt3; end matchcontinue; end createForIteratorAlgorithm; -public function createForIteratorArray "function: createForIteratorArray +protected function createForIteratorArray "function: createForIteratorArray author: KS Creates an array that will be used for storing temporary results in the for-iterator construct. " input Env.Cache cache; input Env.Env env; input Absyn.Exp iterExp; - input list idList; input Absyn.ForIterators rangeIdList; input Boolean b; output Env.Cache outCache; output list outDecls; algorithm - (outCache,outEnv,outDecls) := - matchcontinue (cache,env,iterExp,idList,rangeIdList,b) - case (localCache,localEnv,localIterExp,localIdList,localRangeIdList,impl) + (outCache,outDecls) := + matchcontinue (cache,env,iterExp,rangeIdList,b) + case (localCache,localEnv,localIterExp,localRangeIdList,impl) local Env.Env env2,localEnv; Env.Cache localCache,cache2; - list localIdList; Absyn.ForIterators localRangeIdList; list subscriptList; Types.Type t; @@ -10210,8 +10275,7 @@ algorithm Integer i; Absyn.Exp localIterExp; equation - ld = createTempIntegerVars(localIdList,{}); - (localCache,subscriptList) = deriveArrayDimensions(localCache,localEnv,localRangeIdList,impl,{}); + (localCache,subscriptList,ld) = deriveArrayDimAndTempVars(localCache,localEnv,localRangeIdList,impl,{},{}); // Temporarily add the loop variables to the environment so that we can later // elaborate the main for-iterator construct expression, in order to get the array type @@ -10230,18 +10294,18 @@ algorithm t2 = convertType(t); - decls = Util.listCreate(Absyn.ELEMENTITEM(Absyn.ELEMENT( + decls = {Absyn.ELEMENTITEM(Absyn.ELEMENT( false,NONE(),Absyn.UNSPECIFIED(),"component", Absyn.COMPONENTS(Absyn.ATTR(false,Absyn.VAR(),Absyn.BIDIR(),{}), Absyn.TPATH(t2,NONE()), {Absyn.COMPONENTITEM(Absyn.COMPONENT("VEC__",subscriptList,NONE()),NONE(),NONE())}), - Absyn.INFO("f",false,0,0,0,0),NONE()))); + Absyn.INFO("f",false,0,0,0,0),NONE()))}; then (localCache,decls); end matchcontinue; end createForIteratorArray; -public function convertType "function: convertType +protected function convertType "function: convertType author: KS " input Types.Type t; @@ -10257,77 +10321,65 @@ algorithm case ((Types.T_STRING(_),_)) then Absyn.IDENT("String"); case ((Types.T_BOOL(_),_)) then Absyn.IDENT("Boolean"); case ((Types.T_ENUM(),_)) then Absyn.IDENT("Enum"); - case ((Types.T_COMPLEX(ClassInf.MODEL(s),_,_),_)) then Absyn.IDENT(s); + /* case ((Types.T_COMPLEX(ClassInf.MODEL(s),_,_),_)) then Absyn.IDENT(s); case ((Types.T_COMPLEX(ClassInf.RECORD(s),_,_),_)) then Absyn.IDENT(s); case ((Types.T_COMPLEX(ClassInf.BLOCK(s),_,_),_)) then Absyn.IDENT(s); case ((Types.T_COMPLEX(ClassInf.CONNECTOR(s),_,_),_)) then Absyn.IDENT(s); - case ((Types.T_COMPLEX(ClassInf.EXTERNAL_OBJ(extObj),_,_),_)) then extObj; + case ((Types.T_COMPLEX(ClassInf.EXTERNAL_OBJ(extObj),_,_),_)) then extObj; */ end matchcontinue; end convertType; -public function createTempIntegerVars "function: createTempIntegerVars -author: KS -This function creates integer variables that will be used temporarily. " - input list idList; - input list accList; - output list decls; -algorithm - decls := - matchcontinue (idList,accList) - local - list localAccList; - case ({},localAccList) then localAccList; - case (id :: restList,localAccList) - local - list elem; - Absyn.Ident id; - list restList; - equation - elem = {Absyn.ELEMENTITEM(Absyn.ELEMENT( - false,NONE(),Absyn.UNSPECIFIED(),"component", - Absyn.COMPONENTS(Absyn.ATTR(false,Absyn.VAR(),Absyn.BIDIR(),{}), - Absyn.TPATH(Absyn.IDENT("Integer"),NONE()), - {Absyn.COMPONENTITEM(Absyn.COMPONENT(id,{},NONE()),NONE(),NONE())}), - Absyn.INFO("f",false,0,0,0,0),NONE()))}; - localAccList = listAppend(localAccList,elem); - localAccList = createTempIntegerVars(restList,localAccList); - then localAccList; - end matchcontinue; -end createTempIntegerVars; - -public function deriveArrayDimensions "function: deriveArrayDimensions. -Given a list of range-expressions (tagged with loop variable identifiers), -we derive the dimension of each range. KS" +protected function deriveArrayDimAndTempVars "function: deriveArrayDimAndTempVars. + author: KS + Given a list of range-expressions (tagged with loop variable identifiers), + we derive the dimension of each range. " input Env.Cache cache; input Env.Env env; input Absyn.ForIterators rangeList; input Boolean impl; - input list accList; + input list accList; + input list accTempVars; output Env.Cache cache; - output list outList; + output list outList1; + output list outList2; algorithm - outList := - matchcontinue (cache,env,rangeList,impl,accList) + (cache,outList1,outList2) := + matchcontinue (cache,env,rangeList,impl,accList,accTempVars) local list localAccList; + list localAccTempVars; Env.Env localEnv; Env.Cache localCache; - case (localCache,_,{},_,localAccList) then (localCache,localAccList); - case (localCache,localEnv,(_,SOME(e)) :: restList,localImpl,localAccList) + case (localCache,_,{},_,localAccList,localAccTempVars) then (localCache,localAccList,localAccTempVars); + case (localCache,localEnv,(id,SOME(e)) :: restList,localImpl,localAccList,localAccTempVars) local Absyn.Exp e; Absyn.ForIterators restList; Boolean localImpl; - list elem; - Integer i; + list elem; + list elem2; + Integer i; + Absyn.Ident id; + Types.Type t; + Absyn.Path t2; equation - (localCache,_,Types.PROP((Types.T_ARRAY(Types.DIM(SOME(i)),_),NONE()),_),_) = Static.elabExp(localCache,localEnv,e,localImpl,NONE(),false); + (localCache,_,Types.PROP((Types.T_ARRAY(Types.DIM(SOME(i)),t),NONE()),_),_) = Static.elabExp(localCache,localEnv,e,localImpl,NONE(),false); elem = {Absyn.SUBSCRIPT(Absyn.INTEGER(i))}; - localAccList = listAppend(localAccList,elem); - (localCache,localAccList) = deriveArrayDimensions(localCache,localEnv,restList,localImpl,localAccList); - then (localCache,localAccList); + localAccList = listAppend(localAccList,elem); + t2 = convertType(t); + elem2 = {Absyn.ELEMENTITEM(Absyn.ELEMENT( + false,NONE(),Absyn.UNSPECIFIED(),"component", + Absyn.COMPONENTS(Absyn.ATTR(false,Absyn.VAR(),Absyn.BIDIR(),{}), + Absyn.TPATH(t2,NONE()), + {Absyn.COMPONENTITEM(Absyn.COMPONENT(id,{},NONE()),NONE(),NONE())}), + Absyn.INFO("f",false,0,0,0,0),NONE()))}; + localAccTempVars = listAppend(localAccTempVars,elem2); + (localCache,localAccList,localAccTempVars) = + deriveArrayDimAndTempVars(localCache,localEnv,restList,localImpl,localAccList,localAccTempVars); + then (localCache,localAccList,localAccTempVars); end matchcontinue; -end deriveArrayDimensions; +end deriveArrayDimAndTempVars; + /* ------------------------------------------------------ */ end Inst; diff --git a/Compiler/Static.mo b/Compiler/Static.mo index 82a8038c8f4..395ed2ef79f 100644 --- a/Compiler/Static.mo +++ b/Compiler/Static.mo @@ -435,24 +435,26 @@ algorithm (cache,e_1,prop_1,st_1); /* Array For iterator expression */ - case (cache,env,Absyn.CALL(function_ = Absyn.CREF_IDENT("array",{}),functionArgs = Absyn.FOR_ITER_FARG(e1,rangeList)),impl,st,doVect) + /*case (cache,env,Absyn.CALL(function_ = Absyn.CREF_IDENT("array",{}),functionArgs = Absyn.FOR_ITER_FARG(e1,rangeList)),impl,st,doVect) local Exp.Exp e; list idList; Absyn.Exp e1,vb; Absyn.ForIterators rangeList; Absyn.Algorithm absynStmt,temp; - list idList; + list tempLoopVarNames; Absyn.ComponentRef c1,c2; - list declList; + list declList,tempLoopVars; list vb_body; equation - idList = Inst.extractLoopVars(rangeList,{}); + (tempLoopVarNames,tempLoopVars) = Inst.createTempLoopVars(rangeList,{},{},1); // Create temporary array to store the result from the for-iterator construct - (cache,declList) = Inst.createForIteratorArray(cache,env,e1,idList,rangeList,impl); + (cache,declList) = Inst.createForIteratorArray(cache,env,e1,rangeList,impl); + + declList = listAppend(declList,tempLoopVars); // Create for-statements - temp = Inst.createForIteratorAlgorithm(e1,rangeList,idList,Absyn.CREF_IDENT("VEC__",{})); + temp = Inst.createForIteratorAlgorithm(e1,rangeList,tempLoopVarNames,tempLoopVarNames,Absyn.CREF_IDENT("VEC__",{})); vb_body = Util.listCreate(Absyn.ALGORITHMITEM(temp,NONE())); vb = Absyn.VALUEBLOCK(declList,Absyn.VALUEBLOCKALGORITHMS(vb_body), @@ -460,7 +462,7 @@ algorithm (cache,e_1,prop_1,st_1) = elabExp(cache,env,vb,impl,st,doVect); then - (cache,e_1,prop_1,st_1); + (cache,e_1,prop_1,st_1); */ case (cache,env,Absyn.TUPLE(expressions = (e as (e1 :: rest))),impl,st,doVect) /* PR. Get the properties for each expression in the tuple. Each expression has its own constflag.