Skip to content

Commit

Permalink
- Changed SCodeFlattenImports to also update and return the environment.
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@8713 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
@perost
perost committed Apr 20, 2011
1 parent c8fbbfd commit b467744
Show file tree
Hide file tree
Showing 5 changed files with 124 additions and 66 deletions.
26 changes: 18 additions & 8 deletions Compiler/FrontEnd/SCode.mo
View file
Expand Up @@ -3749,17 +3749,11 @@ public function addElementToClass
input Element inClassDef;
output Element outClassDef;
protected
Ident n;
Prefixes pf;
Encapsulated ep;
Partial pp;
Restriction r;
ClassDef cdef;
Absyn.Info i;
algorithm
CLASS(n, pf, ep, pp, r, cdef, i) := inClassDef;
CLASS(classDef = cdef) := inClassDef;
cdef := addElementToCompositeClassDef(inElement, cdef);
outClassDef := CLASS(n, pf, ep, pp, r, cdef, i);
outClassDef := setElementClassDefinition(cdef, inClassDef);
end addElementToClass;

public function addElementToCompositeClassDef
Expand All @@ -3779,6 +3773,22 @@ algorithm
outClassDef := PARTS(inElement :: el, nel, iel, nal, ial, ed, annl, c);
end addElementToCompositeClassDef;

public function setElementClassDefinition
input ClassDef inClassDef;
input Element inElement;
output Element outElement;
protected
Ident n;
Prefixes pf;
Partial pp;
Encapsulated ep;
Restriction r;
Absyn.Info i;
algorithm
CLASS(n, pf, ep, pp, r, _, i) := inElement;
outElement := CLASS(n, pf, ep, pp, r, inClassDef, i);
end setElementClassDefinition;

public function flowStr
input Flow inFlow;
output String str;
Expand Down
31 changes: 31 additions & 0 deletions Compiler/FrontEnd/SCodeEnv.mo
View file
Expand Up @@ -490,6 +490,37 @@ algorithm
outEnv := FRAME(name, ty, tree, exts, imps, is_used) :: rest;
end extendEnvWithItem;

public function updateItemInEnv
"Updates an item in the environment by replacing an existing item."
input Item inItem;
input Env inEnv;
input String inItemName;
output Env outEnv;
protected
Option<String> name;
AvlTree tree;
ExtendsTable exts;
ImportTable imps;
FrameType ty;
Env rest;
Util.StatefulBoolean is_used;
algorithm
FRAME(name, ty, tree, exts, imps, is_used) :: rest := inEnv;
tree := avlTreeReplace(tree, inItemName, inItem);
outEnv := FRAME(name, ty, tree, exts, imps, is_used) :: rest;
end updateItemInEnv;

public function getItemInEnv
input String inItemName;
input Env inEnv;
output Item outItem;
protected
AvlTree tree;
algorithm
FRAME(clsAndVars = tree) :: _ := inEnv;
outItem := avlTreeGet(tree, inItemName);
end getItemInEnv;

protected function extendEnvWithImport
"Extends the environment with an import element."
input SCode.Element inImport;
Expand Down
2 changes: 1 addition & 1 deletion Compiler/FrontEnd/SCodeFlatten.mo
View file
Expand Up @@ -130,7 +130,7 @@ algorithm
env = SCodeEnv.updateExtendsInEnv(env);

(prog, env) = SCodeDependency.analyse(inClassName, env, prog);
prog = SCodeFlattenImports.flattenProgram(prog, env);
(prog, env) = SCodeFlattenImports.flattenProgram(prog, env);
prog = SCodeFlattenExtends.flattenProgram(prog, env);

//System.stopTimer();
Expand Down
130 changes: 74 additions & 56 deletions Compiler/FrontEnd/SCodeFlattenImports.mo
View file
Expand Up @@ -46,7 +46,9 @@ public import SCodeEnv;

public type Env = SCodeEnv.Env;

protected import Debug;
protected import Error;
protected import RTOpts;
protected import SCodeLookup;
protected import Util;

Expand All @@ -59,37 +61,59 @@ public function flattenProgram
input SCode.Program inProgram;
input Env inEnv;
output SCode.Program outProgram;
output Env outEnv;
algorithm
outProgram := Util.listMap1(inProgram, flattenClass, inEnv);
(outProgram, outEnv) := Util.listMapAndFold(inProgram, flattenClass, inEnv);
end flattenProgram;

public function flattenClass
input SCode.Element inClass;
input Env inEnv;
output SCode.Element outClass;
protected
SCode.Ident name;
SCode.Partial part_pre;
SCode.Encapsulated encap_pre;
SCode.Prefixes prefixes;
SCode.Restriction restriction;
SCode.ClassDef cdef;
Absyn.Info info;
Env env;
output Env outEnv;
algorithm
SCode.CLASS(name, prefixes, encap_pre, part_pre, restriction, cdef, info) := inClass;
env := SCodeEnv.enterScope(inEnv, name);
cdef := flattenClassDef(cdef, env, info);
outClass := SCode.CLASS(name, prefixes, encap_pre, part_pre, restriction, cdef, info);
(outClass, outEnv) := matchcontinue(inClass, inEnv)
local
SCode.Ident name;
SCode.ClassDef cdef;
Absyn.Info info;
Item item;
Env env;
SCodeEnv.Frame cls_env;
SCode.Element cls;
SCodeEnv.ClassType cls_ty;

case (SCode.CLASS(name = name, classDef = cdef, info = info), _)
equation
SCodeEnv.CLASS(env = {cls_env}, classType = cls_ty) =
SCodeEnv.getItemInEnv(name, inEnv);
env = SCodeEnv.enterFrame(cls_env, inEnv);

(cdef, cls_env :: env) = flattenClassDef(cdef, env, info);
cls = SCode.setElementClassDefinition(cdef, inClass);
item = SCodeEnv.newClassItem(cls, {cls_env}, cls_ty);
env = SCodeEnv.updateItemInEnv(item, env, name);
then
(cls, env);

else
equation
true = RTOpts.debugFlag("failtrace");
Debug.traceln("- SCodeFlattenImports.flattenClass failed on " +&
SCode.elementName(inClass) +& " in " +& SCodeEnv.getEnvName(inEnv));
then
fail();
end matchcontinue;
end flattenClass;

protected function flattenClassDef
input SCode.ClassDef inClassDef;
input Env inEnv;
input Absyn.Info inInfo;
output SCode.ClassDef outClassDef;
output Env outEnv;
algorithm
outClassDef := match(inClassDef, inEnv, inInfo)
(outClassDef, outEnv) := match(inClassDef, inEnv, inInfo)
local
list<SCode.Element> el, ex, cl, im, co, ud;
list<SCode.Equation> neql, ieql;
Expand All @@ -102,37 +126,29 @@ algorithm
SCode.Attributes attr;
Env env;
SCode.Ident bc;
SCode.ClassDef cdef;

case (SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt), _, _)
equation
// Lookup elements.
el = Util.listMap1(el, flattenElement, inEnv);
el = Util.listFilter(el, isNotImport);
(el, env) = Util.listMapAndFold(el, flattenElement, inEnv);

// Lookup equations and algorithm names.
neql = Util.listMap1(neql, flattenEquation, inEnv);
ieql = Util.listMap1(ieql, flattenEquation, inEnv);
nal = Util.listMap1(nal, flattenAlgorithm, inEnv);
ial = Util.listMap1(ial, flattenAlgorithm, inEnv);
neql = Util.listMap1(neql, flattenEquation, env);
ieql = Util.listMap1(ieql, flattenEquation, env);
nal = Util.listMap1(nal, flattenAlgorithm, env);
ial = Util.listMap1(ial, flattenAlgorithm, env);
then
SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt);
(SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt), env);

case (SCode.CLASS_EXTENDS(bc, mods, SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt)), _, _)
case (SCode.CLASS_EXTENDS(bc, mods, cdef), _, _)
equation
// Lookup elements.
el = Util.listMap1(el, flattenElement, inEnv);
el = Util.listFilter(el, isNotImport);

// Lookup equations and algorithm names.
neql = Util.listMap1(neql, flattenEquation, inEnv);
ieql = Util.listMap1(ieql, flattenEquation, inEnv);
nal = Util.listMap1(nal, flattenAlgorithm, inEnv);
ial = Util.listMap1(ial, flattenAlgorithm, inEnv);

mods = flattenModifier(mods, inEnv, inInfo);
(cdef, env) = flattenClassDef(cdef, inEnv, inInfo);
mods = flattenModifier(mods, env, inInfo);
then
SCode.CLASS_EXTENDS(bc, mods, SCode.PARTS(el, neql, ieql, nal, ial, extdecl, annl, cmt));
(SCode.CLASS_EXTENDS(bc, mods, cdef), env);

case (SCode.DERIVED(ty, mods, attr, cmt), env, _)
equation
mods = flattenModifier(mods, env, inInfo);
Expand All @@ -141,9 +157,9 @@ algorithm
env = SCodeEnv.removeExtendsFromLocalScope(env);
ty = flattenTypeSpec(ty, env, inInfo);
then
SCode.DERIVED(ty, mods, attr, cmt);
(SCode.DERIVED(ty, mods, attr, cmt), inEnv);

else then inClassDef;
else then (inClassDef, inEnv);
end match;
end flattenClassDef;

Expand Down Expand Up @@ -177,36 +193,38 @@ protected function flattenElement
input SCode.Element inElement;
input Env inEnv;
output SCode.Element outElement;
output Env outEnv;
algorithm
outElement := match(inElement, inEnv)
(outElement, outEnv) := match(inElement, inEnv)
local
Env env;
SCode.Element elem;
String name;
Item item;

// Lookup component types, modifications and conditions.
case (SCode.COMPONENT(name = _), _)
then flattenComponent(inElement, inEnv);
case (SCode.COMPONENT(name = name), _)
equation
elem = flattenComponent(inElement, inEnv);
item = SCodeEnv.newVarItem(elem, true);
env = SCodeEnv.updateItemInEnv(item, inEnv, name);
then
(elem, env);

// Lookup class definitions.
case (SCode.CLASS(name = _), _)
then flattenClassDefElements(inElement, inEnv);
equation
(elem, env) = flattenClass(inElement, inEnv);
then
(elem, env);

// Lookup base class and modifications in extends clauses.
case (SCode.EXTENDS(baseClassPath = _), _)
then flattenExtends(inElement, inEnv);
then (flattenExtends(inElement, inEnv), inEnv);

else then inElement;
else then (inElement, inEnv);
end match;
end flattenElement;

protected function flattenClassDefElements
input SCode.Element inClassDefElement;
input Env inEnv;
output SCode.Element outClassDefElement;
protected
SCode.Ident name;
SCode.Element cls;
algorithm
SCode.CLASS(name = _) := inClassDefElement;
cls := flattenClass(inClassDefElement, inEnv);
outClassDefElement := cls;
end flattenClassDefElements;

protected function flattenComponent
input SCode.Element inComponent;
Expand Down
1 change: 0 additions & 1 deletion Compiler/FrontEnd/SCodeUtil.mo
View file
Expand Up @@ -104,7 +104,6 @@ algorithm
// retrieve the expandable connector presence external flag
// hasExpandableConnectors = System.getHasExpandableConnectors();
// (ih, sp) = ExpandableConnectors.elaborateExpandableConnectors(sp, hasExpandableConnectors);
// sp = SCodeFlatten.flatten(sp);
then
sp;
end match;
Expand Down

0 comments on commit b467744

Please sign in to comment.