Partly implemented support for Modelica.Math.tempInterpol2 function.

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

Compiler/Codegen.rml

@@ -2171,6 +2171,9 @@ relation dim_string : Exp.Subscript => string =
 	-------------------
 	dim_string e => ":"
 
+  rule	print "dim_string failed\n"
+	------------------
+	dim_string(_) => fail
 end
 
 (** relation: is_var_q
@@ -2923,7 +2926,7 @@ relation generate_rhs_cref : (Exp.ComponentRef, Exp.Type, int)
 	generate_array_rhs_cref(cref_str,crt,subs,tnr) => (cfn,var,tnr')
 	--------------------------------------
 	generate_rhs_cref (cref, crt, tnr) => (cfn,var,tnr')
-
+	
 end
 
 (** relation: subs_to_scalar
@@ -2987,6 +2990,11 @@ relation generate_scalar_rhs_cref : (string, Exp.Type,Exp.Subscript list, int)
 	--------------------
 	generate_scalar_rhs_cref (cref_str,crt,subs,tnr) 
 	  => (cfn1,cref1,tnr1)
+
+  rule	Debug.fprint("failtrace","-generate_scalar_rhs_cref failed\n")
+	--------------------
+	generate_scalar_rhs_cref (cref_str,crt,subs,tnr) 
+	  => fail
 end
 
 (** relation: generate_array_rhs_cref
@@ -3093,7 +3101,7 @@ relation generate_index_array : (Exp.Subscript, int)
 
   rule	generate_expression(e,tnr) => (cfn,var1,tnr1) &
 	Util.string_append_list(["make_index_array(1, ",var1,")"]) => idx &
-	let idxsize = "(0)"
+	let idxsize = "(1)"
 	------------------------------------
 	generate_index_array(Exp.INDEX(e), tnr) 
 	  => (cfn,idx,idxsize,tnr1)
@@ -3104,7 +3112,18 @@ relation generate_index_array : (Exp.Subscript, int)
 	generate_index_array(Exp.WHOLEDIM, tnr) 
 	  => (c_empty_function,idx,idxsize,tnr)
 
-
+  rule	generate_expression(e,tnr) => (cfn,var1,tnr1) &
+	generate_temp_decl("modelica_integer",tnr1) => (decl,tvar,tnr2) &
+	Util.string_append_list([tvar,"=size_of_dimension_integer_array(",var1,
+				 ",1);"]) => stmt &
+	c_add_statements(cfn,[stmt]) => cfn' &
+	c_add_variables(cfn',[decl]) => cfn'' &
+	Util.string_append_list(["integer_array_make_index_array(&",var1,")"]) => idx &
+	let idxsize = tvar 
+	-------------------
+	generate_index_array(Exp.SLICE(e), tnr) 
+	  => (cfn'',idx,idxsize,tnr2)
+
   rule	Debug.fprint("failtrace", "# generate_index_array failed\n")
 	-----------------------------
 	generate_index_array(_,_) => fail

Compiler/Dump.rml

@@ -96,6 +96,7 @@ module Dump:
   relation select_string: (bool,string,string) => string
   relation get_string_list : ('a list, 'a => string, string) => string
   relation get_option_str: ('a option, 'a => string) => string 
+  relation get_option_str_default: ('a option, 'a => string,string) => string 
   relation get_option_with_concat_str: ('a option, 'a => string,string) => string 
   relation unparse_annotation_option: (int, Absyn.Annotation option) => string 
   relation unparse_within: (int, Absyn.Within) => string 
@@ -3204,6 +3205,19 @@ relation get_option_str: ('a option, 'a => string) => string =
   axiom	get_option_str(NONE,_) => ""
 end
 
+(** relation get_option_str_default
+ **
+ ** Retrieve the string from a string option.
+ ** If NONE return default string.
+ **)
+relation get_option_str_default: ('a option, 'a => string,string) => string =
+  rule  r (a) => str
+	------------
+	get_option_str_default (SOME(a),r,_) => str
+
+  axiom	get_option_str_default(NONE,_,def) => def
+end
+
 (** relation: get_option_with_concat_str
  **
  ** Get option string value using a relation translating the value to a string

Compiler/Inst.rml

@@ -2165,7 +2165,6 @@ axiom	inst_element(env, mod, pre, csets, ci_state, (SCode.IMPORT(imp),_), instdi
 
 	let new_var = Types.VAR(n,Types.ATTR(flow,acc,param,dir),
 					 prot,ty,binding) &
-
 	Env.update_frame_v(env2',new_var,
 			   true,(*type info present*)
 			   compenv) => env' 
@@ -2407,6 +2406,45 @@ relation inst_var2 : (Env,
 	 ** equations.
 	 **)
         (** Rules for normal instantiation, will resolv dimensional sizes, etc. *)
+	  (* Array vars with binding in functions,e.g. input Real x[:]=Y *)
+  rule	(* Do not flatten because it is a function *)
+	inst_dim_exp_lst (dims,impl) => dims' &
+	(* get the equation modification *)
+	Mod.mod_equation(mod) => SOME(Types.TYPED(e,_,p)) &  
+	(* Instantiate type of the component *)
+	inst_class(env,mod,pre,csets,cl,inst_dims,impl,INNER_CALL) 
+	  => (_,env',csets',ty,st) &
+	(* Make it an array type since we are not flattening *)
+	make_array_type(dims,ty) => ty' &
+	Prefix.prefix_cref(pre,Exp.CREF_IDENT(n,[])) => cr &
+	Types.elab_type(ty') => ty'' &
+	Types.match_prop(e,Types.PROP(ty',Types.C_VAR),p) => (e',_) &
+	(* Put the mod equation in the dae so that code will be generated *)
+	make_dae_equation(Exp.CREF(cr,ty''),e',NON_INITIAL) => daeeq &
+
+	dae_declare(cr,ci_state,ty,attr,NONE,dims',NONE,NONE,comment) => dae1 &
+	list_append (dae1, [daeeq]) => dae
+	-------------------------------
+	inst_var2(env,ci_state as
+		  ClassInf.FUNCTION(_),mod,pre,csets,n,cl,
+                  attr,dims as _::_,idxs,inst_dims,impl,comment)
+          => (env',dae,csets',ty')
+
+	  (* Array vars without binding in functions , e.g. input Real x[:] *)
+  rule	(* Do not flatten because it is a function *)
+	inst_class(env,mod,pre,csets,cl,inst_dims,impl,INNER_CALL) 
+	  => (_,env',csets,ty,st) &
+	Prefix.prefix_cref(pre,Exp.CREF_IDENT(n,[])) => cr &
+	(* Do all dimensions... *)
+	inst_dim_exp_lst(dims,impl) => dims' &
+	dae_declare(cr,ci_state,ty,attr,NONE,dims',NONE,NONE,comment) => dae &
+	make_array_type(dims,ty) => arrty 
+	-------------------------------
+	inst_var2(env,ci_state as ClassInf.FUNCTION(_),mod,pre,csets,
+                  n,cl,attr,dims as _::_,idxs,inst_dims,impl,comment)
+          => (env',dae,csets,arrty)
+
+
 	(* Constants *)
   rule	list_reverse idxs => idxs' &
 	Prefix.prefix_add(n,idxs',pre) => pre' &
@@ -2495,44 +2533,6 @@ relation inst_var2 : (Env,
 	inst_var2(env,ci_state,mod,pre,csets,n,cl,SCode.ATTR(_,flow,acc,vt,dir),
 		  [],idxs,inst_dims,impl,comment)
           => (env',dae,csets',ty)
-
-	  (* Array vars with binding in functions,e.g. input Real x[:]=Y *)
-  rule	(* Do not flatten because it is a function *)
-	inst_dim_exp_lst (dims,impl) => dims' &
-	(* get the equation modification *)
-	Mod.mod_equation(mod) => SOME(Types.TYPED(e,_,p)) &  
-	(* Instantiate type of the component *)
-	inst_class(env,mod,pre,csets,cl,inst_dims,impl,INNER_CALL) 
-	  => (_,env',csets',ty,st) &
-	(* Make it an array type since we are not flattening *)
-	make_array_type(dims,ty) => ty' &
-	Prefix.prefix_cref(pre,Exp.CREF_IDENT(n,[])) => cr &
-	Types.elab_type(ty') => ty'' &
-	Types.match_prop(e,Types.PROP(ty',Types.C_VAR),p) => (e',_) &
-	(* Put the mod equation in the dae so that code will be generated *)
-	make_dae_equation(Exp.CREF(cr,ty''),e',NON_INITIAL) => daeeq &
-
-	dae_declare(cr,ci_state,ty,attr,NONE,dims',NONE,NONE,comment) => dae1 &
-	list_append (dae1, [daeeq]) => dae
-	-------------------------------
-	inst_var2(env,ci_state as
-		  ClassInf.FUNCTION(_),mod,pre,csets,n,cl,
-                  attr,dims as _::_,idxs,inst_dims,impl,comment)
-          => (env',dae,csets',ty')
-
-	  (* Array vars without binding in functions , e.g. input Real x[:] *)
-  rule	(* Do not flatten because it is a function *)
-	inst_class(env,mod,pre,csets,cl,inst_dims,impl,INNER_CALL) 
-	  => (_,env',csets,ty,st) &
-	Prefix.prefix_cref(pre,Exp.CREF_IDENT(n,[])) => cr &
-	(* Do all dimensions... *)
-	inst_dim_exp_lst(dims,impl) => dims' &
-	dae_declare(cr,ci_state,ty,attr,NONE,dims',NONE,NONE,comment) => dae &
-	make_array_type(dims,ty) => arrty 
-	-------------------------------
-	inst_var2(env,ci_state as ClassInf.FUNCTION(_),mod,pre,csets,
-                  n,cl,attr,dims as _::_,idxs,inst_dims,impl,comment)
-          => (env',dae,csets,arrty)
 
 
 	  (* FIXME: make a similar rule: if implicit=true and we fail to flatten, we should leave it unflattened *)
@@ -2796,7 +2796,6 @@ relation update_component_in_env: (Mod,Absyn.ComponentRef, Env,
 	 ** one.
 	 **)
 	check_structural_param_binding(param,binding,env2) => (env2',binding') &
-
 	Env.update_frame_v(env2',Types.VAR(n,Types.ATTR(flow,acc,param,dir),
 					 prot,ty,binding'),
 			   false,(*type info present*)
@@ -3325,6 +3324,8 @@ rule	Exp.print_subscript_str x => s1 &
 	------------------------------------------------
 	print_dim_str SOME(DIMEXP(x,_))::xs => res
 
+  axiom	print_dim_str(_) => "" 
+
 end
 
 (** relation: print_dim

Compiler/Static.rml

@@ -493,17 +493,18 @@ relation elab_matrix_to_matrix_exp_2: Exp.Exp list
 	  => expl'::es'
 end
 
-relation elab_matrix_to_matrix_exp_3:(Exp.Exp list) => (Exp.Exp*bool) list =
+relation elab_matrix_to_matrix_exp_3:(Exp.Exp list) 
+	  => (Exp.Exp*bool) list =
 
   axiom	elab_matrix_to_matrix_exp_3([]) => []
 
   rule	Exp.typeof(e) => tp &
-	Exp.type_builtin(tp) => narray &
-	bool_not(narray) => array &
+	Exp.type_builtin(tp) => scalar &
+	Util.bool_string(scalar) => s &
 	elab_matrix_to_matrix_exp_3(es) => es'
 	--------------------
 	elab_matrix_to_matrix_exp_3(e::es) 
-	  => ((e,array)::es')
+	  => ((e,scalar)::es')
 end
 
 (** relation: matrix_constr_max_dim
@@ -1226,13 +1227,13 @@ relation elab_matrix_comma : (Env.Env,
 	elab_matrix_comma (_,_,_,_,_,_) => fail
 end
 
-(** relation: elab_matrix_cat_one_exp
+(** relation: elab_matrix_cat_two_exp
  ** author: PA
  **
  ** This relation takes an array expression of dimension >=3 and
- ** concatenates each array element along the first dimension.
+ ** concatenates each array element along the second dimension.
  ** For instance
- ** elab_matrix_cat_one( {[1,2;5,6], [3,4;7,8]}) => [1,2,3,4;5,6,7,8]
+ ** elab_matrix_cat_two( {[1,2;5,6], [3,4;7,8]}) => [1,2,3,4;5,6,7,8]
  **)
 relation elab_matrix_cat_two_exp: (Exp.Exp)
 	  => (Exp.Exp) =
@@ -4924,7 +4925,8 @@ relation cref_vectorize: (Exp.Exp,Types.Type) => Exp.Exp =
 	cref_vectorize(Exp.CREF(cr,exptp),(Types.T_ARRAY(Types.DIM(SOME(ds)),t as (Types.T_ARRAY(Types.DIM(SOME(ds2)),_),_)),_)) =>  e
 
 	(* vectorsizes > 4 is not vectorized *)
-  rule	int_lt(ds,4) => true &
+  rule	Types.is_array(t) => false &
+	int_lt(ds,4) => true &
 	create_cref_array(cr,1,ds,exptp,t) => e 
 	-----------------------------------
 	cref_vectorize(Exp.CREF(cr,exptp),(Types.T_ARRAY(Types.DIM(SOME(ds)),t),_)) =>  e

Compiler/Types.rml

@@ -1038,8 +1038,9 @@ relation unparse_type: Type => string =
 	-----------------
 	unparse_type((T_ENUMERATION(l,_),_)) =>  str
 
-  rule  flatten_array_type t => (ty, dimlst) &
-	Util.list_map(dimlst,int_string) => dimlststr &
+  rule  flatten_array_type_opt t => (ty, dimlst) &
+	Util.list_map_2(dimlst,Dump.get_option_str_default,int_string,":") 
+	  => dimlststr &
 	list_reverse(dimlststr) => dimlststr' &
 	unparse_type ty => tys &
 	Util.string_delimit_list(dimlststr',", ") => dims &
@@ -1656,6 +1657,27 @@ relation flatten_array_type : Type => (Type, int list) =
 
 end
 
+
+(** relation: flatten_array_type_opt
+ **
+ ** Returns the element type of a Type and the list of dimensions of the type.
+ ** If dimension is ':' NONE is returned.
+ **)
+relation flatten_array_type_opt : Type => (Type, int option list) =
+
+  rule	flatten_array_type_opt ty => (ty', dimlist')
+	--------------------------------------
+  	flatten_array_type_opt((T_ARRAY(DIM(NONE),ty), _)) => (ty', NONE::dimlist')
+
+  rule	flatten_array_type_opt ty => (ty', dimlist) &
+	list_append (dimlist,[SOME(dim)]) => dimlist'
+	--------------------------------------
+  	flatten_array_type_opt((T_ARRAY(DIM(SOME(dim)), ty),_)) => (ty', dimlist')
+
+  axiom	flatten_array_type_opt ty => (ty, [])
+
+end
+
 (** relation: get_type_name
  **
  ** Return the type name of a Type.

c_runtime/index_spec.c

@@ -65,6 +65,18 @@ void alloc_index_spec(index_spec_t* s)
 	}
     }
 }
+/*
+ * create_index_spec
+ *
+ * Creates a subscript, i.e. index_spec_t from the arguments.
+ * nridx - number of indixes.
+ * Each index consist of a size and a pointer to indixes.
+ *
+ * For instance to create the indexes in a[1,{2,3}] you
+ * write:
+ * int tmp1[1]={1}; int tmp2[2]={2,3};
+ * create_index_spec(&dest,2,1,&tmp1,2,&tmp2);
+ */
 
 void create_index_spec(index_spec_t* dest, int nridx, ...)
 { 
@@ -85,6 +97,11 @@ void create_index_spec(index_spec_t* dest, int nridx, ...)
 
 }
 
+/* make_index_array
+ *
+ * Creates an integer array of indices to be used by e.g.
+ * create_index_spec above.
+ */
 int* make_index_array(int nridx,...)
 {
   int i;

c_runtime/integer_array.c

@@ -26,6 +26,7 @@
 #include <stdlib.h>
 #include <assert.h>
 #include <stdarg.h>
+
 int integer_array_ok(integer_array_t* a)
 {
     int i;
@@ -1320,6 +1321,18 @@ void skew_integer_array(integer_array_t* x,integer_array_t* dest)
   dest->data[6] = 0;
 }
 
+/* integer_array_make_index_array
+ *
+ * Creates an integer array if indices to be used by e.g.
+ ** create_index_spec defined in index_spec.c
+ */
+
+int* integer_array_make_index_array(integer_array_t *arr)
+{ 
+  return arr->data;
+}
+
+
 void clone_reverse_integer_array_spec(integer_array_t* source, integer_array_t* dest)
 {
   int i;
@@ -1360,3 +1373,4 @@ void convert_alloc_integer_array_from_f77(integer_array_t* a, integer_array_t* d
   }
   transpose_integer_array (a,dest);
  }
+

c_runtime/integer_array.h

@@ -175,6 +175,8 @@ void skew_integer_array(integer_array_t* x,integer_array_t* dest);
 
 size_t integer_array_nr_of_elements(integer_array_t* a);
 
+int* integer_array_make_index_array(integer_array_t *arr);
+
 void clone_reverse_integer_array_spec(integer_array_t* source, integer_array_t* dest);
 void convert_alloc_integer_array_to_f77(integer_array_t* a, integer_array_t* dest);
 void convert_alloc_integer_array_from_f77(integer_array_t* a, integer_array_t* dest);