Handle bootstrapping DoubleEndedList.mo

Author: sjoelund

Compiler/Script/CevalScript.mo

@@ -2123,7 +2123,7 @@ algorithm
   path := Absyn.joinPaths(pathPrefix, Absyn.IDENT(name));
   paths := if SCode.isFunction(elt) then path::acc else acc;
   pathsMetarecord := match elt
-    case SCode.CLASS(restriction=SCode.R_METARECORD(moved = true)) then path::accMetarecord;
+    case SCode.CLASS(restriction=SCode.R_METARECORD()) then path::accMetarecord;
     else accMetarecord;
   end match;
   elements := getNonPartialElementsForInstantiatedClass(sp, elt, path);

Compiler/SimCode/SimCodeUtil.mo

@@ -79,6 +79,7 @@ import DAEDump;
 import DAEUtil;
 import Debug;
 import Differentiate;
+import DoubleEndedList;
 import Error;
 import EvaluateFunctions;
 import Expression;
@@ -11029,41 +11030,6 @@ algorithm
   b := listMember(bEq,bEq1);
 end findBEqs;
 
-/*
-This is wrong!
-public function getSimVarByIndex
-  input Integer idx;
-  input SimCodeVar.SimVars allSimVars;
-  output SimCodeVar.SimVar simVar;
-algorithm
-  simVar := matchcontinue(idx,allSimVars)
-    local
-      Integer size,idx2;
-      list<SimCodeVar.SimVar> stateVars,algVars;
-      SimCodeVar.SimVar var;
-  case(_,SimCodeVar.SIMVARS(stateVars=stateVars,algVars=algVars))
-    equation
-      size = listLength(stateVars);
-      true = idx > size;
-      //its not a stateVar
-      idx2 = idx - 2*size + 1;
-      var = listGet(algVars,idx2);
-      then var;
-  case(_,SimCodeVar.SIMVARS(stateVars=stateVars,algVars=algVars))
-    equation
-      size = listLength(stateVars);
-      true = idx <= size;
-      //its a stateVar
-      var = listGet(stateVars,idx);
-      then var;
-  else
-    equation
-      print("SimCodeUtil.getSimVarByIndex failed!\n");
-    then fail();
-  end matchcontinue;
-end getSimVarByIndex;
-*/
-
 public function getAssignedCrefsOfSimEq"gets the crefs of the vars that are assigned (the lhs) of the simEqSystems
 author:Waurich TUD 2014-05"
   input Integer idx;
@@ -11079,7 +11045,7 @@ algorithm
       equation
         simEqSyst = List.getMemberOnTrue(idx,allEqs,indexIsEqual);
         crefs = getSimEqSystemCrefsLHS(simEqSyst);
-    then crefs;
+      then crefs;
   end match;
 end getAssignedCrefsOfSimEq;
 
@@ -11098,17 +11064,15 @@ algorithm
     case(SimCode.SES_RESIDUAL())
       equation
         print("implement SES_RESIDUAL in SimCodeUtil.getSimEqSystemCrefsLHS!\n");
-    then {};
+      then {};
     case(SimCode.SES_SIMPLE_ASSIGN(cref=cref))
-      equation
-    then {cref};
+      then {cref};
     case(SimCode.SES_ARRAY_CALL_ASSIGN(lhs=lhs))
-      equation
-    then {Expression.expCref(lhs)};
+      then {Expression.expCref(lhs)};
     case(SimCode.SES_IFEQUATION())
       equation
         print("implement SES_IFEQUATION in SimCodeUtil.getSimEqSystemCrefsLHS!\n");
-    then {};
+      then {};
     case(SimCode.SES_ALGORITHM()) equation
       print("implement SES_ALGORITHM in SimCodeUtil.getSimEqSystemCrefsLHS!\n");
     then {};
@@ -11117,20 +11081,15 @@ algorithm
     then {};
     case(SimCode.SES_LINEAR(SimCode.LINEARSYSTEM(vars=simVars,residual=residual)))
       equation
-        crefs2 = List.flatten(List.map(residual,getSimEqSystemCrefsLHS));
-        crefs = list(SimCodeFunctionUtil.varName(v) for v in simVars);
-        crefs = listAppend(crefs,crefs2);
-    then crefs;
+        crefs = List.flatten(List.map(residual,getSimEqSystemCrefsLHS));
+        crefs2 = list(SimCodeFunctionUtil.varName(v) for v in simVars);
+      then listAppend(crefs2,crefs2);
     case(SimCode.SES_NONLINEAR(SimCode.NONLINEARSYSTEM(crefs=crefs)))
-      equation
-    then crefs;
-    case(SimCode.SES_MIXED(discVars=simVars))
-      equation
-        crefs = list(SimCodeFunctionUtil.varName(v) for v in simVars);
       then crefs;
+    case(SimCode.SES_MIXED(discVars=simVars))
+      then list(SimCodeFunctionUtil.varName(v) for v in simVars);
     case(SimCode.SES_WHEN(whenStmtLst={BackendDAE.ASSIGN(left=cref)}))
-      equation
-    then {cref};
+      then {cref};
   end match;
 end getSimEqSystemCrefsLHS;
 
@@ -11600,10 +11559,11 @@ protected
    list<tuple<DAE.ComponentRef, list<DAE.ComponentRef>>> spTA, spTB;
    list<tuple<Integer, list<Integer>>> sparseInts;
    list<SimCode.FmiUnknown> derivatives, outputs, discreteStates;
-   list<SimCodeVar.SimVar> varsA, varsB, clockedStates;
+   list<SimCodeVar.SimVar> varsA, varsB, varsC, clockedStates;
    SimCode.HashTableCrefToSimVar crefSimVarHT;
    list<DAE.ComponentRef> diffCrefsA, diffedCrefsA, derdiffCrefsA;
    list<DAE.ComponentRef> diffCrefsB, diffedCrefsB;
+   DoubleEndedList<SimCodeVar.SimVar> delst;
 algorithm
   try
     //print("Start creating createFMIModelStructure\n");
@@ -11643,13 +11603,12 @@ algorithm
     spTA  := mergeSparsePatter(spTA, spTB, {});
     //print("-- merged matrixes CD\n");
 
-    varsB := getSimVars2Crefs(diffedCrefsB, crefSimVarHT);
-    varsA := getSimVars2Crefs(diffCrefsB, crefSimVarHT);
-    varsA := listAppend(varsA, varsB);
-    varsB := getSimVars2Crefs(diffedCrefsA, crefSimVarHT);
-    varsA := listAppend(varsA, varsB);
-    varsB := getSimVars2Crefs(diffCrefsA, crefSimVarHT);
-    varsA := listAppend(varsA, varsB);
+    delst := DoubleEndedList.fromList(getSimVars2Crefs(diffedCrefsB, crefSimVarHT));
+    DoubleEndedList.push_list_back(delst, getSimVars2Crefs(diffCrefsB, crefSimVarHT));
+    DoubleEndedList.push_list_back(delst, getSimVars2Crefs(diffedCrefsA, crefSimVarHT));
+    DoubleEndedList.push_list_back(delst, getSimVars2Crefs(diffCrefsA, crefSimVarHT));
+    varsA := DoubleEndedList.toListAndClear(delst);
+
     //print("-- created vars for CD\n");
 
     sparseInts := sortSparsePattern(varsA, spTA, true);

Compiler/Template/SCodeDumpTpl.tpl

@@ -131,21 +131,21 @@ match class
     let cmt_str = dumpClassComment(cmt, options)
     let ann_str = dumpClassAnnotation(cmt, options)
     let cc_str = dumpReplaceableConstrainClass(prefixes, options)
-    let header_str = dumpClassHeader(classDef, name, cmt_str, options)
+    let header_str = dumpClassHeader(classDef, name, restriction, cmt_str, options)
     let footer_str = dumpClassFooter(classDef, cdef_str, name, cmt_str, ann_str, cc_str)
     <<
     <%prefixes_str%> <%header_str%> <%footer_str%>
     >>
 end dumpClass;
 
-template dumpClassHeader(SCode.ClassDef classDef, String name, String cmt, SCodeDumpOptions options)
+template dumpClassHeader(SCode.ClassDef classDef, String name, SCode.Restriction restr, String cmt, SCodeDumpOptions options)
 ::=
 match classDef
   case CLASS_EXTENDS(__)
     then
     let mod_str = dumpModifier(modifications, options)
     'extends <%name%><%mod_str%> <%cmt%>'
-  case PARTS(__) then '<%name%> <%cmt%>'
+  case PARTS(__) then '<%name%><%dumpRestrictionTypeVars(restr)%> <%cmt%>'
   else '<%name%>'
 end dumpClassHeader;
 
@@ -678,6 +678,14 @@ match restriction
   else errorMsg("SCodeDump.dumpRestriction: Unknown restriction.")
 end dumpRestriction;
 
+template dumpRestrictionTypeVars(SCode.Restriction restriction)
+::=
+match restriction
+  case R_UNIONTYPE(__) then
+    (if typeVars then ("<" + (typeVars |> tv => tv ; separator=";") + ">"))
+  else ""
+end dumpRestrictionTypeVars;
+
 template dumpFunctionRestriction(SCode.FunctionRestriction funcRest)
 ::=
 match funcRest

Compiler/Template/SCodeTV.mo

@@ -356,9 +356,11 @@ package SCode
     record R_METARECORD
       Absyn.Path name;
       Integer index;
+      list<String> typeVars;
     end R_METARECORD;
 
     record R_UNIONTYPE
+      list<String> typeVars;
     end R_UNIONTYPE;
   end Restriction;
 

Compiler/Util/DoubleEndedList.mo

@@ -51,6 +51,31 @@ algorithm
   delst := LIST(arrayCreate(1,1),arrayCreate(1,lst),arrayCreate(1,lst));
 end new;
 
+impure function fromList
+  input list<T> lst;
+  output DoubleEndedList<T> delst;
+protected
+  list<T> head,tail,tmp;
+  Integer length=0;
+  T t;
+algorithm
+  if listEmpty(lst) then
+    delst := LIST(arrayCreate(1,0),arrayCreate(1,{}),arrayCreate(1,{}));
+    return;
+  end if;
+  t::tmp := lst;
+  head := {t};
+  tail := head;
+  length := 1;
+  for l in tmp loop
+    tmp := {l};
+    Dangerous.listSetRest(tail, tmp);
+    tail := tmp;
+    length := length+1;
+  end for;
+  delst := LIST(arrayCreate(1,length),arrayCreate(1,head),arrayCreate(1,tail));
+end fromList;
+
 impure function empty
   input T dummy;
   output DoubleEndedList<T> delst;
@@ -94,6 +119,37 @@ algorithm
   arrayUpdate(delst.front, 1, elt::lst);
 end push_front;
 
+function push_list_front
+  input DoubleEndedList<T> delst;
+  input list<T> lst;
+protected
+  Integer length=arrayGet(delst.length,1), lstLength;
+  list<T> work, tail={}, tmp;
+  T t;
+algorithm
+  lstLength := listLength(lst);
+  if lstLength==0 then
+    return;
+  end if;
+  arrayUpdate(delst.length, 1, length+lstLength);
+  t::tmp := lst;
+  work := {t};
+  tail := work;
+  for l in tmp loop
+    tmp := {l};
+    Dangerous.listSetRest(tail, tmp);
+    tail := tmp;
+  end for;
+  if length==0 then
+    arrayUpdate(delst.front, 1, work);
+    arrayUpdate(delst.back, 1, work);
+    return;
+  end if;
+  tmp := arrayGet(delst.front,1);
+  Dangerous.listSetRest(tail, tmp);
+  arrayUpdate(delst.front, 1, work);
+end push_list_front;
+
 function push_back<T>
   input DoubleEndedList<T> delst;
   input T elt;
@@ -113,6 +169,37 @@ algorithm
   arrayUpdate(delst.back, 1, lst);
 end push_back;
 
+function push_list_back
+  input DoubleEndedList<T> delst;
+  input list<T> lst;
+protected
+  Integer length=arrayGet(delst.length,1), lstLength;
+  list<T> work, tail={}, tmp;
+  T t;
+algorithm
+  lstLength := listLength(lst);
+  if lstLength==0 then
+    return;
+  end if;
+  arrayUpdate(delst.length, 1, length+lstLength);
+  t::tmp := lst;
+  work := {t};
+  tail := work;
+  for l in tmp loop
+    tmp := {l};
+    Dangerous.listSetRest(tail, tmp);
+    tail := tmp;
+  end for;
+  if length==0 then
+    arrayUpdate(delst.front, 1, work);
+    arrayUpdate(delst.back, 1, work);
+    return;
+  end if;
+  tmp := arrayGet(delst.back,1);
+  Dangerous.listSetRest(tmp, tail);
+  arrayUpdate(delst.back, 1, tail);
+end push_list_back;
+
 function toListAndClear
   input DoubleEndedList<T> delst;
   output list<T> res;

Compiler/Util/List.mo

@@ -603,6 +603,21 @@ algorithm
   end match;
 end last;
 
+public function lastElement<T>
+  "Returns the last cons-cell of a list. Fails if the list is empty. Also returns the list length."
+  input list<T> inList;
+  output list<T> lst;
+  output Integer listLength=0;
+protected
+  list<T> rest=inList;
+algorithm
+  false := listEmpty(rest);
+  while not listEmpty(rest) loop
+    (lst as (_::rest)) := rest;
+    listLength := listLength+1;
+  end while;
+end lastElement;
+
 public function lastListOrEmpty<T>
   "Returns the last element(list) of a list of lists. Returns empty list
   if the outer list is empty."

Compiler/boot/LoadCompilerSources.mos

@@ -321,7 +321,7 @@ if true then /* Suppress output */
     "../Util/BaseAvlTree.mo",
     "../Util/AvlTreeString2.mo",
 
-    // "../Util/DoubleEndedList.mo",
+    "../Util/DoubleEndedList.mo",
     "../Util/DiffAlgorithm.mo",
     "../Util/FMI.mo",
     "../Util/FMIExt.mo",