Added partial_inst_class_in to speed up lookup of classes.

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@1075 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Jan 20, 2004 · db9c4c8 · db9c4c8
1 parent b94e46b
commit db9c4c8
Show file tree

Hide file tree

Showing 3 changed files with 171 additions and 72 deletions.
diff --git a/modeq/inst.rml b/modeq/inst.rml
@@ -82,6 +82,11 @@ module Inst:
 	  => ( DAE.Element list, Env.Env, Connect.Sets, 
 	      ClassInf.State, Types.Var list)
 
+  relation partial_inst_class_in: ( Env.Env, Types.Mod, Prefix.Prefix, 
+			   Connect.Sets, ClassInf.State,
+			   SCode.Class, bool, InstDims)
+	  => (Env.Env, ClassInf.State)
+
   relation implicit_instantiation : (Env.Env, Types.Mod, Prefix.Prefix,
 				     Connect.Sets, SCode.Class,InstDims, bool)
 	  => (Env.Env, DAE.Element list)
@@ -489,6 +494,34 @@ relation inst_class_in: (Env, Mod, Prefix, Connect.Sets, ClassInf.State,
 
 end
 
+relation partial_inst_class_in: (Env, Mod, Prefix, Connect.Sets, ClassInf.State,
+			 SCode.Class, bool, InstDims)
+	  => (Env, ClassInf.State) =
+
+  axiom	partial_inst_class_in(env,mods,pre,csets,ci_state,
+		      c as SCode.CLASS("Real",_,_,_,_),_,_) 
+	  => (env,ci_state)
+
+  axiom	partial_inst_class_in(env,mods,pre,csets,ci_state,
+		      c as SCode.CLASS("Integer",_,_,_,_),_,_)
+	  => (env,ci_state)
+
+  axiom	partial_inst_class_in(env,mods,pre,csets,ci_state,
+		      c as SCode.CLASS("String",_,_,_,_),_,_)
+	  => (env,ci_state)
+
+  axiom	partial_inst_class_in(env,mods,pre,csets,ci_state,
+		      c as SCode.CLASS("Boolean",_,_,_,_),_,_)
+	  => (env,ci_state)
+  rule	
+	partial_inst_classdef(env,mods,pre,csets,ci_state,d,r,prot,inst_dims)
+	  => (env',ci_state')
+	-------------------------------------
+	partial_inst_class_in(env,mods,pre,csets,ci_state,
+		      c as SCode.CLASS(n,_,_,r,d), prot, inst_dims)
+	  => (env',ci_state')
+end
+
 (** relation: inst_classdef
  **
  ** There are two kinds of class definitions, either explicit
@@ -673,6 +706,68 @@ relation inst_classdef: (Env, Mod, Prefix, Connect.Sets, ClassInf.State,
 
 end	
 
+(** relation: partial_inst_classdef
+ **
+ **)
+
+relation partial_inst_classdef: (Env, Mod, Prefix, Connect.Sets, ClassInf.State,
+			 SCode.ClassDef, SCode.Restriction, bool,InstDims)
+	  => ( Env, ClassInf.State ) =
+
+  rule	
+	ClassInf.trans(ci_state, ClassInf.NEWDEF) => ci_state1 &
+
+	classdef_elts(els) => cdefelts &
+	extends_elts(els) => extendselts &
+	(* 1. CLASSDEF & IMPORT nodes and COMPONENT nodes(add to env)*)
+	add_classdefs_to_env(env,cdefelts,true) => env1 &
+
+	(*2. EXTENDS Nodes*)
+	(* inst_extends_list only flatten inhteritance structure. *)
+	(* It does not perform component instantiations. *)
+	inst_extends_list(env1, mods, extendselts, ci_state, true)
+	  => (env2, emods, extcomps, eqs2, initeqs2, alg2, initalg2) 
+	------------------------------------------------------
+	partial_inst_classdef(env, mods, pre, csets, ci_state,
+		      SCode.PARTS(els,eqs,initeqs,alg,initalg,_), re, prot, 
+		      inst_dims)
+	  => (env2,ci_state1)
+
+
+	(** This rule describes how to instantiate a derived class *)
+	(** definition *)
+
+  rule	Lookup.lookup_class(env,cn,true) 
+	  => (c as SCode.CLASS(cn2,_,enc2,r,_), cenv) &
+	Env.open_scope(cenv,enc2,0) => cenv' &
+	Env.name_scope(cenv',cn2) => cenv'' &
+	Mod.lookup_modification_p(mods,cn) => m &
+	Mod.elab_mod(env,pre,mod) => mod' &
+	ClassInf.start(r, cn2) => new_ci_state &
+	Mod.merge(mods,m,cenv'',pre) => mods' &
+	Mod.merge(mods',mod',cenv'',pre) => mods'' &
+	partial_inst_class_in(cenv'', mods'', pre, csets, new_ci_state, c,prot,inst_dims)
+	  =>  (env'',new_ci_state')
+	----------------------------------------
+	partial_inst_classdef(env, mods, pre, csets, ci_state,
+		      SCode.DERIVED(cn,ad,mod), re, prot, 
+		      inst_dims)
+	  => (env'',new_ci_state')
+
+	(** If the class is derived from a class that can not be *)
+	(** found in the environment, this rule prints an error *)
+	(** message. *)
+
+  rule	not Lookup.lookup_class(env,cn,false) => (_,_) &
+	Absyn.path_string(cn) => cns &
+	Print.print_buf "# unknown class: " & Print.print_buf cns & Print.print_buf "\n"
+	----------------------------------------
+	partial_inst_classdef(env,mods,pre,csets,ci_state,
+		      SCode.DERIVED(cn,ad,mod), re, prot, 
+		      inst_dims)
+	  => fail
+end	
+
 relation update_compelts_mods: (Env.Env, Prefix.Prefix, (SCode.Element*Types.Mod) list,
 				ClassInf.State, bool) 
 	=> ((SCode.Element * Types.Mod) list, Env.Env) =

diff --git a/modeq/interactive.rml b/modeq/interactive.rml
@@ -1747,8 +1747,8 @@ relation get_nth_inherited_class2: (SCode.Class, Absyn.Class,int, Env.Env)
 	Env.open_scope(env,encflag,0) => env2 &
 	Env.name_scope (env2,id) => env3 &
 	ClassInf.start(restr,id) => ci_state &
-	Inst.inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[],true,true) 
-	  => (_,env'',_,_,_) &
+	Inst.partial_inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) 
+	  => (env'',_) &
 	get_base_classes(cdef,env'') => lst &  
 	int_sub(n,1) => n' &
 	list_nth(lst,n') => cref &
@@ -1848,8 +1848,8 @@ rule	(* If fails, instantiate class and search... *)
 	Env.open_scope(env,encflag,0) => env2 &
 	Env.name_scope (env2,id) => env3 &
 	ClassInf.start(restr,id) => ci_state &
-	Inst.inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[],true,true) 
-	  => (_,env'',_,_,_) &
+	Inst.partial_inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) 
+	  => (env'',_) &
 	get_nth_component_in_class(cdef,n) => comp &
 	get_component_name_and_type_and_comment (comp,env'') => [s1] &
 	string_append("{",s1) => s2 &
@@ -1878,8 +1878,8 @@ relation get_components: (Absyn.ComponentRef,Absyn.Program) => string =
 	Env.open_scope(env',encflag,0) => env2 &
 	Env.name_scope (env2,id) => env3 &
 	ClassInf.start(restr,id) => ci_state &
-	Inst.inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[],true,true) 
-	  => (_,env'',_,_,_) &
+	Inst.partial_inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) 
+	  => (env'',_) &
 	get_components_in_class(cdef) => comps &
 	get_components_name_and_type_and_comment (comps,env'') => s1 &
 	string_append("{",s1) => s2 &
@@ -2435,7 +2435,7 @@ end
 
 relation get_icon_annotation_in_class : (Absyn.Class) => string =
 
-  rule	get_annotations_from_parts(parts) => annlst &
+  rule	get_icon_annotation_from_parts(parts) => annlst &
 	get_icon_annotation_str(annlst) => s1 &
 	string_append("{",s1) => s2 &
 	string_append(s2,"}") => str 
@@ -2444,93 +2444,90 @@ relation get_icon_annotation_in_class : (Absyn.Class) => string =
 	  => str	
 end
 
-relation get_annotations_from_parts: Absyn.ClassPart list 
+relation get_icon_annotation_from_parts: Absyn.ClassPart list 
 	  => Absyn.ElementArg list =
 
-  axiom	get_annotations_from_parts [] => []
+  axiom	get_icon_annotation_from_parts [] => []
 
-  rule	get_annotations_from_elts(elts) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_elts(elts) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.PUBLIC(elts)::rest) => res
+	get_icon_annotation_from_parts(Absyn.PUBLIC(elts)::rest) => res
 
-  rule	get_annotations_from_elts(elts) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_elts(elts) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.PROTECTED(elts)::rest) => res
+	get_icon_annotation_from_parts(Absyn.PROTECTED(elts)::rest) => res
 
-  rule	get_annotations_from_eqns(eqns) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_eqns(eqns) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.EQUATIONS(eqns)::rest) => res
+	get_icon_annotation_from_parts(Absyn.EQUATIONS(eqns)::rest) => res
 
-  rule	get_annotations_from_eqns(eqns) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_eqns(eqns) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.INITIALEQUATIONS(eqns)::rest) => res
+	get_icon_annotation_from_parts(Absyn.INITIALEQUATIONS(eqns)::rest) => 
+	res
 
-  rule	get_annotations_from_algs(algs) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_algs(algs) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.ALGORITHMS(algs)::rest) => res
+	get_icon_annotation_from_parts(Absyn.ALGORITHMS(algs)::rest) => res
 
-  rule	get_annotations_from_algs(algs) => lst1 &
-	get_annotations_from_parts(rest) => lst2 &
-	list_append(lst1,lst2) => res
+  rule	get_icon_annotation_from_algs(algs) => res
 	-----------------------------------------
-	get_annotations_from_parts(Absyn.INITIALALGORITHMS(algs)::rest) => res
+	get_icon_annotation_from_parts(Absyn.INITIALALGORITHMS(algs)::rest) => res
+  rule	get_icon_annotation_from_parts(rest) => res
+	-----------------------------------------
+	get_icon_annotation_from_parts(_::rest) => res
 end
 
-relation get_annotations_from_elts: (Absyn.ElementItem list) 
+relation get_icon_annotation_from_elts: (Absyn.ElementItem list) 
 	  => Absyn.ElementArg list =
-  axiom get_annotations_from_elts [] => []
+  axiom get_icon_annotation_from_elts [] => []
 
-  rule	get_annotations_from_elts(rest) => lst1 &
-	list_append(lst1,lst2) => res
+  rule	contain_icon_annotation(lst)
 	-----------------------------
-	get_annotations_from_elts(Absyn.ANNOTATIONITEM(Absyn.ANNOTATION(lst2))::rest)
+	get_icon_annotation_from_elts(Absyn.ANNOTATIONITEM(Absyn.ANNOTATION(lst))::rest)
+	  => lst
+  rule	get_icon_annotation_from_elts(rest) => res
+	-----------------------------
+	get_icon_annotation_from_elts(_::rest)
 	  => res
+end
+
+relation contain_icon_annotation: Absyn.ElementArg list => () =
+
+  axiom	contain_icon_annotation(Absyn.MODIFICATION(_,_,Absyn.CREF_IDENT("Icon",_),_,_)::_) => ()
 
-  rule	get_annotations_from_elts(rest) => res
+  rule	contain_icon_annotation(lst)
 	-----------------------------
-	get_annotations_from_elts(_::rest)
-	  => res
+	contain_icon_annotation(_::lst) 
 end
 
-relation get_annotations_from_eqns: (Absyn.EquationItem list) 
+relation get_icon_annotation_from_eqns: (Absyn.EquationItem list) 
 	  => Absyn.ElementArg list =
 
-  axiom	get_annotations_from_eqns [] => []
+  axiom	get_icon_annotation_from_eqns [] => []
 
-  rule	get_annotations_from_eqns(rest) => lst1 &
-	list_append(lst1,lst2) => res
+  rule	contain_icon_annotation(lst)
 	--------------------------------------
-	get_annotations_from_eqns(Absyn.EQUATIONITEMANN(Absyn.ANNOTATION(lst2))::rest)
-	  => res
+	get_icon_annotation_from_eqns(Absyn.EQUATIONITEMANN(Absyn.ANNOTATION(lst))::rest)
+	  => lst
 
-  rule	get_annotations_from_eqns(rest) => res
+  rule	get_icon_annotation_from_eqns(rest) => res
 	--------------------------------------
-	get_annotations_from_eqns(_::rest) => res
+	get_icon_annotation_from_eqns(_::rest) => res
 end
 
-relation get_annotations_from_algs: Absyn.AlgorithmItem list 
+relation get_icon_annotation_from_algs: Absyn.AlgorithmItem list 
 	  => Absyn.ElementArg list =
 
-  axiom	get_annotations_from_algs [] => []
+  axiom	get_icon_annotation_from_algs [] => []
 
-  rule	get_annotations_from_algs(rest) => lst1 &
-	list_append(lst1,lst2) => res
+  rule	contain_icon_annotation(lst)
 	-----------------------------
-	get_annotations_from_algs(Absyn.ALGORITHMITEMANN(Absyn.ANNOTATION(lst2))::rest) 
-	=> res
-  rule	get_annotations_from_algs(rest) => res
+	get_icon_annotation_from_algs(Absyn.ALGORITHMITEMANN(Absyn.ANNOTATION(lst))::rest) 
+	=> lst
+  rule	get_icon_annotation_from_algs(rest) => res
 	-----------------------------
-	get_annotations_from_algs(_::rest) => res
+	get_icon_annotation_from_algs(_::rest) => res
 end
 
 relation get_icon_annotation_in_elementitemlist: (Absyn.ElementItem list) => string =

diff --git a/modeq/lookup.rml b/modeq/lookup.rml
@@ -202,8 +202,8 @@ relation lookup_class: (Env.Env, Absyn.Path, bool) => (SCode.Class, Env.Env) =
 	Env.open_scope(env',encflag,0) => env2 &
 	Env.name_scope (env2,id) => env2' &
 	ClassInf.start(restr,id) => ci_state &
-	Inst.inst_class_in(env2',Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[],true,true) 
-	  => (_,env'',_,cistate1,_) &
+	Inst.partial_inst_class_in(env2',Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) 
+	  => (env'',cistate1) &
         not ClassInf.valid(cistate1,SCode.R_PACKAGE)  &  (* Has to do additional check for encapsulated classes, see rule below *)
 
 	lookup_class_in_class(env'', c, path, true) => (c', env''') 
@@ -217,8 +217,8 @@ relation lookup_class: (Env.Env, Absyn.Path, bool) => (SCode.Class, Env.Env) =
 	Env.name_scope (env2,id) => env3 &
 	ClassInf.start(restr,id) => ci_state &
 
-	Inst.inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[],true,true) 
-	  => (_,env4,_,cistate1,_) &
+	Inst.partial_inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) 
+	  => (env4,cistate1) &
         ClassInf.valid(cistate1,SCode.R_PACKAGE)  &  (* Has NOT to do additional check for encapsulated classes, see rule above *)
 	lookup_class_in_class(env4, c, path, false) 
 	  => (c', env5) 
@@ -227,14 +227,16 @@ relation lookup_class: (Env.Env, Absyn.Path, bool) => (SCode.Class, Env.Env) =
 	  => (c', env5)
 
   rule	(*print "-lookup_class failed\n" &
-	Absyn.path_string path => s & 
+ 	Absyn.path_string path => s & 
+	Env.print_env env &
+	Print.get_string => str & print "Env: " & print str & print "\n" 
 	Print.print_buf "#Error, class " & Print.print_buf s & 
 	Print.print_buf " not found.\n" &
-(*	Debug.fprint("failtrace", "- lookup_class failed\n  - looked for ") &
+	Debug.fprint("failtrace", "- lookup_class failed\n  - looked for ") &
  	Debug.fprint("failtrace",  s) &
 	Debug.fprint("failtrace", "\n env:") &
 	Debug.fcall("failtrace", Env.print_env, env) &
-	Debug.fprint("failtrace", "\n") *)*)
+	Debug.fprint("failtrace", "\n") *)
 	--------------
 	lookup_class(env,path,true)=> fail 
 end
@@ -258,9 +260,9 @@ relation lookup_qualified_imported_class_in_env:(Env.Env, Env.Env,
        	Env.open_scope(env',encflag,0) => env2 &
 	Env.name_scope (env2,id) => env3 &
 	ClassInf.start(restr,id) => ci_state &
-	Inst.inst_class_in(env3, Types.NOMOD, Prefix.NOPRE, [], ci_state,
-			   c, false, [], true, true) 
-	  => (_,env4,_,_,_) &  
+	Inst.partial_inst_class_in(env3, Types.NOMOD, Prefix.NOPRE, [], ci_state,
+			   c, false, []) 
+	  => (env4,_) &  
 	lookup_class_in_class(env4, c, path, false) 
 	  => (c', env'')
 	-----------------------------------------------------------------
@@ -365,8 +367,8 @@ relation lookup_unqualified_imported_class_in_frame: (Env.Item list, Env.Env, SC
 	Env.open_scope(env', encflag,0) => env2 &
 	Env.name_scope (env2,id) => env2' &
 	ClassInf.start(restr, id) => ci_state &
-	Inst.inst_class_in(env2', Types.NOMOD, Prefix.NOPRE, [], ci_state, c, false, [], true,true) 
-	  => (_,env'',_,cistate1,_) &
+	Inst.partial_inst_class_in(env2', Types.NOMOD, Prefix.NOPRE, [], ci_state, c, false, []) 
+	  => (env'',cistate1) &
 
 	lookup_class_in_class(env'', c, Absyn.IDENT(ident), false) 
 	  => (c', env''') &
@@ -929,9 +931,14 @@ relation lookup_class_in_env: (Env.Env,Absyn.Path,bool) => (SCode.Class, Env.Env
   rule	(* Look in  first inherited classes. *)
 	(* To prevent infinite recursion, the recursive call is stripped from the 
 	 inherited scopes. Also spec says that inherited classes are looked up 
-	 idenpendently. *)
-	lookup_class(Env.FRAME(sid,a,b,c,[],d)::fs,bc,false) => (_,env') &
-	lookup_class(env',id,false) => (c,env'')
+	 independently. *)
+	lookup_class(Env.FRAME(sid,a,b,c,[],d)::fs,bc,false) 
+	  => (c as SCode.CLASS(cid,_,encflag,restr,_),env') &
+	ClassInf.start(restr,cid) => ci_state &
+       	Env.open_scope(env',encflag,0) => env2 &
+	Env.name_scope (env2,cid) => env3 &
+	Inst.partial_inst_class_in(env3,Types.NOMOD,Prefix.NOPRE,[],ci_state,c,false,[]) => (env4,ci_state') &
+	lookup_class(env4,id,false) => (c,env'') 
 	--------------------------------------
 	lookup_class_in_env((f as Env.FRAME(sid,a,b,c,bc::bcs,d))::fs,
 			    id ,msgflag)