- not working yet, reverting.

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

Author: adrpo

Compiler/FrontEnd/Inst.mo

@@ -8220,27 +8220,22 @@ algorithm
      // e.g. Point p => Real p[3]; These must be handled separately since even if they do not
      // appear to be an array, they can. Therefore we need to collect
       // the full dimensionality and call instVar2
-    case (cache,env,ih,store,ci_state,mod,pre,n,(cl as SCode.CLASS(name = id)),attr as SCode.ATTR(variability = vt),pf,_,idxs,inst_dims,impl,comment,_,graph,csets)
+    case (cache,env,ih,store,ci_state,mod,pre,n,(cl as SCode.CLASS(name = id)),attr as SCode.ATTR(variability = vt),pf,dims,idxs,inst_dims,impl,comment,_,graph,csets)
       equation
         // Collect dimensions
         p1 = Absyn.IDENT(n);
         p1 = PrefixUtil.prefixPath(p1,pre);
         str = Absyn.pathString(p1);
         Error.updateCurrentComponent(str,info);
         (cache, dims as (_ :: _),cl,type_mods) = getUsertypeDimensions(cache, env, ih, mod, pre, cl, inst_dims, impl);
-        
-        type_mods = Mod.addEachIfNeeded(type_mods, dims);
-        mod = Mod.addEachIfNeeded(mod, inDimensionLst);
-        
-        dims = listAppend(inDimensionLst, dims);
         mod = Mod.merge(mod, type_mods, env, pre);
 
         attr = propagateClassPrefix(attr,pre);
         (cache,compenv,ih,store,dae,csets,ty,graph) = 
           instVar2(cache,env,ih,store, ci_state, mod, pre, n, cl, attr,
             pf, dims, idxs, inst_dims, impl, comment, info, graph, csets);
         source = DAEUtil.createElementSource(info, Env.getEnvPath(env), PrefixUtil.prefixToCrefOpt(pre), NONE(), NONE());
-        (cache,dae) = addArrayVarEquation(cache, env, ih, ci_state, dae, ty, mod, NFInstUtil.toConst(vt), pre, n, source);
+        (cache,dae) = addArrayVarEquation(cache,env,ih,ci_state, dae, ty, mod, NFInstUtil.toConst(vt), pre, n, source);
         cache = addRecordConstructorFunction(cache,Types.arrayElementType(ty));
         Error.updateCurrentComponent("",Absyn.dummyInfo);
       then
@@ -9192,52 +9187,54 @@ algorithm
       list<SCode.Element> els;
       SCode.Path path;
 
-    case (cache,_,_,_,_,cl as SCode.CLASS(name = "Real"),_,_) then (cache,{},cl,DAE.NOMOD());
+    case (cache,_,_,_,_,cl as SCode.CLASS(name = "Real"),_,_) then (cache,{},cl,DAE.NOMOD());  /* impl */
     case (cache,_,_,_,_,cl as SCode.CLASS(name = "Integer"),_,_) then (cache,{},cl,DAE.NOMOD());
     case (cache,_,_,_,_,cl as SCode.CLASS(name = "String"),_,_) then (cache,{},cl,DAE.NOMOD());
     case (cache,_,_,_,_,cl as SCode.CLASS(name = "Boolean"),_,_) then (cache,{},cl,DAE.NOMOD());
 
     case (cache,_,_,_,_,cl as SCode.CLASS(restriction = SCode.R_RECORD(),
                                         classDef = SCode.PARTS(elementLst = _)),_,_) then (cache,{},cl,DAE.NOMOD());
 
-    //------------------------
-    // MetaModelica extension
-    case (cache, env, ih, _, pre, cl as SCode.CLASS(name = id, info=info,
+    /*------------------------*/
+    /* MetaModelica extension */
+    case (cache,env,ih,_,pre,cl as SCode.CLASS(name = id, info=info,
                                           classDef = SCode.DERIVED(Absyn.TCOMPLEX(Absyn.IDENT(_),_,arrayDim = ad),
                                                                    modifications = mod)),
-          dims, impl)
+          dims,impl)
       equation
-        true = Config.acceptMetaModelicaGrammar();
+        true=Config.acceptMetaModelicaGrammar();
         owncref = Absyn.CREF_IDENT(id,{});
         ad_1 = getOptionArraydim(ad);
-        (cache,dim1) = elabArraydim(cache, env, owncref, Absyn.IDENT("Integer"), ad_1, NONE(), impl, NONE(), true, false, pre, info, dims);
+        // Absyn.IDENT("Integer") used as a dummie
+        (cache,dim1) = elabArraydim(cache,env, owncref, Absyn.IDENT("Integer"), ad_1,NONE(), impl,NONE(),true, false,pre,info,dims);
       then 
-        (cache, dim1, cl, DAE.NOMOD());
+        (cache,dim1,cl,DAE.NOMOD());
 
     // Partial function definitions with no output - stefan
-    case (cache, env, ih, _, _,
+    case (cache,env,ih,_,_,
       cl as SCode.CLASS(name = id,restriction = SCode.R_FUNCTION(SCode.FR_NORMAL_FUNCTION()),
                         partialPrefix = SCode.PARTIAL()),_,_) 
       then 
         (cache,{},cl,DAE.NOMOD());
 
-    case (cache, env, ih, _, _,
+    case (cache,env,ih,_,_,
       SCode.CLASS(name = id,info=info,restriction = SCode.R_FUNCTION(SCode.FR_NORMAL_FUNCTION()),
                   partialPrefix = SCode.NOT_PARTIAL()),_,_)
       equation
         Error.addSourceMessage(Error.META_FUNCTION_TYPE_NO_PARTIAL_PREFIX, {id}, info);
       then fail();
 
-    // MetaModelica Uniontype. Added 2009-05-11 sjoelund
-    case (cache, env, ih, _, _,
+      // MetaModelica Uniontype. Added 2009-05-11 sjoelund
+    case (cache,env,ih,_,_,
       cl as SCode.CLASS(name = id,restriction = SCode.R_UNIONTYPE()),_,_) 
-      then (cache, {}, cl, DAE.NOMOD());
+      then (cache,{},cl,DAE.NOMOD());
+      /*----------------------*/
 
-    // Derived classes with restriction type, e.g. type Point = Real[3];
-    case (cache, env, ih, mods, pre,
+    /* Derived classes with restriction type, e.g. type Point = Real[3]; */
+    case (cache,env,ih,mods,pre,
       SCode.CLASS(name = id,restriction = SCode.R_TYPE(),info=info,
                              classDef = SCode.DERIVED(Absyn.TPATH(path = cn, arrayDim = ad),modifications = mod)),
-          dims, impl)
+          dims,impl)
       equation
         (cache,cl,cenv) = Lookup.lookupClass(cache,env, cn, true);
         owncref = Absyn.CREF_IDENT(id,{});
@@ -9250,37 +9247,29 @@ algorithm
         mods_2 = Mod.merge(mods, mod_1, env, pre);
         eq = Mod.modEquation(mods_2);
         mods_3 = Mod.lookupCompModification(mods_2, id);
-        (cache,dim1,cl,type_mods) = getUsertypeDimensions(cache, cenv, ih, mods_3, pre, cl, dims, impl);
-        (cache,dim2) = elabArraydim(cache, env, owncref, cn, ad_1, eq, impl, NONE(), true, false, pre, info, dims);
-        
-        type_mods = Mod.addEachIfNeeded(type_mods, dim1);
-        // do not add each to mod_1, it should have it already!
-        // mod_1 = Mod.addEachIfNeeded(mod_1, dim2);
-        
-        res = listAppend(dim2, dim1);
+        (cache,dim1,cl,type_mods) = getUsertypeDimensions(cache,cenv,ih, mods_3, pre, cl, dims, impl);
         type_mods = Mod.merge(mod_1, type_mods, env, pre);
+        (cache,dim2) = elabArraydim(cache,env, owncref, cn, ad_1, eq, impl,NONE(),true, false,pre,info,dims);
+        res = listAppend(dim2, dim1);
       then
         (cache,res,cl,type_mods);
 
-    // extended classes type Y = Real[3]; class X extends Y;
-    case (cache, env, ih, mods, pre,
-      SCode.CLASS(name = id, restriction = _,
+    /* extended classes type Y = Real[3]; class X extends Y; */
+    case (cache,env,ih,mods,pre,
+      SCode.CLASS(name = id,restriction = _,
                   classDef = SCode.PARTS(elementLst=els,
-                  normalEquationLst = {},
-                  initialEquationLst = {},
-                  normalAlgorithmLst = {},
-                  initialAlgorithmLst = {},
-                  externalDecl = _)),
-          dims, impl)
+                  normalEquationLst={},
+                  initialEquationLst={},
+                  normalAlgorithmLst={},
+                  initialAlgorithmLst={},
+                  externalDecl=_)),
+          dims,impl)
       equation
         (_,_,{SCode.EXTENDS(path, _, mod,_, info)},{}) = splitElts(els); // ONLY ONE extends!
         (cache,mod_1) = Mod.elabModForBasicType(cache, env, ih, pre, mod, impl, info);
         mods_2 = Mod.merge(mods, mod_1, env, pre);
         (cache,cl,cenv) = Lookup.lookupClass(cache,env, path, false);
         (cache,res,cl,type_mods) = getUsertypeDimensions(cache,env,ih,mods_2,pre,cl,{},impl);
-        
-        type_mods = Mod.addEachIfNeeded(type_mods, res);
-        
         type_mods = Mod.merge(mods_2, type_mods, env, pre);
       then
         (cache,res,cl,type_mods);

Compiler/FrontEnd/Mod.mo

@@ -591,7 +591,7 @@ algorithm
 end updateMod;
 
 protected function updateSubmods ""
-  input Env.Cache inCache;
+    input Env.Cache inCache;
   input Env.Env inEnv;
   input InstanceHierarchy inIH;
   input Prefix.Prefix inPrefix;
@@ -715,7 +715,7 @@ end elabUntypedMod;
 protected function elabSubmods
 "function: elabSubmods
   This function helps elabMod by recusively elaborating on a list of submodifications."
-  input Env.Cache inCache;
+    input Env.Cache inCache;
   input Env.Env inEnv;
   input InstanceHierarchy inIH;
   input Prefix.Prefix inPrefix;
@@ -752,7 +752,7 @@ protected function elabSubmod
 "function: elabSubmod
   This function elaborates on a submodification, turning an
   SCode.SubMod into one or more DAE.SubMod."
-  input Env.Cache inCache;
+    input Env.Cache inCache;
   input Env.Env inEnv;
   input InstanceHierarchy inIH;
   input Prefix.Prefix inPrefix;
@@ -3538,75 +3538,5 @@ algorithm outsubs := match(inSubs,componentName)
 end match;
 end removeModInSubs;
 
-public function addEachIfNeeded
-"This function adds each to the mods
- if the dimensions are not empty."
-  input DAE.Mod inMod;
-  input DAE.Dimensions inDimensions;
-  output DAE.Mod outMod;
-algorithm
-  outMod := matchcontinue (inMod, inDimensions)
-    local
-      SCode.Final finalPrefix;
-      list<tuple<SCode.Element, DAE.Mod>> elist;
-      SCode.Each eachPrefix;
-      list<DAE.SubMod> subs;
-      Option<DAE.EqMod> eq;
-    
-    case (_, {}) then inMod;
-    
-    case (DAE.NOMOD(), _) 
-      then DAE.NOMOD();
-    
-    case (DAE.REDECL(finalPrefix,eachPrefix,elist), _)
-      then
-        DAE.REDECL(finalPrefix,SCode.EACH(),elist);
-    
-    case (DAE.MOD(finalPrefix,eachPrefix,subs,eq), _)
-      equation
-        subs = addEachToSubsIfNeeded(subs, inDimensions); 
-      then
-        DAE.MOD(finalPrefix,SCode.EACH(),subs,eq);
-    
-    case(_, _) 
-      equation 
-        print("Mod.addEachIfNeeded failed on: " +& printModStr(inMod) +& "\n"); 
-      then 
-        fail();
-    
-  end matchcontinue;
-end addEachIfNeeded;
-
-public function addEachToSubsIfNeeded
-  input list<DAE.SubMod> inSubMods;
-  input DAE.Dimensions inDimensions;
-  output list<DAE.SubMod> outSubMods;
-algorithm
-  outSubMods := matchcontinue(inSubMods, inDimensions)
-    local 
-      list<DAE.SubMod> rest;
-      DAE.Mod m;
-      String id;
-      list<Integer> idxs;
-    
-    case ({}, _) then {};
-    
-    case (DAE.NAMEMOD(id, m)::rest, _)
-      equation
-        m = addEachIfNeeded(m, inDimensions);
-        rest = addEachToSubsIfNeeded(rest, inDimensions);
-      then
-        DAE.NAMEMOD(id, m)::rest;
-    
-    case (DAE.IDXMOD(idxs, m)::rest, _)
-      equation
-        m = addEachIfNeeded(m, inDimensions);
-        rest = addEachToSubsIfNeeded(rest, inDimensions);
-      then
-        DAE.IDXMOD(idxs, m)::rest;
-  
-  end matchcontinue;
-end addEachToSubsIfNeeded;
-
 end Mod;