- Changed SCodeFlatten.flatten so it uses the correct variables.

- Changed SCodeEnv.printEnvStr so it prints the whole environment instead of
  only the last frame.
- Implemented support for derived classes in SCodeFlattenImports.


git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@7786 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Compiler/FrontEnd/SCodeEnv.mo

@@ -1248,14 +1248,14 @@ algorithm
   tree := AVLTREENODE(NONE(),0,NONE(),NONE());
 end avlTreeNew;
 
-protected function printEnvStr
+public function printEnvStr
   input Env inEnv;
   output String outString;
 protected
-  Frame f;
+  Env env;
 algorithm
-  f :: _ := inEnv;
-  outString := printFrameStr(f);
+  env := listReverse(inEnv);
+  outString := Util.stringDelimitList(Util.listMap(env, printFrameStr), "\n");
 end printEnvStr;
 
 protected function printFrameStr
@@ -1317,6 +1317,7 @@ algorithm
       String left_str, right_str, value_str;
 
     case (NONE()) then "";
+    case (SOME(AVLTREENODE(value = NONE()))) then "";
     case (SOME(AVLTREENODE(value = SOME(value), left = left, right = right)))
       equation
         left_str = printAvlTreeStr(left);
@@ -1325,6 +1326,7 @@ algorithm
         value_str = value_str +& left_str +& right_str;
       then
         value_str;
+
   end match;
 end printAvlTreeStr;
 

Compiler/FrontEnd/SCodeFlatten.mo

@@ -62,8 +62,8 @@ algorithm
   env := SCodeEnv.insertClassExtendsIntoEnv(env);
 
   outProgram := SCodeFlattenImports.flattenProgram(inProgram, env);
-  outProgram := SCodeFlattenExtends.flattenProgram(inProgram, env);
-  outProgram := SCodeFlattenRedeclare.flattenProgram(inProgram, env);
+  outProgram := SCodeFlattenExtends.flattenProgram(outProgram, env);
+  outProgram := SCodeFlattenRedeclare.flattenProgram(outProgram, env);
   //System.stopTimer();
   //print("flatten took " +& realString(System.getTimerIntervalTime()) +& 
   //  " seconds\n");

Compiler/FrontEnd/SCodeFlattenImports.mo

@@ -84,16 +84,17 @@ protected
 algorithm
   SCode.CLASS(name, part_pre, encap_pre, restriction, cdef, info) := inClass;
   env := SCodeEnv.enterScope(inEnv, name);
-  cdef := flattenClassDefs(cdef, env);
+  cdef := flattenClassDefs(cdef, env, info);
   outClass := SCode.CLASS(name, part_pre, encap_pre, restriction, cdef, info);
 end flattenClasses;
 
 protected function flattenClassDefs
   input SCode.ClassDef inClassDef;
   input Env inEnv;
+  input Absyn.Info inInfo;
   output SCode.ClassDef outClassDef;
 algorithm
-  outClassDef := match(inClassDef, inEnv)
+  outClassDef := match(inClassDef, inEnv, inInfo)
     local
       list<SCode.Element> el, ex, cl, im, co, ud;
       list<SCode.Equation> neql, ieql;
@@ -102,27 +103,38 @@ algorithm
       list<SCode.Annotation> annl;
       Option<SCode.Comment> cmt;
       SCode.ClassDef cdef;
+      Absyn.TypeSpec ty;
+      SCode.Mod mods;
+      Absyn.ElementAttributes attr;
       Env env;
 
-    case (SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt), env)
+    case (SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt), _, _)
       equation
         // Lookup elements.
-        el = Util.listMap1(el, flattenElement, env);
+        el = Util.listMap1(el, flattenElement, inEnv);
         el = Util.listFilter(el, isNotImport);
 
         // Lookup equations and algorithm names.
-        neql = Util.listMap1(neql, flattenEquation, env);
-        ieql = Util.listMap1(ieql, flattenEquation, env);
-        nal = Util.listMap1(nal, flattenAlgorithm, env);
-        ial = Util.listMap1(ial, flattenAlgorithm, env);
+        neql = Util.listMap1(neql, flattenEquation, inEnv);
+        ieql = Util.listMap1(ieql, flattenEquation, inEnv);
+        nal = Util.listMap1(nal, flattenAlgorithm, inEnv);
+        ial = Util.listMap1(ial, flattenAlgorithm, inEnv);
         cdef = SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt);
       then
         cdef;
 
+    case (SCode.DERIVED(ty, mods, attr, cmt), _, _)
+      equation
+        env = SCodeEnv.removeExtendsFromLocalScope(inEnv);
+        (_, ty, _) = SCodeLookup.lookupTypeSpec(ty, env, inInfo);
+        mods = flattenModifier(mods, inEnv, inInfo);
+      then
+        SCode.DERIVED(ty, mods, attr, cmt);
+
     //case (SCode.CLASS_EXTENDS
     //case (SCode.DERIVED
 
-    case (SCode.ENUMERATION(enumLst = _), _) then inClassDef;
+    case (SCode.ENUMERATION(enumLst = _), _, _) then inClassDef;
 
     //case (SCode.OVERLOAD
     //case (SCode.PDER
@@ -222,7 +234,7 @@ algorithm
     // Make sure that the checkpoint is deleted properly.
     else
       equation
-        ErrorExt.delCheckpoint("lookupComponent");
+        ErrorExt.delCheckpoint("flattenComponent");
       then
         fail();
 

Compiler/FrontEnd/SCodeUtil.mo

@@ -98,14 +98,14 @@ algorithm
         // set the external flag that signals the presence of expandable connectors in the model
         System.setHasStreamConnectors(false);
         sp = Util.listFold(initialClasses, translate2, {});
+        //sp = {};
         sp = Util.listFold(inClasses, translate2, sp);
         names = Util.listMap(sp, SCode.className);
         names = Util.sort(names,Util.strcmpBool);
         (_,names) = Util.splitUniqueOnBool(names,stringEqual);
         checkForDuplicateClassesInTopScope(names);
         sp = listReverse(sp);
 
-        //sp = SCodeFlatten.flatten(sp);
         //print(Util.stringDelimitList(Util.listMap(sp, SCode.printClassStr), "\n"));
         // retrieve the expandable connector presence external flag
         hasExpandableConnectors = System.getHasExpandableConnectors();