Changeset bf001f11 in OpenModelica

Timestamp:

2012-11-20T14:00:36+01:00 (11 years ago)

Author:

Per Östlund <per.ostlund@…>

Branches:

Added-citation-metadata, maintenance/v1.14, maintenance/v1.15, maintenance/v1.16, maintenance/v1.17, maintenance/v1.18, maintenance/v1.19, maintenance/v1.20, maintenance/v1.21, maintenance/v1.22, maintenance/v1.23, master, omlib-staging

Children:

3dda9d88

Parents:

14915b6

Message:

• Don't return the class from InstSymbolTable.addClass, it's no longer needed since classes are flattened in SCodeInst.instClassItem.

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

Location:

Compiler/FrontEnd

Files:

• InstSymbolTable.mo (modified) (10 diffs)
• SCodeInst.mo (modified) (5 diffs)

Compiler/FrontEnd/InstSymbolTable.mo

@@ -157 +157 @@
    symboltable."
   input Class inClass;
-  output Class outClass;
-  output SymbolTable outSymbolTable;
-algorithm
-  (outClass, outSymbolTable) := match(inClass)
+  output SymbolTable outSymbolTable;
+algorithm
+  outSymbolTable := match(inClass)
     local
       SymbolTable st;
@@ -173 +172 @@
         bucket_size = Util.nextPrime(intDiv((comp_size * 4), 3)) + 1;
         st = createSized(bucket_size);
-        (cls, st) = addClass(inClass, st);
+        st = addClass(inClass, st);
         st = addAliases(inClass, st);
         // Add the special variable time to the symboltable.
         st = addUniqueComponent(Absyn.IDENT("time"), BUILTIN_TIME_COMP, st);
       then
-        (cls, st);
+        st;
 
   end match;
@@ -251 +250 @@
 
 public function addClass
-  "Adds the elements of a given class to the symboltable."
+  "Adds the components of a given class to the symboltable."
   input Class inClass;
   input SymbolTable inSymbolTable;
-  output Class outClass;
-  output SymbolTable outSymbolTable;
-algorithm
-  (outClass, outSymbolTable) := match(inClass, inSymbolTable)
+  output SymbolTable outSymbolTable;
+algorithm
+  outSymbolTable := match(inClass, inSymbolTable)
     local
       list<Element> comps;
@@ -265 +263 @@
       Absyn.Path name;
 
-    // A basic type doesn't have any elements, nothing to add.
+    // A basic type doesn't have any components, nothing to add.
     case (InstTypes.BASIC_TYPE(name), st) then (inClass, st);
 
-    // A complex class, add it's elements to the symboltable.
-    case (InstTypes.COMPLEX_CLASS(name, comps, eq, ieq, al, ial), st)
-      equation
-        (comps, st) = addElements(comps, st);
-      then
-        (InstTypes.COMPLEX_CLASS(name, comps, eq, ieq, al, ial), st);
+    // A complex class, add its components to the symboltable.
+    case (InstTypes.COMPLEX_CLASS(components = comps), st)
+      then addElements(comps, st);
 
   end match;
@@ -284 +279 @@
   input list<Element> inElements;
   input SymbolTable inSymbolTable;
-  output list<Element> outElements;
-  output SymbolTable outSymbolTable;
-algorithm
-  (outElements, outSymbolTable) :=
-    addElements2(inElements, inSymbolTable, {});
+  output SymbolTable outSymbolTable;
+algorithm
+  outSymbolTable := List.fold(inElements, addElement, inSymbolTable);
 end addElements;
-
-protected function addElements2
-  "Tail-recursive implementation of addElements."
-  input list<Element> inElements;
-  input SymbolTable inSymbolTable;
-  input list<Element> inAccumEl;
-  output list<Element> outElements;
-  output SymbolTable outSymbolTable;
-algorithm
-  (outElements, outSymbolTable) := match(inElements, inSymbolTable, inAccumEl)
-    local
-      Element el;
-      list<Element> rest_el, accum_el;
-      Boolean added;
-      SymbolTable st;
-
-    case ({}, st, _) then (inAccumEl, st);
-
-    case (el :: rest_el, st, _)
-      equation
-        // Try to add the element to the symboltable.
-        (el, st) = addElement(el, st);
-        // Add the element to the accumulation list if it was added.
-        accum_el = el :: inAccumEl;
-        // Add the rest of the elements.
-        (rest_el, st) = addElements2(rest_el, st, accum_el);
-      then
-        (rest_el, st);
-
-  end match;
-end addElements2;
 
 public function addElement
@@ -328 +290 @@
   input Element inElement;
   input SymbolTable inSymbolTable;
-  output Element outElement;
-  output SymbolTable outSymbolTable;
-algorithm
-  (outElement, outSymbolTable) := match(inElement, inSymbolTable)
+  output SymbolTable outSymbolTable;
+algorithm
+  outSymbolTable := match(inElement, inSymbolTable)
     local
       Component comp;
       Class cls;
       SymbolTable st;
-      Absyn.Path bc;
-      DAE.Type ty;
 
     case (InstTypes.ELEMENT(comp, cls), st)
@@ -344 +303 @@
         st = addComponent(comp, st);
         // Add the component's class.
-        (cls, st) = addClass(cls, st);
-      then
-        (InstTypes.ELEMENT(comp, cls), st);
+        st = addClass(cls, st);
+      then
+        st;
 
     case (InstTypes.CONDITIONAL_ELEMENT(comp), st)
-      equation
-        st = addComponent(comp, st);
-      then
-        (InstTypes.CONDITIONAL_ELEMENT(comp), st);
+      then addComponent(comp, st);
 
   end match;
@@ -616 +572 @@
   input Element inElement;
   input SymbolTable inSymbolTable;
-  output Element outElement;
   output SymbolTable outSymbolTable;
   output Boolean outAdded;
 algorithm
-  (outElement, outSymbolTable, outAdded) := match(inElement, inSymbolTable)
+  (outSymbolTable, outAdded) := match(inElement, inSymbolTable)
     local
       Component comp;
@@ -639 +594 @@
         (cls, st) = addClassOnTrue(cls, st, added);
       then
-        (InstTypes.ELEMENT(comp, cls), st, added);
+        (st, added);
 
   end match;
@@ -674 +629 @@
     // element from an extends. In that case we should make sure that the new
     // component is equivalent to the old one, and return the symboltable
-    // unchagned.
+    // unchanged.
     case (_, _, SOME(comp), st)
       equation
+        /*********************************************************************/
+        // TODO: Check if this is still needed, since we check duplicate
+        // elements in SCodeInst.instClassItem now.
+        /*********************************************************************/
         //checkEqualComponents
       then

Compiler/FrontEnd/SCodeInst.mo

@@ -134 +134 @@
         name = Absyn.pathLastIdent(inClassPath);
 
-        // ---------------- Instantiation ---------------
+        /*********************************************************************/
+        /* ------------------------- INSTANTIATION ------------------------- */
+        /*********************************************************************/
+
         // Look up the class to instantiate in the environment.
         (item, path, env) = 
           SCodeLookup.lookupClassName(inClassPath, inEnv, Absyn.dummyInfo);
+
         // Instantiate that class.
         functions = HashTablePathToFunction.emptyHashTableSized(BaseHashTable.lowBucketSize);
@@ -149 +153 @@
         //print(InstDump.modelStr(name, cls)); print("\n");
 
-        // ------------------- Typing -------------------
+        /*********************************************************************/
+        /* ----------------------------- TYPING ---------------------------- */
+        /*********************************************************************/
+
         // Build the symboltable to use for typing.
-        (cls, symtab) = InstSymbolTable.build(cls);
+        symtab = InstSymbolTable.build(cls);
+        // Add the package constants found during instantiation.
         symtab = InstSymbolTable.merge(symtab, constants);
-        (_, symtab) = InstSymbolTable.addClass(builtin_el, symtab);
+        // Add any builtin elements we might need, like StateSelect.
+        symtab = InstSymbolTable.addClass(builtin_el, symtab);
 
         // Mark structural parameters.
@@ -180 +189 @@
         (cls, conn) = Typing.typeSections(cls, symtab);
         
+        // Generate connect equations.
         flows = ConnectUtil2.collectFlowConnectors(cls);
         dae_conn = ConnectEquations.generateEquations(conn, flows);
@@ -192 +202 @@
 
         //print("SCodeInst took " +& realString(System.getTimerIntervalTime()) +& " seconds.\n");
+
+        /*********************************************************************/
+        /* --------------------------- EXPANSION --------------------------- */
+        /*********************************************************************/
 
         // Expand the instantiated and typed class into scalar components,
@@ -3843 +3857 @@
         // Instantiate the element and update the symbol table.
         (el, globals) = instElement(sel, inMod, inPrefixes, inEnv, inPrefix, INST_ALL(), globals);
-        (el, st, added) = InstSymbolTable.addInstCondElement(el, st);
+        (st, added) = InstSymbolTable.addInstCondElement(el, st);
         // Recursively instantiate any conditional components in this element.
         (oel, st, globals) = instConditionalElementOnTrue(added, el, st, globals);