Don't use Absyn.VarAttr. Instead use SCode.Attributes.

Fixed functions.


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

Author: x97davka

modeq/staticexp.rml

@@ -10,6 +10,7 @@ module Static :
 
   with "absyn.rml"
   with "exp.rml"
+  with "explode.rml"
   with "types.rml"
   with "env.rml"
   with "values.rml"
@@ -335,23 +336,25 @@ end
 relation elab_call_args : (Env.Env, Absyn.Path, Absyn.Exp list)
 	=> (Exp.Exp, Properties) =
 
-(*
+	(* This rule finds user-defined functions. *)
+
+  rule	Lookup.lookup_type(env,fn) => (t as Types.T_COMPLEX(st,vl)) &
+	(* ClassInf.valid(st, Absyn.R_FUNCTION) & *)
+	function_params(vl) => (in,out as [(_,rt)]) &
+	elab_input_args(env, args, in) => (args', c)
+	--------------------------------------------
+	elab_call_args(env,fn,args) => (Exp.CALL(fn,args'), PROP(rt, c))
+
+	(* This rule finds the built-in functions *)
+
   rule	Lookup.lookup_type(env,fn) => (t as Types.T_FUNCTION(params,restype)) &
 	print "   function " & Dump.print_path fn & print " is " &
 	Types.print_type t & print "\n" &
-	elab_call_args(env,args,params) => (args',c)
+	(* elab_call_args(env,args,params) => (args',c) *)
+	elab_input_args(env, args, params) => (args',c)
 	-------------------------------------
-	elab_call2 (env,fn,args) => (Exp.CALL(fn,args'), PROP(restype, c))
-*)
+	elab_call_args (env,fn,args) => (Exp.CALL(fn,args'), PROP(restype, c))
 
-  rule	(* Lookup.lookup_class(env,fn) => fcl & *)
-	Lookup.lookup_type(env,fn) => (t as Types.T_COMPLEX(st,vl)) &
-	(* ClassInf.valid(st, Absyn.R_FUNCTION) & *)
-	function_params(vl) => (in,out as [Types.VAR(_,_,_,rt,_)]) &
-	elab_input_args(env, args, in) => args'
-	(** FIXME: calculate properties *)
-	----------------------------------
-	elab_call_args(env,fn,args) => (Exp.CALL(fn,args'), PROP(rt, false))
 
   rule	not Lookup.lookup_type(env,fn) => _ &
 	print "# Couldn't find function " & Dump.print_path fn & print "\n"
@@ -372,7 +375,8 @@ end
  ** separate lists.
  **)
 
-relation function_params : Types.Var list => (Types.Var list, Types.Var list) =
+relation function_params : Types.Var list => ((Ident * Types.Type) list,
+					      (Ident * Types.Type) list) =
 
   axiom	function_params [] => ([],[])
 
@@ -383,20 +387,20 @@ relation function_params : Types.Var list => (Types.Var list, Types.Var list) =
 
   rule	function_params vs => (in, out)
 	------------------------------
-	function_params ((v as Types.VAR(_,Absyn.ATTR(_,_,_,Absyn.INPUT),
-					 false,_,_))::vs)
-	  => (v::in, out)
+	function_params (Types.VAR(n,SCode.ATTR(_,_,_,Absyn.INPUT),
+				   false,t,Types.UNBOUND)::vs)
+	  => ((n,t)::in, out)
 
   rule	function_params vs => (in, out)
 	------------------------------
-	function_params ((v as Types.VAR(_,Absyn.ATTR(_,_,_,Absyn.OUTPUT),
-					 false,_,_))::vs)
-	  => (in, v::out)
+	function_params (Types.VAR(n,SCode.ATTR(_,_,_,Absyn.OUTPUT),
+					 false,t,Types.UNBOUND)::vs)
+	  => (in, (n,t)::out)
 
   rule	print "# Components in functions must be INPUT or OUTPUT\n" &
 	print "    component: " & print n & print "\n"
 	----------------------------------------------
-	function_params((v as Types.VAR(n,Absyn.ATTR(_,_,_,Absyn.BIDIR),_,_,_))
+	function_params((v as Types.VAR(n,SCode.ATTR(_,_,_,Absyn.BIDIR),_,_,_))
 			::vs) => fail
 
   rule	print "- function_params failed\n"
@@ -413,24 +417,25 @@ end
  ** `Types.Var'.
  **)
 
-relation elab_input_args : (Env.Env, Absyn.Exp list, Types.Var list)
-	  => Exp.Exp list =
+relation elab_input_args : (Env.Env, Absyn.Exp list, (Ident * Types.Type) list)
+	  => (Exp.Exp list, bool) =
 
-  axiom	elab_input_args(_, [], []) => []
+  axiom	elab_input_args(_, [], []) => ([], true)
 
-  rule	elab_exp(env, e) => (e',PROP(t,_)) &
+  rule	elab_exp(env, e) => (e',PROP(t, c1)) &
 	match_type(e', t, vt) => e'' &
-	elab_input_args(env, es, vs) => args'
+	elab_input_args(env, es, vs) => (args', c2) &
+	bool_and(c1, c2) => c
 	-------------------------------------
-	elab_input_args(env, e::es, Types.VAR(_,_,_,vt,_)::vs) => e''::args'
+	elab_input_args(env, e::es, (_,vt)::vs) => (e''::args', c)
 
   rule	elab_exp(env, e) => (e',PROP(t,_)) &
 	print "# Argument (" & Dump.print_exp e &
  	print ") doesn't match parameter type\n" &
 	print "    parameter type: " & Types.print_type vt & print "\n" &
 	print "    argument type: " & Types.print_type t & print "\n"
 	-------------------------------------------------------------
-	elab_input_args(env, e::es, Types.VAR(_,_,_,vt,_)::vs) => fail
+	elab_input_args(env, e::es, (_,vt)::vs) => fail
 
 end
 
@@ -484,11 +489,11 @@ relation elab_cref : (Env.Env, Absyn.ComponentRef) => (Exp.Exp, Properties) =
   rule	print "    elab_cref " & Dump.print_component_ref c & print "\n" &
 	elab_cref_subs (env,c) => (c', const) &
 	print "     subs\n" &
-	Lookup.lookup_var (env,c') => (Absyn.ATTR(ad,_,vartype,_),
+	Lookup.lookup_var (env,c') => (SCode.ATTR(ad,_,variability,_),
 				       t,
 				       binding) &
 	print "     looked it up\n" &
-	elab_cref2 (env, c', vartype, t, binding) => (exp,const) &
+	elab_cref2 (env, c', variability, t, binding) => (exp,const) &
 	subscript_cref_type (exp,t) => t' &
 	print "    elab_cref " & Dump.print_component_ref c &
 	print " => " & print " (" & Types.print_type t' & print ")\n"
@@ -509,7 +514,7 @@ end
  **)
 
 relation elab_cref2 : (Env.Env,
-		       Exp.ComponentRef, Absyn.VarType,
+		       Exp.ComponentRef, Absyn.Variability,
 		       Types.Type, Types.Binding) => (Exp.Exp,bool) =
 
 	(* FIXME: Check type of expression anyway? *)