Skip to content

Commit

Permalink
Start using lform.
Browse files Browse the repository at this point in the history 
git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@127 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
  • Loading branch information
x97davka committed Feb 18, 1998
1 parent aaae561 commit 4915167
Showing 1 changed file with 92 additions and 67 deletions.
159 changes: 92 additions & 67 deletions modeq/mod.rml
View file
Expand Up @@ -10,30 +10,32 @@
module Mod:

with "exp.rml"
with "absyn.rml"
with "lform.rml"
with "env.rml"
with "dae.rml"
with "prefix.rml"

type Mod = Absyn.Modification
type Mod = Lform.Modification

val empty_mod : Mod

relation modify_class: (Env.Env, Exp.Path, Mod, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list)
relation simple_modify_class : (Env.Env, Mod, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list)
relation maybe_modify_class: (Env.Env, Exp.Path, Mod option, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list)
relation simple_maybe_modify_class : (Env.Env, Mod option, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list)
relation lookup_modification: (Mod,Absyn.Ident) => Mod option
relation modify_class: (Env.Env, Exp.Path, Mod, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list)
relation simple_modify_class : (Env.Env, Mod, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list)
relation maybe_modify_class: (Env.Env, Exp.Path, Mod option,
Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list)
relation simple_maybe_modify_class : (Env.Env, Mod option,
Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list)
relation lookup_modification: (Mod,Lform.Ident) => Mod option

relation merge : (Mod option, Mod option) => Mod option

end

val empty_mod = Absyn.CLASSMOD([])
val empty_mod = Lform.CLASSMOD([])

(**********************************************************************)

Expand All @@ -51,63 +53,63 @@ end

(* utility *)

relation element_name : Absyn.Element => Exp.Ident =
relation element_name : Lform.Element => Exp.Ident =

axiom element_name(Absyn.ELEMENT(_,n,_)) => n
axiom element_name(Lform.ELEMENT(_,n,_)) => n

end

(**********************************************************************)

relation lookup_classmod : (Absyn.ElementArg list, Absyn.Ident)
relation lookup_classmod : (Lform.ElementArg list, Lform.Ident)
=> Mod option =

axiom lookup_classmod([],_) => NONE

rule mn = n
------
lookup_classmod(Absyn.MODIFICATION(f,Exp.IDENT(mn),m)::_,n)
lookup_classmod(Lform.MODIFICATION(f,Exp.IDENT(mn),m)::_,n)
=> SOME(m)

rule mn = n
------
lookup_classmod(Absyn.MODIFICATION(f,Exp.QUALIFIED(mn,p),m)::_,n)
=> SOME(Absyn.CLASSMOD([Absyn.MODIFICATION(f,p,m)]))
lookup_classmod(Lform.MODIFICATION(f,Exp.QUALIFIED(mn,p),m)::_,n)
=> SOME(Lform.CLASSMOD([Lform.MODIFICATION(f,p,m)]))

rule print "FIXME: lookup_classmod(REDECLARATION)\n" &
fail
-----------------------------------------------
lookup_classmod(Absyn.REDECLARATION(f,_)::_,n) => NONE
lookup_classmod(Lform.REDECLARATION(f,_)::_,n) => NONE

rule lookup_classmod(es,n) => m
--------------------------
lookup_classmod(_::es,n) => m

end

relation lookup_modification: (Mod,Absyn.Ident) => Mod option =
relation lookup_modification: (Mod,Lform.Ident) => Mod option =

rule print "Error: lookup_modification(EQUALMOD(_)," &
print n & print ")\n"
----------------------------------------------
lookup_modification(Absyn.EQUALMOD(_),n) => NONE
lookup_modification(Lform.EQUALMOD(_),n) => NONE

rule lookup_classmod(cm,n) => m
------------------------
lookup_modification(Absyn.CLASSMOD(cm),n) => m
lookup_modification(Lform.CLASSMOD(cm),n) => m

end

relation modifies: (Mod,Absyn.Ident) => () =
relation modifies: (Mod,Lform.Ident) => () =

rule lookup_modification(mod,n) => m
-------------------------------
modifies(mod,n)

end

relation modify_element : (Mod option,Prefix.Prefix,Absyn.Element,bool)
=> (Absyn.Element, DAE.DAEcomp list) =
relation modify_element : (Mod option,Prefix.Prefix,Lform.Element,bool)
=> (Lform.Element, DAE.DAEcomp list) =

axiom modify_element(NONE,_,e,_) => (e,[])

Expand All @@ -121,87 +123,110 @@ relation modify_element : (Mod option,Prefix.Prefix,Absyn.Element,bool)
rule modifies(mod,n) &
print "Error: Trying to modify final element " & print n & print "\n"
---------------------------------------------------------------------
modify_element(SOME(mod),_,e as Absyn.ELEMENT(true,n,_),_) => (e,[])
modify_element(SOME(mod),_,e as Lform.ELEMENT(true,n,_),_) => (e,[])

rule Prefix.prefix_exp(exp,pre) => exp' &
element_name(e) => n &
Prefix.prefix_path(Exp.IDENT(n),pre) => np
Prefix.prefix_path(Exp.IDENT(n),pre) => np &

print " modify_element: adding equation " &
Exp.path_string(np) => nps &
print nps & print " = ...\n"
-----------------------------------
modify_element(SOME(Absyn.EQUALMOD(exp)),pre, e,_)
modify_element(SOME(Lform.EQUALMOD(exp)),pre, e,_)
=> (e,[DAE.EQUATION(Exp.RELATION(Exp.PATH(np),Exp.EQUAL,exp'))])
(*
rule Prefix.prefix_path(Exp.IDENT(en),pre) => np &

print " modify_element: modify_class( " &
Exp.path_string(np) => nps &
print nps & print ", ...)\n" &

modify_class(env,np,m,pre,c) => (c',dae)
-----------------------------------------------------------
modify_element(SOME(m),pre, e as Lform.ELEMENT(f,en,
Lform.COMPONENTS(_,_,_,_,_,t,
[Lform.COMPONENT(])),_)
=> (Lform.ELEMENT(f,en,Lform.COMPONENTS
*)
rule Prefix.prefix_path(Exp.IDENT(en),pre) => np &
Exp.path_string(np) => ns &
print "# ignoring modification of " & print ns & print "\n"
-----------------------------------------------------------
modify_element(SOME(m),pre,e as Lform.ELEMENT(_,en,_),_) => (e,[])

end

relation modify_classpart : (Mod,Prefix.Prefix,Absyn.ClassPart)
=> (Absyn.ClassPart, DAE.DAEcomp list) =
relation modify_classpart : (Mod,Prefix.Prefix,Lform.ClassPart)
=> (Lform.ClassPart, DAE.DAEcomp list) =

axiom modify_classpart(_,_,p as Absyn.EQUATIONS(_)) => (p,[])
axiom modify_classpart(_,_,p as Absyn.ALGORITHMS(_)) => (p,[])
axiom modify_classpart(_,_,p as Absyn.PUBLIC([])) => (p,[])
axiom modify_classpart(_,_,p as Absyn.PROTECTED([])) => (p,[])
axiom modify_classpart(_,_,p as Lform.EQUATIONS(_)) => (p,[])
axiom modify_classpart(_,_,p as Lform.ALGORITHMS(_)) => (p,[])
axiom modify_classpart(_,_,p as Lform.PUBLIC([])) => (p,[])
axiom modify_classpart(_,_,p as Lform.PROTECTED([])) => (p,[])

rule element_name(e) => en &
lookup_modification(mod,en) => mod' &
modify_element(mod',pre,e,true) => (e',eq1) &
modify_classpart(mod,pre,Absyn.PUBLIC(es))
=> (Absyn.PUBLIC(es'),eq2) &
modify_classpart(mod,pre,Lform.PUBLIC(es))
=> (Lform.PUBLIC(es'),eq2) &
list_append(eq1,eq2) => eq
---------------------------------------
modify_classpart(mod,pre,Absyn.PUBLIC(e::es))
=> (Absyn.PUBLIC(e'::es'),eq)
modify_classpart(mod,pre,Lform.PUBLIC(e::es))
=> (Lform.PUBLIC(e'::es'),eq)

rule element_name(e) => en &
lookup_modification(mod,en) => mod' &
modify_element(mod',pre,e,false) => (e',eq1) &
modify_classpart(mod,pre,Absyn.PROTECTED(es))
=> (Absyn.PUBLIC(es'),eq2) &
modify_classpart(mod,pre,Lform.PROTECTED(es))
=> (Lform.PUBLIC(es'),eq2) &
list_append(eq1,eq2) => eq
---------------------------------------
modify_classpart(mod,pre,Absyn.PROTECTED(e::es)) =>
(Absyn.PROTECTED(e'::es'), eq)
modify_classpart(mod,pre,Lform.PROTECTED(e::es)) =>
(Lform.PROTECTED(e'::es'), eq)

end

relation modify_classdef : (Env.Env,Mod,Prefix.Prefix,Absyn.ClassDef)
=> (Absyn.ClassDef, DAE.DAEcomp list) =
relation modify_classdef : (Env.Env,Mod,Prefix.Prefix,Lform.ClassDef)
=> (Lform.ClassDef, DAE.DAEcomp list) =

axiom modify_classdef(_,_,_,p as Absyn.PARTS([])) => (p,[])
axiom modify_classdef(_,_,_,p as Lform.PARTS([])) => (p,[])

rule modify_classpart(mod,pre,p) => (p',eq1) &
modify_classdef(env,mod,pre,Absyn.PARTS(ps))
=> (Absyn.PARTS(ps'),eq2) &
modify_classdef(env,mod,pre,Lform.PARTS(ps))
=> (Lform.PARTS(ps'),eq2) &
list_append(eq1,eq2) => eq
------------------------------------
modify_classdef(env,mod,pre,Absyn.PARTS(p::ps))
=> (Absyn.PARTS(p'::ps'), eq)
modify_classdef(env,mod,pre,Lform.PARTS(p::ps))
=> (Lform.PARTS(p'::ps'), eq)

rule Env.lookup_class(env,p) => Absyn.CLASS(n,_,r,d) &
rule Env.lookup_class(env,p) => Lform.Class(n,_,r,d) &
(* FIXME: Check restriction *)
modify_classdef(env,mod,pre,d) => (d',eq)
---------------------------------
modify_classdef(env,mod,pre,Absyn.DERIVED(p,ad,es)) => (d',eq)
modify_classdef(env,mod,pre,Lform.DERIVED(p,ad,es)) => (d',eq)

end

relation modify_class: (Env.Env, Exp.Path, Mod, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list) =
relation modify_class: (Env.Env, Exp.Path, Mod, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list) =

rule print " modify_class: Adding equation " &
Exp.path_string(vn) => s &
print s & print " = ...\n"
---------------------------------------------------
modify_class(env,vn,Absyn.EQUALMOD(e), pre, c)
modify_class(env,vn,Lform.EQUALMOD(e), pre, c)
=> (c,[DAE.EQUATION(Exp.RELATION(Exp.PATH(vn),Exp.EQUAL,e))])

rule modify_classdef(env,mod,pre,d) => (d',eq)
---------------------------------
modify_class(env,_,mod, pre, Absyn.CLASS(n,p,r,d))
=> (Absyn.CLASS(n,p,r,d'),eq)
modify_class(env,_,mod, pre, Lform.CLASS(n,p,r,d))
=> (Lform.CLASS(n,p,r,d'),eq)

end

relation maybe_modify_class: (Env.Env, Exp.Path, Mod option, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list) =
relation maybe_modify_class: (Env.Env, Exp.Path, Mod option, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list) =

axiom maybe_modify_class(_,_,NONE,pre,c) => (c, [])

Expand All @@ -211,25 +236,25 @@ relation maybe_modify_class: (Env.Env, Exp.Path, Mod option, Prefix.Prefix, Absy

end

relation simple_modify_class : (Env.Env, Mod, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list) =
relation simple_modify_class : (Env.Env, Mod, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list) =

rule modify_classdef(env,mod,pre,d) => (d',dae)
---------------------------------
simple_modify_class(env,mod,pre,Absyn.CLASS(n,p,r,d))
=> (Absyn.CLASS(n,p,r,d'),dae)
simple_modify_class(env,mod,pre,Lform.CLASS(n,p,r,d))
=> (Lform.CLASS(n,p,r,d'),dae)

end

relation simple_maybe_modify_class : (Env.Env, Mod option, Prefix.Prefix, Absyn.Class)
=> (Absyn.Class, DAE.DAEcomp list) =
relation simple_maybe_modify_class : (Env.Env, Mod option, Prefix.Prefix, Lform.Class)
=> (Lform.Class, DAE.DAEcomp list) =

axiom simple_maybe_modify_class(_,NONE,_,c) => (c,[])

rule modify_classdef(env,mod,pre,d) => (d',dae)
--------------------------------------
simple_maybe_modify_class(env,SOME(mod),pre,Absyn.CLASS(n,p,r,d))
=> (Absyn.CLASS(n,p,r,d'),dae)
simple_maybe_modify_class(env,SOME(mod),pre,Lform.CLASS(n,p,r,d))
=> (Lform.CLASS(n,p,r,d'),dae)

end

Expand All @@ -242,7 +267,7 @@ relation merge : (Mod option, Mod option) => Mod option =

axiom merge(m,NONE) => m

rule print "Incomplete handling of modification merging\n"
rule print "# incomplete handling of modification merging\n"
-----------------------------------------------------
merge(outer,inner) => outer

Expand Down

0 comments on commit 4915167

Please sign in to comment.