diff --git a/modeq/codegen.rml b/modeq/codegen.rml
index 8a1117687d8..d87776b2a72 100644
--- a/modeq/codegen.rml
+++ b/modeq/codegen.rml
@@ -129,6 +129,14 @@ relation c_merge_fn : (CFunction, CFunction) => CFunction =
 			 
 end
 
+relation c_move_statements_to_inits : CFunction => CFunction =
+
+  rule	list_append(is,st) => is'
+	---------------------------
+	c_move_statements_to_inits CFUNCTION(rt,fn,rts,ad,vd,is,st,cl) 
+	  => CFUNCTION(rt,fn,rts,ad,vd,is',[],cl)
+end
+
 relation c_print_functions : CFunction list => () =
 
   axiom	c_print_functions []
@@ -468,7 +476,7 @@ relation generate_return_decl: DAE.Element => (string, string) =
 	is_first_in_array id => true &
 	dae_type_str (typ,is_a) => typ_str &
 	comp_ref_cstr id => (id_str,_) &
-	Util.list_map(inst_dims,int_string) => dim_strs &
+	Util.list_map(inst_dims,dim_string) => dim_strs &
 	Util.string_delimit_list(dim_strs,", ") => dims_str &
 	Util.string_append_list([typ_str," ",id_str,";",
 				 " /* [",dims_str,"] */"]) 
@@ -830,7 +838,9 @@ relation generate_alloc_outvar : (DAE.Element,string,int) => (CFunction,int) =
 	is_first_in_array id => true &
 	dae_type_str (typ,is_a) => typ_str &
 	comp_ref_cstr id => (cref_str,_) &
-	Util.list_map(inst_dims,int_string) => dim_strs &
+	generate_size_subscripts(inst_dims,tnr) => (cfn1,dim_strs,tnr1) &
+	c_move_statements_to_inits cfn1 => cfn1' &
+
 	list_length dim_strs => ndims &
 	int_string ndims => ndims_str &
 	Util.string_delimit_list(dim_strs,", ") => dims_str &
@@ -839,18 +849,38 @@ relation generate_alloc_outvar : (DAE.Element,string,int) => (CFunction,int) =
 			ndims_str,", ",dims_str,");"])
 	  => alloc_str &
 	  
-	  c_add_inits(c_empty_function,[alloc_str]) => cfn' &
-	Util.if (is_a,cfn',c_empty_function) => cfn
+	  c_add_inits(cfn1',[alloc_str]) => cfn' &
+	Util.if (is_a,cfn',cfn1') => cfn
 	-----------
 	generate_alloc_outvar(DAE.VAR(id, vk, vd, typ, e,inst_dims),
 			      prefix,
 			      tnr) 
-	  => (cfn,tnr)
+	  => (cfn,tnr1)
 
-  axiom	generate_alloc_outvar (_,_,tnr) => (c_empty_function,tnr)
+  rule	not DAE.is_var e
+	-------------
+	generate_alloc_outvar (e,_,tnr) => (c_empty_function,tnr)
 
 end
 
+relation generate_size_subscripts : (Exp.Subscript list,int)
+	  => (CFunction,string list,int) =
+
+  axiom	generate_size_subscripts ([],tnr) => (c_empty_function,[],tnr)
+
+  rule	generate_expression (e,tnr) => (cfn1,var1,tnr1) &
+	generate_size_subscripts (r,tnr1) => (cfn2,vars2,tnr2) &
+	c_merge_fn(cfn1,cfn2) => cfn
+	-------
+	generate_size_subscripts (Exp.INDEX(e)::r,tnr)
+	  => (cfn,var1::vars2,tnr2)
+
+  rule	print "# generate_size_subscripts failed\n" & print " - [" &
+	Dump.print_list(subs,Exp.print_subscript,", ") & print "]\n"
+	-----------
+	generate_size_subscripts(subs,_) => fail
+
+end
 relation prefix_cr : (string, Exp.ComponentRef) => Exp.ComponentRef =
 
   axiom	prefix_cr (prf,cref) 
@@ -1171,6 +1201,30 @@ relation generate_vars : (DAE.Element list,DAE.Element => (),int)
 	
 end
 
+relation generate_var_decls : (DAE.Element list,DAE.Element => (),int) 
+	  => (CFunction,int) =
+
+  axiom	generate_var_decls ([],_,tnr) => (c_empty_function,tnr)
+	
+  rule	verify first &
+	generate_var_decl (first,tnr)  => (cfn1,tnr1) & 
+	generate_var_decls (rest,verify,tnr1)  => (cfn2,tnr2) &
+	c_merge_fn(cfn1,cfn2) => cfn
+	--------------------
+	generate_var_decls (first :: rest,verify,tnr)  => (cfn,tnr2) 
+
+  rule	not verify first &
+	generate_var_decls (rest,verify,tnr)  => (cfn,tnr2)
+	--------------------
+	generate_var_decls (first :: rest,verify,tnr)  => (cfn,tnr2) 
+
+  rule	print "# generate_var_decls failed\n"
+	---------------------------------
+	generate_var_decls (_,_,_) => fail
+	
+end
+
+
 
 relation generate_var : (DAE.Element,int) => (CFunction,int) =
 (*
@@ -1193,7 +1247,10 @@ relation generate_var : (DAE.Element,int) => (CFunction,int) =
 	is_first_in_array id => true &
 	dae_type_str (typ,is_a) => typ_str &
 	comp_ref_cstr id => (cref_str,_) &
-	Util.list_map(inst_dims,int_string) => dim_strs &
+	generate_size_subscripts(inst_dims,tnr) => (cfn1',vars1,tnr1) &
+	c_move_statements_to_inits cfn1' => cfn1 &
+	Util.string_delimit_list(vars1,", ") => dimvars_str &
+	Util.list_map(inst_dims,dim_string) => dim_strs &
 	Util.string_delimit_list(dim_strs,", ") => dims_str &
 	Util.string_append_list([" /* [",dims_str,"] */"]) => dim_comment &
 	Util.if (is_a,dim_comment,"") => dim_comment' &
@@ -1201,8 +1258,8 @@ relation generate_var : (DAE.Element,int) => (CFunction,int) =
 	int_string ndims => ndims_str &
 	Util.string_append_list([typ_str," ",cref_str,";",dim_comment'])=> decl_str &
 	Util.string_append_list(["alloc_",typ_str,"(&",cref_str,", ",
-			ndims_str,", ",dims_str,");"]) => alloc_str &
-	c_add_variables(c_empty_function,[decl_str]) => cfn' &
+			ndims_str,", ",dimvars_str,");"]) => alloc_str &
+	c_add_variables(cfn1,[decl_str]) => cfn' &
 	c_add_inits(cfn',[alloc_str]) => cfn'' &
 	Util.if (is_a,cfn'',cfn') => cfn
 	----------------------------------------------------
@@ -1212,7 +1269,10 @@ relation generate_var : (DAE.Element,int) => (CFunction,int) =
 	is_first_in_array id => true &
 	dae_type_str (typ,is_a) => typ_str &
 	comp_ref_cstr id => (cref_str,_) &
-	Util.list_map(inst_dims,int_string) => dim_strs &
+	generate_size_subscripts(inst_dims,tnr) => (cfn1',vars1,tnr1) &
+	c_move_statements_to_inits cfn1' => cfn1 &
+	Util.string_delimit_list(vars1,", ") => dimvars_str &
+	Util.list_map(inst_dims,dim_string) => dim_strs &
 	Util.string_delimit_list(dim_strs,", ") => dims_str &
 	Util.string_append_list([" /* [",dims_str,"] */"]) => dim_comment &
 	Util.if (is_a,dim_comment,"") => dim_comment' &
@@ -1221,8 +1281,8 @@ relation generate_var : (DAE.Element,int) => (CFunction,int) =
 	Util.string_append_list([typ_str," ",cref_str,";",dim_comment'])
 	  => decl_str &
 	Util.string_append_list(["alloc_",typ_str,"(&",cref_str,", ",
-			ndims_str,", ",dims_str,");"]) => alloc_str &
-	c_add_variables(c_empty_function,[decl_str]) => cfn' &
+			ndims_str,", ",dimvars_str,");"]) => alloc_str &
+	c_add_variables(cfn1,[decl_str]) => cfn' &
 	c_add_inits(cfn',[alloc_str]) => cfn'' &
 	Util.if (is_a,cfn'',cfn') => cfn &
 	print "# default value not implemented yet: " &
@@ -1252,7 +1312,63 @@ relation generate_var : (DAE.Element,int) => (CFunction,int) =
 	generate_var (e,_) => fail
 end
 
+relation generate_var_decl : (DAE.Element,int) => (CFunction,int) =
 
+  rule	is_first_in_array id => false
+	-----------------------------
+	generate_var_decl(DAE.VAR(id,_,_,_,_,_),tnr) => (c_empty_function,tnr)
+
+  rule	is_array id => is_a &
+	is_first_in_array id => true &
+	dae_type_str (typ,is_a) => typ_str &
+	comp_ref_cstr id => (cref_str,_) &
+	Util.list_map(inst_dims,dim_string) => dim_strs &
+	Util.string_delimit_list(dim_strs,", ") => dims_str &
+	Util.string_append_list([" /* [",dims_str,"] */"]) => dim_comment &
+	Util.if (is_a,dim_comment,"") => dim_comment' &
+	list_length dim_strs => ndims &
+	int_string ndims => ndims_str &
+	Util.string_append_list([typ_str," ",cref_str,";",dim_comment'])=> decl_str &
+	
+	c_add_variables(c_empty_function,[decl_str]) => cfn
+	----------------------------------------------------
+	generate_var_decl(DAE.VAR(id, vk, vd, typ, NONE,inst_dims),tnr) => (cfn,tnr)
+
+  rule	is_array id => is_a &
+	is_first_in_array id => true &
+	dae_type_str (typ,is_a) => typ_str &
+	comp_ref_cstr id => (cref_str,_) &
+	Util.list_map(inst_dims,dim_string) => dim_strs &
+	Util.string_delimit_list(dim_strs,", ") => dims_str &
+	Util.string_append_list([" /* [",dims_str,"] */"]) => dim_comment &
+	Util.if (is_a,dim_comment,"") => dim_comment' &
+	list_length dim_strs => ndims &
+	int_string ndims => ndims_str &
+	Util.string_append_list([typ_str," ",cref_str,";",dim_comment'])
+	  => decl_str &
+	c_add_variables(c_empty_function,[decl_str]) => cfn &
+	print "# default value not implemented yet: " &
+	Exp.print_exp e & print "\n"
+	-----------
+	generate_var_decl(DAE.VAR(id, vk, vd, typ, SOME(e),inst_dims),tnr) 
+	  => (cfn,tnr)
+
+	
+  rule	print "# generate_var failed\n  " &
+	DAE.dump_debug_element e & print "\n"
+	-----------------------------------
+	generate_var_decl (e,_) => fail
+end
+
+relation dim_string : Exp.Subscript => string =
+
+  rule	int_string i => str
+	---------------------
+	dim_string Exp.INDEX(Exp.ICONST(i)) => str
+
+  axiom	dim_string _ => ":"
+
+end
 relation is_var_q : DAE.Element => () =
 
   rule	generate_var_q(vk) &
@@ -1479,9 +1595,11 @@ relation generate_expression : (Exp.Exp, int) => (CFunction,string,int) =
 
 	c_add_statements(cfn2,[stmt]) => cfn &
 
-	Util.string_append_list([tvar,".",ret_type,"_1"]) => var
+	Util.string_append_list([tvar,".",ret_type,"_1"]) => var_not_bi &
+	Util.if(builtin,tvar,var_not_bi) => var
 	-------------------------
-	generate_expression(Exp.CALL(fn,args,false),tnr) => (cfn,var,tnr2)
+	generate_expression(Exp.CALL(fn,args,false,builtin),tnr) 
+	  => (cfn,var,tnr2)
 
 rule	generate_expressions(args,tnr) => (cfn1,vars1,tnr1) &
 	generate_return_type fn => ret_type &
@@ -1494,7 +1612,8 @@ rule	generate_expressions(args,tnr) => (cfn1,vars1,tnr1) &
 
 	c_add_statements(cfn2,[stmt]) => cfn
 	-------------------------
-	generate_expression(Exp.CALL(fn,args,true),tnr) => (cfn,tvar,tnr2)
+	generate_expression(Exp.CALL(fn,args,true,builtin),tnr) 
+	  => (cfn,tvar,tnr2)
 
   rule	generate_expressions(elist,tnr) => (cfn1,vars1,tnr1) &
 	list_length vars1 => nvars &
@@ -1503,9 +1622,12 @@ rule	generate_expressions(args,tnr) => (cfn1,vars1,tnr1) &
 	exp_short_type_str t => short_type_str &
 	generate_temp_decl(array_type_str,tnr1) => (tdecl,tvar,tnr2) &
 	Util.if(a,"","scalar_") => scalar &
-	Util.string_delimit_list (vars1, ", ") => args_str &
+	Util.if(a,"&","") => scalar_ref &
+	string_append(", ",scalar_ref) => scalar_delimit &
+	Util.string_delimit_list (vars1, scalar_delimit) => args_str &
 	Util.string_append_list ["array_",scalar,array_type_str,"(&",
-				 tvar,", ",nvars_str,", ",args_str,");"
+				 tvar,", ",nvars_str,", ",
+				 scalar_ref,args_str,");"
 				 ] => stmt &
 	c_add_variables(cfn1,[tdecl]) => cfn' &
 	c_add_statements(cfn',[stmt]) => cfn
@@ -1832,11 +1954,16 @@ end
 relation generate_scalar_lhs_cref : (Exp.Type, Exp.ComponentRef, int)
 	  => (CFunction, string, int) =
 
-  rule	Debug.fprintln("gcge","generating cref ccode") &
-	ident_cstr id => cid
+  rule	comp_ref_cstr cref => (cref_str,[])
+	--------------------
+	generate_scalar_lhs_cref(t,cref,tnr)
+	  => (c_empty_function,cref_str,tnr)
+
+  rule	comp_ref_cstr cref => (cref_str,subs) &
+	generate_scalar_rhs_cref(cref_str,t,subs,tnr) => (cfn,var,tnr')
 	--------------------
-	generate_scalar_lhs_cref(_,Exp.CREF_IDENT(id,[]),tnr)
-	  => (c_empty_function,cid,tnr)
+	generate_scalar_lhs_cref(t,cref,tnr)
+	  => (cfn,var,tnr')
 
   rule	Debug.fprintln("gcge","generating cref ccode") &
 	generate_indices(idx,tnr) => (cfn1,idxs1,tnr1) &
@@ -2281,7 +2408,7 @@ relation generate_matrix : (Exp.Type, int, (Exp.Exp*bool) list list, int)
 	list_length(vars2) => n &
 	int_string n => n_str &
 	generate_temp_decl(array_type_str,tnr2) => (tdecl,tvar,tnr3) &
-	Util.string_append_list(["concatenate_",array_type_str,"(1, &",
+	Util.string_append_list(["cat_alloc_",array_type_str,"(1, &",
 				 tvar,", ",n_str,
 				 ", &",args_str,");"]) => stmt &
 
@@ -2323,7 +2450,7 @@ relation concatenate_matrix_row : (Exp.Type, string list, int)
 	list_length(vars) => n &
 	int_string n => n_str &
 	generate_temp_decl(array_type_str,tnr) => (tdecl,tvar,tnr1) &
-	Util.string_append_list(["concatenate_",array_type_str,"(2, &",
+	Util.string_append_list(["cat_alloc_",array_type_str,"(2, &",
 				 tvar,", ",n_str,
 				 ", &",args_str,");"]) => stmt &
 
@@ -2398,7 +2525,7 @@ relation generate_read_call_write : (string,
 	c_add_inits(cfn1,["PRE_VARIABLES",
 			       out_decl]) => cfn1' &
 	(*generate_vars(outvars,is_rcw_output,1) => (cfn2,tnr1) &*)
-	generate_vars(invars,is_rcw_input,1) => (cfn3,tnr2) &
+	generate_var_decls(invars,is_rcw_input,1) => (cfn3,tnr2) &
 	c_add_statements(cfn3,["PRE_OPEN_INFILE"]) => cfn3' &
 	invar_names invars => in_names &
 	Util.string_delimit_list(in_names,", ") => in_args &
diff --git a/modeq/dae.rml b/modeq/dae.rml
index 92683f2dfb8..5b748a2bb23 100644
--- a/modeq/dae.rml
+++ b/modeq/dae.rml
@@ -22,7 +22,7 @@ module DAE:
   with "staticexp.rml"
 
   type Ident = string
-  type InstDims = int list
+  type InstDims = Exp.Subscript list
 
   datatype VarKind = VARIABLE | DISCRETE | PARAM | CONST
 
diff --git a/modeq/exp.rml b/modeq/exp.rml
index 1a4ab550617..c9cde50f9dc 100644
--- a/modeq/exp.rml
+++ b/modeq/exp.rml
@@ -42,7 +42,7 @@ module Exp:
 	       | LUNARY of Operator * Exp
 	       | RELATION of Exp * Operator * Exp
 	       | IFEXP of Exp * Exp * Exp
-	       | CALL of Absyn.Path * Exp list * bool (* Function call *)
+	       | CALL of Absyn.Path * Exp list * bool * bool (* Function call *)
 	       | ARRAY of Type * bool * Exp list
 	       | MATRIX of Type * int * (Exp*bool) list list
 	       | RANGE of Type * Exp * Exp option * Exp
@@ -440,7 +440,7 @@ relation print_exp2 : (Exp,int) => () =
   rule	Absyn.path_string(fcn) => fs &
 	print fs & print "(" & print_list(args,print_exp,",") & print ")"
 	---------------------------------------------
-	print_exp2(CALL(fcn, args,_),_)
+	print_exp2(CALL(fcn, args,_,_),_)
 
   rule	(* print "This an array: " & *)
 	print "[" &
@@ -955,7 +955,7 @@ relation print_exp2_str : (Exp,int) => string =
 	string_append(s, argstr) => s' &
 	string_append(s', ")") => s''
 	---------------------------------------------
-	print_exp2_str(CALL(fcn, args,_),_) => s''
+	print_exp2_str(CALL(fcn, args,_,_),_) => s''
 
   rule	print_list_str(es, print_exp_str, ",") => s &
 	string_append ("[",s) => s' &
diff --git a/modeq/inst.rml b/modeq/inst.rml
index 10d470a3f9a..184a309ac06 100644
--- a/modeq/inst.rml
+++ b/modeq/inst.rml
@@ -23,7 +23,10 @@ module Inst:
   with "prefix.rml"
   with "types.rml"
 
-  type InstDims = int list
+  type InstDims = Exp.Subscript list
+
+  datatype DimExp = DIMINT of int
+		  | DIMEXP of Exp.Subscript * Exp.Exp option
 
   relation instantiate: SCode.Program => DAE.DAElist
 
@@ -552,7 +555,7 @@ relation inst_var : (Env.Env,
 		     Ident,
 		     SCode.Class,
 		     SCode.Attributes,
-		     int list, 
+		     DimExp list, 
 		     int list,
 		     InstDims)
 	  => (DAE.Element list,Connect.Sets,Types.Type) =
@@ -594,12 +597,12 @@ relation inst_var : (Env.Env,
 
 
 
-  rule	(* for debugging.
-	print "= inst_array mod: " & print n & Mod.print_mod mod & print "\n" & *)
-	list_append(inst_dims,[dim]) => inst_dims' &
+  rule	inst_dim_exp dim => dime &
+	list_append(inst_dims,[dime]) => inst_dims' &
 	inst_array(env,mod,pre,csets,n,(cl,attr),1,dim,dims,idxs,inst_dims')
 	  => (dae, csets', ty) &
-	Types.lift_array(ty,SOME(dim)) => ty'
+	inst_dim_type dim => dimt &
+	Types.lift_array(ty,dimt) => ty'
 	-------------------------------
 	inst_var(env,mod,pre,csets,n,cl,attr,dim::dims,idxs,inst_dims)
           => (dae,csets',ty')
@@ -610,6 +613,20 @@ relation inst_var : (Env.Env,
 	
 end
 
+relation inst_dim_exp : DimExp => Exp.Subscript =
+
+  axiom	inst_dim_exp DIMINT(i) => Exp.INDEX(Exp.ICONST(i))
+  axiom	inst_dim_exp DIMEXP(e,_) => e
+
+end
+
+relation inst_dim_type : DimExp => int option =
+
+  axiom	inst_dim_type DIMINT(i) => SOME(i)
+  axiom	inst_dim_type DIMEXP(_,_) => NONE
+
+end
+
 relation fix_direction : (DAE.Element list, Absyn.Direction)
 	  => DAE.Element list =
 
@@ -650,28 +667,34 @@ relation inst_array : (Env.Env,
 		       Ident,
 		       (SCode.Class*SCode.Attributes),
 		       int,
-		       int,
-		       int list,
+		       DimExp,
+		       DimExp list,
 		       int list,
 		       InstDims
 		       )
 	  => (DAE.Element list,Connect.Sets,Types.Type) =
 
+  rule	inst_var(env,mod,pre,csets,n,cl,attr,dims,i::idxs,inst_dims)
+	  => (dae,csets,ty)
+	-----------------
+	inst_array(env,mod,pre,csets,n,(cl,attr),i,DIMEXP(_,_),dims,idxs,inst_dims)
+	  => (dae,csets,ty)
+
   rule	int_gt(i,stop) => true
 	----------------------
-	inst_array(env,mod,pre,csets,n,(cl,attr),i,stop,dims,idxs,inst_dims)
+	inst_array(env,mod,pre,csets,n,(cl,attr),i,DIMINT(stop),dims,idxs,inst_dims)
 	  => ([], csets, Types.T_NOTYPE)
 
   rule	Mod.lookup_idx_modification(mod,i) => mod' &
 	inst_var(env,mod',pre,csets,n,cl,attr,dims,i::idxs,inst_dims)
 	  => (dae1,csets',ty) &
 	int_add(i,1) => i' &
-	inst_array(env,mod,pre,csets',n,(cl,attr),i',stop,dims,idxs,inst_dims)
+	inst_array(env,mod,pre,csets',n,(cl,attr),i',DIMINT(stop),dims,idxs,inst_dims)
 	  => (dae2, csets'',_) &
 
 	list_append(dae1,dae2) => dae
 	-----------------------------
-	inst_array(env,mod,pre,csets,n,(cl,attr),i,stop,dims,idxs,inst_dims)
+	inst_array(env,mod,pre,csets,n,(cl,attr),i,DIMINT(stop),dims,idxs,inst_dims)
           => (dae,csets'',ty)
 
   rule	print "- inst_array failed: " & print n & print "\n"
@@ -696,7 +719,7 @@ end
  **)
 
 relation elab_arraydim : (Env.Env, Absyn.ArrayDim, Mod.EqMod option)
-	  => int list =
+	  => DimExp list =
 
   rule	elab_arraydim_decl(env,ad) => dim &
 	complete_arraydim(dim) => dim'
@@ -734,7 +757,7 @@ end
  **)
 
 (*!ignorecode*)
-relation print_dim : (int option) list => () =
+relation print_dim : (DimExp option) list => () =
 
   rule	print ":"
 	---------
@@ -742,7 +765,11 @@ relation print_dim : (int option) list => () =
 
   rule	int_string x => s & print s
 	---------------------------
-	print_dim [SOME(x)]
+	print_dim [SOME(DIMINT(x))]
+
+  rule	Exp.print_subscript x
+	---------------------------
+	print_dim [SOME(DIMEXP(x,_))]
 
   rule	print ":," & print_dim xs
 	-------------------------
@@ -750,20 +777,24 @@ relation print_dim : (int option) list => () =
 
   rule	int_string x => s & print s & print "," & print_dim xs
 	------------------------------------------------
-	print_dim SOME(x)::xs
+	print_dim SOME(DIMINT(x))::xs
+
+rule	Exp.print_subscript x & print "," & print_dim xs
+	------------------------------------------------
+	print_dim SOME(DIMEXP(x,_))::xs
 
 end
 (*!includecode*)
 
 (** relation: elab_arraydim_decl
  **
- ** Given an `Absyj.ArrayDim', this relation evaluates all dimension
+ ** Given an `Absyn.ArrayDim', this relation evaluates all dimension
  ** size specifications, creating a list of (optional) integers.  When
  ** the array dimension size is specified as `:', the result will
  ** contain `NONE'.
  **)
 
-relation elab_arraydim_decl : (Env.Env, Absyn.ArrayDim) => (int option) list =
+relation elab_arraydim_decl : (Env.Env, Absyn.ArrayDim) => (DimExp option) list =
 
   axiom	elab_arraydim_decl(_,[]) => []
 
@@ -776,14 +807,13 @@ relation elab_arraydim_decl : (Env.Env, Absyn.ArrayDim) => (int option) list =
 	Static.ceval(env,e) => Values.INTEGER(i) &
 	elab_arraydim_decl(env,ds) => l
 	-------------------------------------------
-	elab_arraydim_decl(env,Absyn.SUBSCRIPT(d)::ds) => SOME(i)::l
+	elab_arraydim_decl(env,Absyn.SUBSCRIPT(d)::ds) => SOME(DIMINT(i))::l
 
-  rule	Static.elab_exp(env, d)
-	  => (e,Static.PROP(Types.T_INTEGER,false)) &
-	print "# Variable array sizes are not allowed\n" &
-	print "    expression: " & Exp.print_exp e & print "\n"
+  rule	Static.elab_exp(env, d) => (e,Static.PROP(Types.T_INTEGER,false)) &
+	elab_arraydim_decl(env,ds) => l
 	-------------------------------------------------------
-	elab_arraydim_decl(env,Absyn.SUBSCRIPT(d)::ds) => fail
+	elab_arraydim_decl(env,Absyn.SUBSCRIPT(d)::ds) 
+	  => SOME(DIMEXP(Exp.INDEX(e),NONE))::l
 
   rule	Static.elab_exp(env, d)
 	  => (e,Static.PROP(t,_)) &
@@ -809,7 +839,7 @@ end
  ** specified array dimension sizes.
  **)
 
-relation complete_arraydim : (int option) list => int list =
+relation complete_arraydim : (DimExp option) list => DimExp list =
 
   axiom	complete_arraydim [] => []
 
@@ -817,6 +847,10 @@ relation complete_arraydim : (int option) list => int list =
 	---------------------------
 	complete_arraydim SOME(x)::xs => x::xs'
 
+  rule	complete_arraydim xs => xs'
+	---------------------------
+	complete_arraydim NONE::xs => DIMEXP(Exp.WHOLEDIM,NONE)::xs'
+
 end
 
 (** relation: compatible_arraydim
@@ -829,8 +863,8 @@ end
  ** a dimension size, they have to specify the same size.
  **)
 
-relation compatible_arraydim : ((int option) list,(int option) list)
-	  => int list =
+relation compatible_arraydim : ((DimExp option) list,(DimExp option) list)
+	  => DimExp list =
 
   axiom	compatible_arraydim([],[]) => []
 
@@ -845,7 +879,35 @@ relation compatible_arraydim : ((int option) list,(int option) list)
   rule	x = y &
 	compatible_arraydim(xs,ys) => l
 	-------------------------------
-	compatible_arraydim (SOME(x)::xs,SOME(y)::ys) => x::l
+	compatible_arraydim (SOME(DIMINT(x))::xs,SOME(DIMINT(y))::ys) 
+	  => DIMINT(x)::l
+
+  rule	arraydim_condition(DIMEXP(Exp.INDEX(Exp.ICONST(x)),NONE),DIMEXP(y,e))
+	  => de &
+	compatible_arraydim(xs,ys) => l
+	-------------------------------
+	compatible_arraydim (SOME(DIMINT(x))::xs,SOME(DIMEXP(y,e))::ys)
+	  => de::l
+
+  rule	arraydim_condition(DIMEXP(Exp.INDEX(Exp.ICONST(y)),NONE),DIMEXP(x,e))
+	  => de &
+	compatible_arraydim(xs,ys) => l
+	-------------------------------
+	compatible_arraydim (SOME(DIMEXP(x,e))::xs,SOME(DIMINT(y))::ys) 
+	  => de::l
+
+  rule	arraydim_condition(DIMEXP(x,e1),DIMEXP(y,e2))
+	  => de &
+	compatible_arraydim(xs,ys) => l
+	-------------------------------
+	compatible_arraydim (SOME(DIMEXP(x,e1))::xs,SOME(DIMEXP(y,e2))::ys)
+	  => de::l
+
+
+  rule	compatible_arraydim(xs,ys) => l
+	--------------------------------
+	compatible_arraydim (NONE::xs,NONE::ys) 
+	  => DIMEXP(Exp.WHOLEDIM,NONE)::l
 
   rule	print "- compatible_arraydim failed\n"
 	--------------------------------------
@@ -853,6 +915,11 @@ relation compatible_arraydim : ((int option) list,(int option) list)
 
 end
 
+relation arraydim_condition : (DimExp, DimExp) => DimExp =
+	
+  axiom arraydim_condition (de,_) => de
+
+end
 (** relation: elab_arraydim_type
  **
  ** Find out the dimension sizes of a type.  The second argument is
@@ -861,11 +928,17 @@ end
  **)
 
 relation elab_arraydim_type : (Types.Type, Absyn.ArrayDim)
-	  => int option list =
+	  => DimExp option list =
 
   rule	elab_arraydim_type(t,ad) => l
 	---------------------------
-	elab_arraydim_type(Types.T_ARRAY(Types.DIM(i),t), _::ad) => i::l
+	elab_arraydim_type(Types.T_ARRAY(Types.DIM(NONE),t), _::ad) 
+	  => NONE::l
+	
+  rule	elab_arraydim_type(t,ad) => l
+	---------------------------
+	elab_arraydim_type(Types.T_ARRAY(Types.DIM(SOME(i)),t), _::ad) 
+	  => SOME(DIMINT(i))::l
 	
  axiom elab_arraydim_type(_,[]) => []
 
diff --git a/modeq/modutil.rml b/modeq/modutil.rml
index 4ca3177e9e1..9bda8e90b1b 100644
--- a/modeq/modutil.rml
+++ b/modeq/modutil.rml
@@ -95,8 +95,8 @@ relation string_prefix_component_ref : (string, (Exp.ComponentRef, 'b)
 
   rule	string_prefix_component_refs (str, r, rarg, el) => el'
 	--------------------------------------------
-	string_prefix_component_ref (str, r, rarg, Exp.CALL(p, el,b)) 
-	  => Exp.CALL(p, el',b)
+	string_prefix_component_ref (str, r, rarg, Exp.CALL(p, el,b,bi)) 
+	  => Exp.CALL(p, el',b,bi)
 
   rule	string_prefix_component_refs (str, r, rarg, el) => el'
 	--------------------------------------------
@@ -297,7 +297,7 @@ relation print_exp_no_funcall : Exp.Exp => () =
   rule	path_string(fcn) => fs &
 	print fs
 	--------
-	print_exp_no_funcall Exp.CALL(fcn, args,_)
+	print_exp_no_funcall Exp.CALL(fcn, args,_,_)
 
   rule	Exp.print_exp e
 	---------------
diff --git a/modeq/prefix.rml b/modeq/prefix.rml
index ad4bf1565c6..002fea3bf8a 100644
--- a/modeq/prefix.rml
+++ b/modeq/prefix.rml
@@ -235,7 +235,7 @@ relation prefix_exp: (Env.Env,Exp.Exp,Prefix) => Exp.Exp =
 
   rule	prefix_exp_list(env,es,p) => es'
 	-----------------------
-	prefix_exp(env,Exp.CALL(f,es,b),p) => Exp.CALL(f,es',b)
+	prefix_exp(env,Exp.CALL(f,es,b,bi),p) => Exp.CALL(f,es',b,bi)
 
 	(**)
   axiom	prefix_exp(env,Exp.ARRAY(t,a,[]),p) => Exp.ARRAY(t,a,[])
diff --git a/modeq/staticexp.rml b/modeq/staticexp.rml
index 267b32fffd4..9f5200a79ba 100644
--- a/modeq/staticexp.rml
+++ b/modeq/staticexp.rml
@@ -540,6 +540,29 @@ relation elab_builtin_size : (Env.Env, Absyn.Exp list) => (Exp.Exp, Properties)
 	------------------------------------------------------
 	elab_builtin_size (env, [arraycr,ind]) => (exp, prop)
 
+  rule	elab_exp (env,arraycr) => (crefe as Exp.CREF(cr,crt), crprop) &
+	Lookup.lookup_var (env, cr) => (attr, ty, bnd) &
+	Types.array_element_type ty => Types.T_INTEGER &
+	elab_exp (env,ind) => (indexp, PROP(indty, ind_const)) &
+	let exp = Exp.CALL(Absyn.IDENT("size_integer_array"),
+			   [crefe,indexp],false,true) &
+	let prop = PROP(Types.T_INTEGER,false)
+	------------------------------------------------------
+	elab_builtin_size (env, [arraycr,ind]) 
+	  => (exp, 
+	      prop)
+
+ rule	elab_exp (env,arraycr) => (crefe as Exp.CREF(cr,crt), crprop) &
+	Lookup.lookup_var (env, cr) => (attr, ty, bnd) &
+	Types.array_element_type ty => Types.T_REAL &
+	elab_exp (env,ind) => (indexp, PROP(indty, ind_const)) &
+	let exp = Exp.CALL(Absyn.IDENT("size_of_dimension_real_array"),
+			   [crefe,indexp],false,true) &
+	let prop = PROP(Types.T_INTEGER,false)
+	------------------------------------------------------
+	elab_builtin_size (env, [arraycr,ind]) 
+	  => (exp, prop)
+
   rule	print "#-- elab_builtin_size: Couldn't elaborate size()\n" &
 	print "#-- Wrong args or non-constant dimension\n"
 	----------------------------------------------------------
@@ -557,10 +580,6 @@ relation elab_builtin_size_2 : (Env.Env, Types.Type, int) => (Exp.Exp, Propertie
 	--------------------------------------------------
 	elab_builtin_size_2 (env, Types.T_ARRAY(_, ty), ind) => (exp, prop)
 
-  rule	print "#-- elab_builtin_size_2: Couldn't elaborate size()\n" &
-	print "#-- Maybe not an array type or not a component reference\n" 
-	----------------------------------------------------------
-	elab_builtin_size_2 (env, crexp, ind) => fail
 end
 
 
@@ -737,7 +756,7 @@ relation elab_call_args : (Env.Env, Absyn.Path, Absyn.Exp list)
 	elab_call_args(env,fn,args) 
 	  => (Exp.CALL(fn,args'), PROP_TUPLE(Types.T_TUPLE(types), const)) 
  *)
-	elab_call_args(env,fn,args) => (Exp.CALL(fn,args',tuple), prop )
+	elab_call_args(env,fn,args) => (Exp.CALL(fn,args',tuple,false), prop )
 
 	(* 
 	 Functions that returns just one argument should not return a
@@ -771,7 +790,7 @@ relation elab_call_args : (Env.Env, Absyn.Path, Absyn.Exp list)
 (*PR.	elab_input_args(env, args, params) => (args',c)  *)
 	Debug.fprintln ("sei", "elab_call_args succeeded")
 	-----------------------------------------------
-	elab_call_args (env,fn,args) => (Exp.CALL(fn,args',tuple), PROP(restype, c))
+	elab_call_args (env,fn,args) => (Exp.CALL(fn,args',tuple,false), PROP(restype, c))
 
 
 (*  rule	not Lookup.lookup_type(env,fn) => _ &
@@ -1448,7 +1467,7 @@ relation ceval : (Env.Env, Exp.Exp) => Values.Value =
   rule	print "# Can't call functions at compile time\n" &
 	print "    expression: " & Exp.print_exp e & print "\n"
 	-------------------------------------------------------
-	ceval (env, e as Exp.CALL(_,_,_)) => fail
+	ceval (env, e as Exp.CALL(_,_,_,_)) => fail
 
 	(**  Numerical *)
 
diff --git a/modeq/test_codegen/Makefile b/modeq/test_codegen/Makefile
index 720c3cf63fd..cee7a3e62f8 100644
--- a/modeq/test_codegen/Makefile
+++ b/modeq/test_codegen/Makefile
@@ -7,6 +7,11 @@ CFLAGS= -Wall -ansi -pedantic -I../../c_runtime
 
 LDFLAGS= -L../../c_runtime 
 
+CDIR = csrc
+ODIR = obj
+BDIR = bin
+
+
 MOFILES = \
 	algorithm_for1.mo \
 	algorithm_if1.mo \
diff --git a/modeq/test_codegen/return_multiple_record.mo b/modeq/test_codegen/return_multiple_record.mo
index 94f825ff80c..e5ffc97bc5e 100644
--- a/modeq/test_codegen/return_multiple_record.mo
+++ b/modeq/test_codegen/return_multiple_record.mo
@@ -3,7 +3,7 @@ record rec
   Integer i;
 end rec;
 
-function fn
+function return_multiple_record
   output rec r1;
   output rec r2;
 algorithm
@@ -12,7 +12,7 @@ algorithm
 
   r2.r := 1.0;
   r2.i := 1;
-end fn;
+end return_multiple_record;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_multiple_record_array.mo b/modeq/test_codegen/return_multiple_record_array.mo
index b78e0283339..30f27bde382 100644
--- a/modeq/test_codegen/return_multiple_record_array.mo
+++ b/modeq/test_codegen/return_multiple_record_array.mo
@@ -3,7 +3,7 @@ record rec
   Integer i;
 end rec;
 
-function fn
+function return_multiple_record_array
   output rec[2] r1;
   output rec[2] r2;
 algorithm
@@ -12,7 +12,7 @@ algorithm
 
   r2.r := {1.0,2.0};
   r2.i := {1,2};
-end fn;
+end return_multiple_record_array;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_multiple_scalar.mo b/modeq/test_codegen/return_multiple_scalar.mo
index 891f7a71703..1de3a035c68 100644
--- a/modeq/test_codegen/return_multiple_scalar.mo
+++ b/modeq/test_codegen/return_multiple_scalar.mo
@@ -1,12 +1,12 @@
 
 
-function fn
+function return_multiple_scalar
   output Real r;
   output Integer i;
 algorithm
   r := 1.0;
   i := 1;
-end fn;
+end return_multiple_scalar;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_multiple_scalar_array.mo b/modeq/test_codegen/return_multiple_scalar_array.mo
index 0d0a09a82c0..9ef350c5243 100644
--- a/modeq/test_codegen/return_multiple_scalar_array.mo
+++ b/modeq/test_codegen/return_multiple_scalar_array.mo
@@ -1,12 +1,12 @@
 
 
-function fn
+function return_multiple_scalar_array
   output Real[2] r;
-  outpur Integer[2] i;
+  output Integer[2] i;
 algorithm
   r := {1.0,2.0};
-  i := [1,2};
-end fn;
+  i := {1,2};
+end return_multiple_scalar_array;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_record.mo b/modeq/test_codegen/return_record.mo
index 07df0f0108c..c922bc0ee07 100644
--- a/modeq/test_codegen/return_record.mo
+++ b/modeq/test_codegen/return_record.mo
@@ -4,12 +4,12 @@ record rec
   Integer i;
 end rec;
 
-function fn
+function return_record
   output rec r;
 algorithm
   r.r := 1.0;
   r.i := 2;
-end fn;
+end return_record;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_record_array.mo b/modeq/test_codegen/return_record_array.mo
index 837e6d45c41..6d2a78bea89 100644
--- a/modeq/test_codegen/return_record_array.mo
+++ b/modeq/test_codegen/return_record_array.mo
@@ -3,11 +3,11 @@ record rec
   Real r;
 end rec;
 
-function fn
+function return_record_array
   output rec[2] r;
 algorithm
 
-end fn;
+end return_record_array;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_scalar.mo b/modeq/test_codegen/return_scalar.mo
index f6b1ea6d5a9..5d001ffe52f 100644
--- a/modeq/test_codegen/return_scalar.mo
+++ b/modeq/test_codegen/return_scalar.mo
@@ -1,9 +1,9 @@
 
-function fn
+function return_scalar
   output Real r;
 algorithm
   r := 1.0;
-end fn;
+end return_scalar;
 
 model mo
 end mo;
diff --git a/modeq/test_codegen/return_scalar_array.mo b/modeq/test_codegen/return_scalar_array.mo
index 158873a09dd..ba44d2a9f3f 100644
--- a/modeq/test_codegen/return_scalar_array.mo
+++ b/modeq/test_codegen/return_scalar_array.mo
@@ -1,9 +1,9 @@
 
-function fn
+function return_scalar_array
   output Real[2] r;
 algorithm
   r := {1.0, 2.0};
-end fn;
+end return_scalar_array;
 
 model mo
 end mo;