Changeset 11631


Ignore:
Timestamp:
Sep 20, 2018 3:03:23 PM (15 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Reverting r11578,r11581,r11596 probably causing intermittent simulation problems in some models.

Location:
trunk/Compiler
Files:
28 edited

Legend:

Unmodified
Added
Removed
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r11611 r11631  
    696696
    697697    syn String FAccess.toString_C(CodePrinter.ExecuteCodePrinter p) {
    698         return myFV().genUse_C(p, asFAccess().getFArraySubscripts(), myFV().funcArrayType(isAssignUse()));
    699     }
    700 
    701     syn String FAccessFull.toString_C(CodePrinter.ExecuteCodePrinter p) {
    702         if (getNumFAccessPart() < 2) {
    703             return super.toString_C(p);
    704         }
    705        
    706698        String type = myFV().funcArrayType(isAssignUse());
    707         FAccessPart part = getFAccessPart(0);
    708         FArraySubscripts fas = part.hasFArraySubscripts() ? part.getFArraySubscripts() : null;
    709         String res = myOutermostFV().genUse_C(p, fas, C_ARRAY_RECORD);
    710         for (int i = 1, n = getNumFAccessPart(); i < n; i++) {
    711             part = getFAccessPart(i);
    712             res = res + "->" + part.getName();
    713             if (part.hasFArraySubscripts()) {
    714                 String curType = (n - i > 1 ? C_ARRAY_RECORD : type);
    715                 res = part.getFArraySubscripts().genFunctionArrayUse_C(p.codePrinter(), res, curType);
    716             }
    717         }
    718         return res;
     699        if (myFV().inRecord() && inFunction()) {
     700            return asFAccess().genRecordUse_C(p, asFAccess().myOutermostFV(), type);
     701        } else {
     702            return myFV().genUse_C(p, asFAccess().getFArraySubscripts(), type);
     703        }
    719704    }
    720705
     
    744729    public void FArraySubscripts.prettyPrint_C(CodePrinter p, CodeStream str, String indent) {
    745730        getFSubscripts().prettyPrintWithSep(p, str, "", ", ");
     731    }
     732
     733    /**
     734     * Helper, generates an record variable use
     735     */
     736    public String FAccess.genRecordUse_C(CodePrinter.ExecuteCodePrinter p, FAbstractVariable fv, String type) {
     737        throw new UnsupportedOperationException();
     738    }
     739
     740    /**
     741     * Helper, generates an record variable use
     742     */
     743    @Override
     744    public String FAccessFull.genRecordUse_C(CodePrinter.ExecuteCodePrinter p, FAbstractVariable fv, String type) {
     745        FAccessPart part = getFAccessPart(0);
     746        FArraySubscripts fas = part.hasFArraySubscripts() ? part.getFArraySubscripts() : null;
     747        String res = fv.genUse_C(p, fas, C_ARRAY_RECORD);
     748        for (int i = 1, n = getNumFAccessPart(); i < n; i++) {
     749            part = getFAccessPart(i);
     750            res = res + "->" + part.getName();
     751            if (part.hasFArraySubscripts()) {
     752                String curType = (n - i > 1 ? C_ARRAY_RECORD : type);
     753                res = part.getFArraySubscripts().genFunctionArrayUse_C(p.codePrinter(), res, curType);
     754            }
     755        }
     756        return res;
    746757    }
    747758
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r11578 r11631  
    283283                ArrayList<FGlobalVariable> globals = new ArrayList<>();
    284284                for (FGlobalVariable fv : fclass.getFGlobalVariables()) {
    285                     fv.getBindingExp().genGlobalVariableInitFunc_C(p, str, indent, false);
     285                    fv.getBindingExp().genGlobalVariableInit_C(p, str, indent);
    286286                    globals.add(fv);
    287287                }
     
    295295                    @Override
    296296                    public void gen(FGlobalVariable element) {
    297                         element.genGlobalVariableInitCall_C(p, str, indent);
     297                        element.genGlobalVariableInit_C(p, str, indent);
    298298                    }
    299299                };
     
    313313    }
    314314
    315     public void FGlobalVariable.genGlobalVariableInitCall_C(CodePrinter p, CodeStream str, String indent) {
    316         getBindingExp().genGlobalVariableInitCall_C(p, str, indent, FExp.global_C(nameUnderscore()), false);
    317     }
    318 
    319     public void FExp.genGlobalVariableInitFunc_C(CodePrinter p, CodeStream str, String indent, boolean inArray) {
    320         if (!type().isExternalObject()) {
    321             for (FExp arg : childFExps()) {
    322                 arg.genGlobalVariableInitFunc_C(p, str, indent, isArray());
    323             }
    324             if (inArray || !isComposite()) {
    325                 return;
    326             }
    327         }
     315    public void FGlobalVariable.genGlobalVariableInit_C(CodePrinter p, CodeStream str, String indent) {
     316        getBindingExp().genGlobalVariableInitScalar_C(p, str, indent, FExp.global_C(nameUnderscore()), false);
     317    }
     318
     319    public void ASTNode.genGlobalVariableInit_C(CodePrinter p, CodeStream str, String indent) {
     320        genGlobalVariableInitChildren_C(p, str, indent);
     321    }
     322   
     323    public void ASTNode.genGlobalVariableInitChildren_C(CodePrinter p, CodeStream str, String indent) {
     324        for (ASTNode n : this) {
     325            n.genGlobalVariableInit_C(p, str, indent);
     326        }
     327    }
     328   
     329    public void FRecordConstructor.genGlobalVariableInit_C(CodePrinter p, CodeStream str, String indent) {
     330        super.genGlobalVariableInit_C(p, str, indent);
    328331       
    329332        String next = p.indent(indent);
    330         String returnType = isArray() ? type().nameArray_C(p) : type().nameScalar_C(p);
    331         if (!type().isExternalObject()) {
    332             returnType = returnType + "*";
    333         }
    334         str.print(indent, returnType, " jmi_global_", tempName_C(), "(jmi_t* jmi) {\n");
     333        str.print(indent, type().nameScalar_C(p), "* jmi_global_", tempName_C(), "(jmi_t* jmi) {\n");
    335334        str.print(next, "JMI_DYNAMIC_INIT()\n");
    336335       
    337         genGlobalVariableInitFuncDecl_C(p, str, next);
     336        String typeName = type().nameScalar_C(p);
     337        str.print(next, typeName, "* ", tempName_C(), ";\n");
    338338       
    339339        str.print(next, "JMI_GLOBALS_INIT()\n");
    340340       
    341         genGlobalVariableInitFuncInit_C(p, str, next);
     341        str.print(next, tempName_C(), " = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(", typeName, "), TRUE);\n");
     342       
     343        genGlobalVariableInitScalar_C(p, str, next, tempName_C(), true);
    342344       
    343345        str.print(next, "JMI_GLOBALS_FREE()\n");
     
    346348        str.print(indent, "}\n\n");
    347349    }
    348 
    349     public void FIdUseExp.genGlobalVariableInitFunc_C(CodePrinter p, CodeStream str, String indent, boolean inArray) {
    350        
    351     }
    352 
    353     public void FExp.genGlobalVariableInitFuncDecl_C(CodePrinter p, CodeStream str, String indent) {
    354         str.print(indent, type().nameScalar_C(p), " ", tempName_C(), ";\n");
    355         p.printVarDecls(this, str, indent);
    356     }
    357 
    358     public void FExp.genGlobalVariableInitFuncInit_C(CodePrinter p, CodeStream str, String indent) {
    359         p.printPreSteps(this, str, indent);
    360         str.print(indent, tempName_C(), " = ");
    361         p.print(this, str, indent);
    362         p.printPostSteps(this, str, indent);
    363         str.print(";\n");
    364     }
    365 
    366     @Override
    367     public void FRecordConstructor.genGlobalVariableInitFuncDecl_C(CodePrinter p, CodeStream str, String indent) {
    368         str.print(indent, type().nameScalar_C(p), "* ", tempName_C(), ";\n");
    369     }
    370 
    371     @Override
    372     public void FRecordConstructor.genGlobalVariableInitFuncInit_C(CodePrinter p, CodeStream str, String indent) {
    373         str.print(indent, tempName_C(), " = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(", type().nameScalar_C(p), "), TRUE);\n");
    374         genGlobalVariableInitCall_C(p, str, indent, tempName_C(), true);
    375     }
    376 
    377     @Override
    378     public void FArray.genGlobalVariableInitFuncDecl_C(CodePrinter p, CodeStream str, String indent) {
    379         str.print(indent, "JMI_ARR(",
     350   
     351    public void FArray.genGlobalVariableInit_C(CodePrinter p, CodeStream str, String indent) {
     352        for (Index i : indices()) {
     353            fArrayCell(i, 0).genGlobalVariableInitChildren_C(p, str, indent);
     354        }
     355       
     356        String next = p.indent(indent);
     357        str.print(indent, type().nameArray_C(p), "* jmi_global_", tempName_C(), "(jmi_t* jmi) {\n");
     358        str.print(next, "JMI_DYNAMIC_INIT()\n");
     359       
     360        str.print(next, "JMI_ARR(",
    380361                "DYNA", ", ",
    381362                type().nameScalar_C(p, false), ", ",
    382363                type().nameArray_C(p, false), ", ",
    383364                tempName_C(), ", ");
    384         type().size().printNumElements_C(p, str, indent, this);
     365        type().size().printNumElements_C(p, str, next, this);
    385366        str.print(", ");
    386367        str.print(type().ndims());
    387368        str.print(")\n");
    388     }
    389 
    390     @Override
    391     public void FArray.genGlobalVariableInitFuncInit_C(CodePrinter p, CodeStream str, String indent) {
    392         str.print(indent, "JMI_ARRAY_INIT_", ndims(), "(",
     369       
     370        str.print(next, "JMI_GLOBALS_INIT()\n");
     371       
     372        str.print(next, "JMI_ARRAY_INIT_", ndims(), "(",
    393373                "DYNA", ", ",
    394374                type().nameScalar_C(p, false), ", ",
    395375                type().nameArray_C(p, false), ", ",
    396376                tempName_C(), ", ");
    397         type().size().printNumElements_C(p, str, indent, this);
     377        type().size().printNumElements_C(p, str, next, this);
    398378        str.print(", ");
    399379        str.print(type().ndims());
    400380        str.print(", ");
    401         type().size().printDimensions_C(p, str, indent, this);
     381        type().size().printDimensions_C(p, str, next, this);
    402382        str.print(")\n");
    403383       
     
    408388            String cellName = pre + i.toUnclosedString() + ")";
    409389            FExp cellExp = fArrayCell(i, 0);
    410             cellExp.genGlobalVariableInitCall_C(p, str, indent, cellName, true);
    411         }
    412        
    413     }
    414 
    415     public void FExp.genGlobalVariableInitCall_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
    416         if (!isLiteralZero()) {;
     390            cellExp.genGlobalVariableInitScalar_C(p, str, next, cellName, true);
     391        }
     392       
     393        str.print(next, "JMI_GLOBALS_FREE()\n");
     394        str.print(next, "JMI_DYNAMIC_FREE()\n");
     395        str.print(next, "return ", tempName_C(), ";\n");
     396        str.print(indent, "}\n\n");
     397    }
     398   
     399    public void FExp.genGlobalVariableInitScalar_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
     400        if (isComposite()) {
     401            str.print(indent, name, " = ");
     402            str.print("jmi_global_", tempName_C(), "(jmi)");
     403            str.print(";\n");
     404        } else if (!isLiteralZero()) {
    417405            str.print(indent, name, " = ");
    418406            p.print(this, str, indent);
     
    421409    }
    422410
    423     public void FFunctionCall.genGlobalVariableInitCall_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
    424         str.print(indent, name, " = jmi_global_", tempName_C(), "(jmi);\n");
    425     }
    426 
    427     public void FArray.genGlobalVariableInitCall_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
    428         str.print(indent, name, " = jmi_global_", tempName_C(), "(jmi);\n");
    429     }
    430 
    431     public void FRecordConstructor.genGlobalVariableInitCall_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
     411    public void FRecordConstructor.genGlobalVariableInitScalar_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
    432412        if (expand) {
    433413            for (FRecordComponentType comp : getRecord().recordType().getComponents()) {
    434414                String compName = name + "->" + comp.getName();
    435415                FExp compExp = component(comp.getName());
    436                 compExp.genGlobalVariableInitCall_C(p, str, indent, compName, false);
     416                compExp.genGlobalVariableInitScalar_C(p, str, indent, compName, false);
    437417            }
    438418        } else {
    439             str.print(indent, name, " = jmi_global_", tempName_C(), "(jmi);\n");
    440         }
    441     }
    442    
    443     @Override
    444     public void FGlobalVariable.genDestructorCall_C(CodePrinter p, CodeStream str, String indent) {
    445         getBindingExp().genDestructorCall_C(p, str, indent, this);
    446     }
    447    
    448     public void FExp.genDestructorCall_C(CodePrinter p, CodeStream str, String indent, FGlobalVariable v) {
    449    
    450     }
    451    
    452     @Override
    453     public void FFunctionCall.genDestructorCall_C(CodePrinter p, CodeStream str, String indent, FGlobalVariable v) {
    454         if (isConstructorCall()) {
    455             String strName = v.type().name() + ".destructor";
    456             FCallable c = getName().lookupFCallable(strName);
    457             str.print(indent, c.funcNameUnderscore(C_SUFFIX_DEF), "(", FExp.global_C(v.nameUnderscore()), ");\n");
     419            super.genGlobalVariableInitScalar_C(p, str, indent, name, expand);
    458420        }
    459421    }
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CGenerator.jrag

    r11578 r11631  
    12261226                eo.genDestructorCall_C(p, str, p.indent(""));
    12271227            }
    1228             for (FGlobalVariable eo : fclass.getFGlobalVariables()) {
    1229                 eo.genDestructorCall_C(p, str, p.indent(""));
    1230             }
    12311228        }
    12321229    }
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenGlobalsTests.mo

    r11626 r11631  
    19811981    i_0ie = floor((2) - (1));
    19821982    for (i_0i = 1; i_0in <= i_0ie; i_0i = 1 + (++i_0in)) {
    1983         y_v = jmi_pow_function(\"CCodeGenGlobalsTests.GlobalVariables.GlobalConstantForPowInt1.f\", y_v, jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantForPowInt1_f_c), i_0i), \"y ^ global(CCodeGenGlobalsTests.GlobalVariables.GlobalConstantForPowInt1.f.c[i])\");
     1983        y_v = jmi_pow_function(\"CCodeGenGlobalsTests.GlobalVariables.GlobalConstantForPowInt1.f\", y_v, jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantForPowInt1_f_c), i_0i), \"y ^ CCodeGenGlobalsTests.GlobalVariables.GlobalConstantForPowInt1.f.c[i]\");
    19841984    }
    19851985    JMI_RET(GEN, y_o, y_v)
     
    21952195end GlobalConstantRef2;
    21962196
    2197 model GlobalConstantRef3
    2198    
    2199     constant R1[1] r = {R1(2)};
    2200     record R1
    2201         parameter Real x;
    2202     end R1;
    2203     function f
    2204         input Integer i;
    2205         output Real y = 1 + r[i].x;
    2206     algorithm
    2207     end f;
    2208    
    2209     Real y = f(integer(time));
    2210 
    2211 annotation(__JModelica(UnitTesting(tests={
    2212     CCodeGenTestCase(
    2213         name="GlobalConstantRef3",
    2214         description="",
    2215         template="
    2216 $C_global_temps$
    2217 $C_set_globals_start$
    2218 $C_functions$
    2219 $C_ode_derivatives$
    2220 ",
    2221         generatedCode="
    2222     R1_0_ra* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef3_r;
    2223 
    2224 R1_0_ra* jmi_global_tmp_1(jmi_t* jmi) {
    2225     JMI_DYNAMIC_INIT()
    2226     JMI_ARR(DYNA, R1_0_r, R1_0_ra, tmp_1, 1, 1)
    2227     JMI_GLOBALS_INIT()
    2228     JMI_ARRAY_INIT_1(DYNA, R1_0_r, R1_0_ra, tmp_1, 1, 1, 1)
    2229     jmi_array_rec_1(tmp_1, 1)->x = AD_WRAP_LITERAL(2);
    2230     JMI_GLOBALS_FREE()
    2231     JMI_DYNAMIC_FREE()
    2232     return tmp_1;
    2233 }
    2234 
    2235 int jmi_set_globals_start_0(jmi_t* jmi) {
    2236     int ef = 0;
    2237     JMI_DYNAMIC_INIT()
    2238     JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef3_r) = jmi_global_tmp_1(jmi);
    2239     JMI_DYNAMIC_FREE()
    2240     return ef;
    2241 }
    2242 
    2243 int jmi_set_globals_start_0(jmi_t* jmi);
    2244 
    2245 int jmi_set_globals_start(jmi_t* jmi) {
    2246     int ef = 0;
    2247     JMI_DYNAMIC_INIT()
    2248     ef |= jmi_set_globals_start_0(jmi);
    2249     JMI_DYNAMIC_FREE()
    2250     return ef;
    2251 }
    2252 
    2253 
    2254 
    2255 int model_ode_derivatives_base(jmi_t* jmi) {
    2256     int ef = 0;
    2257     JMI_DYNAMIC_INIT()
    2258     if (jmi->atInitial || jmi->atEvent) {
    2259         _sw(0) = jmi_turn_switch_time(jmi, _time - (pre_temp_1_2), _sw(0), JMI_REL_LT);
    2260     }
    2261     if (jmi->atInitial || jmi->atEvent) {
    2262         _sw(1) = jmi_turn_switch_time(jmi, _time - (pre_temp_1_2 + AD_WRAP_LITERAL(1)), _sw(1), JMI_REL_GEQ);
    2263     }
    2264     _temp_1_2 = COND_EXP_EQ(LOG_EXP_OR(LOG_EXP_OR(_sw(0), _sw(1)), _atInitial), JMI_TRUE, floor(_time), pre_temp_1_2);
    2265     pre_temp_1_2 = _temp_1_2;
    2266     _y_1 = 1 + jmi_array_rec_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef3_r), _temp_1_2)->x;
    2267     JMI_DYNAMIC_FREE()
    2268     return ef;
    2269 }
    2270 ")})));
    2271 end GlobalConstantRef3;
    2272 
    2273 model GlobalConstantExternalObject1
    2274    
    2275     package P
    2276         model EO
    2277             extends ExternalObject;
    2278             function constructor
    2279                 input Real[:] x;
    2280                 output EO eo;
    2281                 external;
    2282             end constructor;
    2283             function destructor
    2284                 input EO eo;
    2285                 external;
    2286             end destructor;
    2287         end EO;
    2288        
    2289         function f
    2290             output Real y;
    2291             external "C" y = f(eo1);
    2292         end f;
    2293        
    2294         constant Real x = 1;
    2295         constant EO eo = EO({x});
    2296         constant EO eo1 = eo;
    2297     end P;
    2298    
    2299     function f
    2300         input Real x;
    2301         output Real y = x + P.f();
    2302     algorithm
    2303     end f;
    2304 
    2305     Real y = f(time);
    2306 
    2307 annotation(__JModelica(UnitTesting(tests={
    2308     CCodeGenTestCase(
    2309         name="GlobalConstantExternalObject1",
    2310         description="",
    2311         template="
    2312 $C_global_temps$
    2313 $C_set_globals_start$
    2314 $C_functions$
    2315 $C_destruct_external_object$
    2316 ",
    2317         generatedCode="
    2318     jmi_extobj_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo;
    2319     jmi_extobj_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1;
    2320 
    2321 jmi_extobj_t jmi_global_tmp_1(jmi_t* jmi) {
    2322     JMI_DYNAMIC_INIT()
    2323     jmi_extobj_t tmp_1;
    2324     JMI_ARR(STAT, jmi_real_t, jmi_array_t, tmp_2, 1, 1)
    2325     JMI_GLOBALS_INIT()
    2326     JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, tmp_2, 1, 1, 1)
    2327     jmi_array_ref_1(tmp_2, 1) = 1.0;
    2328     tmp_1 = func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_exp2(tmp_2);
    2329     JMI_GLOBALS_FREE()
    2330     JMI_DYNAMIC_FREE()
    2331     return tmp_1;
    2332 }
    2333 
    2334 int jmi_set_globals_start_0(jmi_t* jmi) {
    2335     int ef = 0;
    2336     JMI_DYNAMIC_INIT()
    2337     JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo) = jmi_global_tmp_1(jmi);
    2338     JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1) = JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo);
    2339     JMI_DYNAMIC_FREE()
    2340     return ef;
    2341 }
    2342 
    2343 int jmi_set_globals_start_0(jmi_t* jmi);
    2344 
    2345 int jmi_set_globals_start(jmi_t* jmi) {
    2346     int ef = 0;
    2347     JMI_DYNAMIC_INIT()
    2348     ef |= jmi_set_globals_start_0(jmi);
    2349     JMI_DYNAMIC_FREE()
    2350     return ef;
    2351 }
    2352 
    2353 void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_def0(jmi_real_t* y_o) {
    2354     JMI_DYNAMIC_INIT()
    2355     JMI_DEF(REA, y_v)
    2356     extern double f(void*);
    2357     y_v = f(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1));
    2358     JMI_RET(GEN, y_o, y_v)
    2359     JMI_DYNAMIC_FREE()
    2360     return;
    2361 }
    2362 
    2363 jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_exp0() {
    2364     JMI_DEF(REA, y_v)
    2365     func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_def0(&y_v);
    2366     return y_v;
    2367 }
    2368 
    2369 void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(jmi_extobj_t eo_v) {
    2370     JMI_DYNAMIC_INIT()
    2371     extern void destructor(void*);
    2372     destructor(eo_v);
    2373     JMI_DYNAMIC_FREE()
    2374     return;
    2375 }
    2376 
    2377 void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_def2(jmi_array_t* x_a, jmi_extobj_t* eo_o) {
    2378     JMI_DYNAMIC_INIT()
    2379     JMI_DEF(EXO, eo_v)
    2380     extern void* constructor(double*, size_t);
    2381     eo_v = constructor(x_a->var, jmi_array_size(x_a, 0));
    2382     JMI_RET(GEN, eo_o, eo_v)
    2383     JMI_DYNAMIC_FREE()
    2384     return;
    2385 }
    2386 
    2387 jmi_extobj_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_exp2(jmi_array_t* x_a) {
    2388     JMI_DEF(EXO, eo_v)
    2389     func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_def2(x_a, &eo_v);
    2390     return eo_v;
    2391 }
    2392 
    2393 
    2394     func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo));
    2395 
    2396 ")})));
    2397 end GlobalConstantExternalObject1;
    2398 
    23992197end GlobalVariables;
    24002198
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenTests.mo

    r11626 r11631  
    1162711627end BlockTest24;
    1162811628
    11629 model BlockTest25
    11630     record R
    11631         constant Real y;
    11632     end R;
    11633    
    11634     function f
    11635         constant R[:] p = {R(3)};
    11636         input Integer i;
    11637         output Real y = p[i].y;
    11638     algorithm
    11639     end f;
    11640    
    11641     function f2
    11642         input Real x;
    11643         output Real y = x;
    11644     algorithm
    11645         annotation(Inline=false);
    11646     end f2;
    11647    
    11648     parameter Integer i = 1;
    11649     Real x = f(i) + f2(x);
    11650 
    11651 annotation(__JModelica(UnitTesting(tests={
    11652     CCodeGenTestCase(
    11653         name="BlockTest25",
    11654         description="Nominal with global constant in record",
    11655         template="$C_dae_blocks_residual_functions$",
    11656         variability_propagation=false,
    11657         generatedCode="
    11658 static int dae_block_0(jmi_t* jmi, jmi_real_t* x, jmi_real_t* residual, int evaluation_mode) {
    11659     /***** Block: 1 *****/
    11660     jmi_real_t** res = &residual;
    11661     int ef = 0;
    11662     JMI_DYNAMIC_INIT()
    11663     if (evaluation_mode == JMI_BLOCK_VALUE_REFERENCE) {
    11664         x[0] = 1;
    11665     } else if (evaluation_mode == JMI_BLOCK_EQUATION_NOMINAL_AUTO) {
    11666         (*res)[0] = jmi_max(AD_WRAP_LITERAL(1), jmi_max(jmi_abs(jmi_array_rec_1(JMI_GLOBAL(CCodeGenTests_BlockTest25_f_p), _i_0)->y), AD_WRAP_LITERAL(1)));
    11667     } else if (evaluation_mode == JMI_BLOCK_INITIALIZE) {
    11668         x[0] = _x_1;
    11669     } else if (evaluation_mode & JMI_BLOCK_EVALUATE || evaluation_mode & JMI_BLOCK_WRITE_BACK) {
    11670         if ((evaluation_mode & JMI_BLOCK_EVALUATE_NON_REALS) == 0) {
    11671             _x_1 = x[0];
    11672         }
    11673         if (evaluation_mode & JMI_BLOCK_EVALUATE) {
    11674             (*res)[0] = jmi_array_rec_1(JMI_GLOBAL(CCodeGenTests_BlockTest25_f_p), _i_0)->y + func_CCodeGenTests_BlockTest25_f2_exp0(_x_1) - (_x_1);
    11675         }
    11676     }
    11677     JMI_DYNAMIC_FREE()
    11678     return ef;
    11679 }
    11680 ")})));
    11681 end BlockTest25;
    11682 
    1168311629model NestedUnsolvedScalarInSolvedBlock
    1168411630    Real a;
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r11611 r11631  
    16471647        public FExp buildLiteral() {
    16481648            return type.createLiteral(index);
    1649         }
    1650 
    1651         @Override
    1652         public FExp buildInstLiteral() {
    1653             return new FEnumLitExp(type, index);
    16541649        }
    16551650
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/Constructors.jrag

    r11578 r11631  
    973973    // Identifier expressions
    974974    public FIdUseExp      FIdUseExp.createEmptyNode()      { return new FIdUseExp();      }
    975     public FGlobalAccessExp FGlobalAccessExp.createEmptyNode() { return new FGlobalAccessExp(); }
    976975    public InstDerExp     InstDerExp.createEmptyNode()     { return new InstDerExp();     }
    977976    public FDerExp        FDerExp.createEmptyNode()        { return new FDerExp();        }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r11596 r11631  
    32203220   
    32213221    eq FIdUseExp.nominal() = myFV().nominal();
    3222     eq FGlobalAccessExp.nominal() = new FAbsExp(treeCopy());
    32233222   
    32243223    syn FExp FAbstractVariable.nominal() {
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatNameBinding.jrag

    r11578 r11631  
    7373            res = variablesMap().lookup(name);
    7474        }
     75        if (res == null) {
     76            res = lookupGlobalVariable(name);
     77        }
    7578        return nullUnknown(res);
    7679    }
     80
     81    inh FAbstractVariable FFunctionDecl.lookupGlobalVariable(String name);
     82    eq Root.getChild().lookupGlobalVariable(String name)   = null;
     83    eq FClass.getChild().lookupGlobalVariable(String name) = globalVariablesMap().lookup(name);
    7784
    7885    private FlatVariableMap FFunctionDecl.tempLookupMap = null;
     
    128135        }
    129136    }
    130     syn FAbstractVariable FAccess.myFV();
    131     eq FAccess    .myFV() = isGlobalAccess() ? lookupGlobalVariable(name()) : lookupFV(name());
     137
     138    syn FAbstractVariable FAccess.myFV() = lookupFV(name());
    132139    eq FAccessFull.myFV() = getFAccessPart(getNumFAccessPart() - 1).myFV();
    133140
     
    140147        FAbstractVariable res = myContextFV();
    141148        if (res == null) {
    142             if (isGlobalAccess()) {
    143                 res = lookupGlobalVariable(name());
    144             } else {
    145                 res = lookupFV(name());
    146             }
     149            res = lookupFV(name());
    147150        } else if (!res.isUnknown()) {
    148151            res = res.myFRecordDecl().lookupFV(name());
     
    154157    eq FAccessFull.getFAccessPart(int i).myContextFV() =
    155158            i == 0 ? null : getFAccessPart(i - 1).myFV();
    156 
    157     inh FAbstractVariable FAccess.lookupGlobalVariable(String name);
    158     inh FAbstractVariable FAccessPart.lookupGlobalVariable(String name);
    159     eq Root.getChild().lookupGlobalVariable(String name)   = null;
    160     eq FClass.getChild().lookupGlobalVariable(String name) = globalVariablesMap().lookup(name);
    161 
    162     inh boolean FAccess.isGlobalAccess();
    163     inh boolean FAccessPart.isGlobalAccess();
    164     eq BaseNode.getChild().isGlobalAccess() = false;
    165     eq FAccessFull.getChild().isGlobalAccess() = isGlobalAccess();
    166     eq FGlobalAccessExp.getChild().isGlobalAccess() = true;
    167 
     159   
    168160    syn boolean CommonAccess.isForIndex();
    169161    syn boolean FIdUseExp.isForIndex() = getCommonAccess().isForIndex();
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r11611 r11631  
    16451645        p.print(getCommonAccess(), str, indent);
    16461646    }
    1647    
    1648     protected void FGlobalAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
    1649         str.print("global(");
    1650         super.prettyPrintExp(p, str, indent);
    1651         str.print(")");
    1652     }
    16531647   
    16541648    public void InstAccess.prettyPrint(Printer p, CodeStream str, String indent) {
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r11611 r11631  
    10031003
    10041004/**
    1005  * Access expression to global variable
    1006  */
    1007 FGlobalAccessExp : FIdUseExp;
    1008 
    1009 /**
    10101005 * A reference to a dynamic state. These are the states that are introduced by
    10111006 * the compiler and exposed as state in the FMU.
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/errorcheck/ComplianceCheck.jadd

    r11578 r11631  
    9191    public static final SimpleProblemProducer ASTNode.ONLY_FMU_NON_FIXED_RECORD_ARRAY_INDEX =
    9292            new ComplianceFMUOnlyProducer("ONLY_FMU_NON_FIXED_RECORD_ARRAY_INDEX", "Using arrays of records with indices of higher than parameter variability is");
    93     public static final SimpleProblemProducer ASTNode.EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE =
    94             new SimpleErrorProducer("EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE", ProblemKind.COMPLIANCE, "Access to external object constants in arrays or records is not supported");
     93    public static final SimpleProblemProducer ASTNode.EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION =
     94            new SimpleErrorProducer("EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION", ProblemKind.COMPLIANCE, "Access to external object constants is not supported in functions");
    9595   
    9696
     
    102102            ONLY_FMU_NON_FIXED_RECORD_ARRAY_INDEX.invoke(this);
    103103        }
    104         if (decl.isExternalObject() && decl.isConstant() && (decl.inRecord() || decl.isArray())) {
    105             EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE.invoke(this);
     104        if (decl.isExternalObject() && !decl.inFunction() && decl.getSrcComponentDecl().isConstant() && inFunction()) {
     105            EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION.invoke(this);
    106106        }
    107107    }
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r11611 r11631  
    844844    @Override
    845845    public void InstAssignable.flattenInFunction(Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts) {
    846         if (!flattenAsGlobalVariableFromFunction()) {
     846        if (!flattenAsFunctionConstant()) {
    847847            if (hasInstValueMod())
    848848                getBindingFExp().flattenUsedFuncsAndEnums(f);
     
    12281228
    12291229    public void InstAssignable.flatten(Flattener f, FlattenBindingExp binding, int level, boolean global) {
    1230         if (useInFlattening() && (global || !flattenAsGlobalVariable())) {
     1230        if (useInFlattening()) {
    12311231            if (hasBindingFExp()) {
    12321232                getBindingFExp().flattenAssertExternal(f);
     
    17851785            if (variability().knownParameterOrLess()) {
    17861786                CValue cval = ceval();
     1787                FExp t = dynamicFExp(cval.buildInstLiteral());
     1788                t.flattenUsedFuncsAndEnums(f);
    17871789                if (cval.hasBuildLiteral()) {
    1788                     FExp t = dynamicFExp(cval.buildInstLiteral());
    1789                     t.flattenUsedFuncsAndEnums(f);
    1790                     FExp res = t.flatten(f);
    1791                     clearDynamicFExp();
    1792                     return res;
     1790                    return cval.buildLiteral();
    17931791                }
    17941792            }
     
    25172515
    25182516    public FExp FLitExp.flatten(Flattener f)     { return fullCopy(); }
    2519     public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), new Opt<FEnumType>()); }
     2517    public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), null); }
    25202518   
    25212519    public FExp FModFuncExp.flatten(Flattener f) {
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningAccess.jrag

    r11578 r11631  
    241241            }
    242242        }
    243         if (ia.flattenAsGlobalAccess()) {
     243        if (ia.inFunction() && flattenAsFunctionConstant()) {
    244244            InstAssignable top = ia.topInstAssignable();
    245245            if (!f.isFlattenedGlobalVariable(top)) {
    246246                top.flatten(f, FlattenBindingExp.ALL, 0, true);
    247247            }
    248             return new FGlobalAccessExp(ia.flatten().copyAndPrepend(top.surroundingInstClass().qualifiedName()), (String)null);
     248            return new FIdUseExp(ia.flatten().copyAndPrepend(top.surroundingInstClass().qualifiedName()));
    249249        }
    250250        return null;
    251251    }
    252252
    253     syn boolean InstAccess.flattenAsGlobalAccess() =
    254             topInstAssignable().flattenAsGlobalVariable() ||
    255             (inFunction() && topInstAssignable().flattenAsGlobalVariableFromFunction());
    256     syn boolean InstAssignable.flattenAsGlobalVariable() =
    257             isExternalObject() && variability().constantVariability();
    258     syn boolean InstAssignable.flattenAsGlobalVariableFromFunction() =
    259             !isInput() && !isOutput() && variability().constantVariability();
     253    syn boolean InstAssignable.flattenAsFunctionConstant() =
     254            !isInput() && !isOutput() && variability().knownParameterOrLess();
    260255
    261256    /**
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstTypeAnalysis.jrag

    r11578 r11631  
    9191    }
    9292
    93     syn nta lazy FRecordType InstClassDecl.recordType() {
     93    syn lazy FRecordType InstClassDecl.recordType() {
    9494        FRecordType type = resolveLib().createEmptyFRecordType(Size.SCALAR);
    9595        for (InstComponentDecl icd : allInstComponentDecls())
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstVariability.jrag

    r11578 r11631  
    6262    eq UnknownInstComponentDecl.calcVariability() = Variability.CONSTANT;
    6363    eq InstAssignable.calcVariability()           = calcVariability(super.calcVariability());
    64     eq InstExternalObject.calcVariability() {
    65         TypePrefixVariability v = super.calcVariability();
    66         if (!v.constantVariability()) {
    67             v = calcVariability(Variability.FIXEDPARAMETER).combine(Variability.FIXEDPARAMETER).combineDown(Variability.INITIALPARAMETER);
    68         }
    69         return v;
    70     }
     64    eq InstExternalObject.calcVariability()                        = calcVariability(Variability.FIXEDPARAMETER)
     65                .combine(Variability.FIXEDPARAMETER).combineDown(Variability.INITIALPARAMETER);
    7166   
    7267    // Parameters variabilities also depend on binding expressions since its nice
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r11578 r11631  
    857857        return (FExp) getDynamicFExpOpt().getChild(0);
    858858    }
    859 
    860     public void InstNode.clearDynamicFExp() {
    861        getDynamicFExpOpt().setChild(null, 0);
    862     }
    863 
     859   
    864860    /**
    865861     * Dynamically places an FExp in the tree under this InstExternal.
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/ArrayTests.mo

    r11578 r11631  
    90199019  output Real o;
    90209020 algorithm
    9021   o := global(ArrayTests.Other.ArrayConst3.c[integer(i)]);
     9021  o := ArrayTests.Other.ArrayConst3.c[integer(i)];
    90229022  return;
    90239023 annotation(Inline = false);
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo

    r11578 r11631  
    739739end ExtObjInFunction1;
    740740
     741model ExtObjInFunction2
     742    package Ext
     743        extends ExternalObject;
     744        function constructor
     745            input String s;
     746            output Ext ext;
     747            external "C" ext = ext_constructor(s);
     748        end constructor;
     749        function destructor
     750            input Ext ext;
     751            external "C" ext_destructor(ext);
     752        end destructor;
     753    end Ext;
     754    function EXT_F
     755        input Ext  ext;
     756        input Real  u;
     757        output Real y;
     758    external "C"
     759        y = ext_f(ext, u);
     760    end EXT_F;
     761    package Map
     762        constant String n = "";
     763        final constant Ext ext = Ext(n);
     764        function f
     765            input Real x;
     766            output Real y;
     767        algorithm
     768            y := EXT_F(ext, x);
     769        end f;
     770    end Map;
     771   
     772    package map = Map;
     773   
     774    Real x = map.f(time);
     775   
     776    annotation(__JModelica(UnitTesting(tests={
     777        ComplianceErrorTestCase(
     778            name="ExtObjInFunction2",
     779            description="Test compliance error for external object constants used in functions",
     780            errorMessage="
     7811 errors found:
     782
     783Compliance error at line 28, column 24, in file 'Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo', EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION:
     784  Access to external object constants is not supported in functions
     785")})));
     786end ExtObjInFunction2;
     787
     788
    741789model DeprecatedDecoupleTest1
    742790    Real x[2] = time * (1:2);
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/FunctionTests.mo

    r11610 r11631  
    494494 algorithm
    495495  init y as Real[2];
    496   y[1] := x[1] .+ global(FunctionTests.FunctionFlatten9.a[i]) .+ global(FunctionTests.FunctionFlatten9.a[i + 1]);
    497   y[2] := x[2] .+ global(FunctionTests.FunctionFlatten9.a[i]) .+ global(FunctionTests.FunctionFlatten9.a[i + 1]);
    498   return;
    499  annotation(Inline = false);
     496  y[1] := x[1] .+ FunctionTests.FunctionFlatten9.a[i] .+ FunctionTests.FunctionFlatten9.a[i + 1];
     497  y[2] := x[2] .+ FunctionTests.FunctionFlatten9.a[i] .+ FunctionTests.FunctionFlatten9.a[i + 1];
     498  return;
     499 annotation(Inline=false);
    500500 end FunctionTests.FunctionFlatten9.f;
    501501
     
    10091009  output Real y;
    10101010 algorithm
    1011   y := global(FunctionTests.FunctionFlatten21.f.x);
     1011  y := FunctionTests.FunctionFlatten21.f.x;
    10121012  return;
    10131013 end FunctionTests.FunctionFlatten21.f;
     
    10921092 algorithm
    10931093  for i in 1:1 loop
    1094    y := global(FunctionTests.FunctionFlatten23.f.r.a[i]) * x;
     1094   y := FunctionTests.FunctionFlatten23.f.r.a[i] * x;
    10951095  end for;
    10961096  return;
     
    1031210312  output Real y1;
    1031310313 algorithm
    10314   y1 := FunctionTests.UnknownArray29.f2({global(FunctionTests.UnknownArray29.a[i]), global(FunctionTests.UnknownArray29.a[i + 1])});
    10315   return;
    10316  annotation(Inline = false);
     10314  y1 := FunctionTests.UnknownArray29.f2({FunctionTests.UnknownArray29.a[i], FunctionTests.UnknownArray29.a[i + 1]});
     10315  return;
     10316 annotation(Inline=false);
    1031710317 end FunctionTests.UnknownArray29.f1;
    1031810318
     
    1032810328  y2 := temp_1;
    1032910329  return;
    10330  annotation(Inline = false);
     10330 annotation(Inline=false);
    1033110331 end FunctionTests.UnknownArray29.f2;
    1033210332
     
    1249112491  Real f;
    1249212492 algorithm
    12493   f := a + global(FunctionTests.ExtendFunc2.d[c]);
     12493  f := a + FunctionTests.ExtendFunc2.d[c];
    1249412494  b := f;
    1249512495  return;
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo

    r11578 r11631  
    17191719  output Real x;
    17201720 algorithm
    1721   x := global(NameTests.ConstantLookup32.C.d[i].b);
     1721  x := NameTests.ConstantLookup32.C.d[i].b;
    17221722  return;
    17231723 end NameTests.ConstantLookup32.f;
     
    17761776  output Real x;
    17771777 algorithm
    1778   x := global(NameTests.ConstantLookup33.C.d[i].b);
     1778  x := NameTests.ConstantLookup33.C.d[i].b;
    17791779  return;
    17801780 end NameTests.ConstantLookup33.f;
     
    18271827  output Real x;
    18281828 algorithm
    1829   x := global(NameTests.ConstantLookup34.A.x[i].y[i]);
     1829  x := NameTests.ConstantLookup34.A.x[i].y[i];
    18301830  return;
    18311831 annotation(Inline = false);
     
    19101910  Real y;
    19111911 algorithm
    1912   y := global(NameTests.ConstantLookup35.L.a[i]);
     1912  y := NameTests.ConstantLookup35.L.a[i];
    19131913  x := y;
    19141914  return;
     
    19561956  output Real x;
    19571957 algorithm
    1958   x := global(NameTests.ConstantLookup36.f.a[i].b[i]);
     1958  x := NameTests.ConstantLookup36.f.a[i].b[i];
    19591959  return;
    19601960 annotation(Inline = false);
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/RecordTests.mo

    r11578 r11631  
    20732073  output Real x;
    20742074 algorithm
    2075   x := RecordTests.UnmodifiableComponent5.f2(global(RecordTests.UnmodifiableComponent5.r[i]));
     2075  x := RecordTests.UnmodifiableComponent5.f2(RecordTests.UnmodifiableComponent5.r[i]);
    20762076  return;
    20772077 annotation(Inline = false);
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/VariabilityTests.mo

    r11578 r11631  
    11771177end RecordVariabilityScalarization1;
    11781178
    1179 model ExternalObjectConstant1
    1180     model EO
    1181         extends ExternalObject;
    1182         function constructor
    1183             input Real x;
    1184             output EO eo;
    1185             external;
    1186         end constructor;
    1187         function destructor
    1188             input EO eo;
    1189             external;
    1190         end destructor;
    1191     end EO;
    1192    
    1193     function f
    1194         input EO x;
    1195         output Real y;
    1196         external;
    1197     end f;
    1198    
    1199     constant Real x = 1;
    1200     constant EO eo = EO(x);
    1201     constant EO eo1 = eo;
    1202     constant EO eo2 = eo;
    1203     Real y = f(eo1);
    1204 
    1205     annotation(__JModelica(UnitTesting(tests={
    1206         FlatteningTestCase(
    1207             name="ExternalObjectConstant1",
    1208             description="",
    1209             flatModel="
    1210 fclass VariabilityTests.ExternalObjectConstant1
    1211  constant Real x = 1;
    1212  Real y = VariabilityTests.ExternalObjectConstant1.f(global(VariabilityTests.ExternalObjectConstant1.eo1));
    1213 package constant
    1214  constant VariabilityTests.ExternalObjectConstant1.EO VariabilityTests.ExternalObjectConstant1.eo = VariabilityTests.ExternalObjectConstant1.EO.constructor(1.0);
    1215  constant VariabilityTests.ExternalObjectConstant1.EO VariabilityTests.ExternalObjectConstant1.eo1 = global(VariabilityTests.ExternalObjectConstant1.eo);
    1216 
    1217 public
    1218  function VariabilityTests.ExternalObjectConstant1.EO.destructor
    1219   input VariabilityTests.ExternalObjectConstant1.EO eo;
    1220  algorithm
    1221   external \"C\" destructor(eo);
    1222   return;
    1223  end VariabilityTests.ExternalObjectConstant1.EO.destructor;
    1224 
    1225  function VariabilityTests.ExternalObjectConstant1.EO.constructor
    1226   input Real x;
    1227   output VariabilityTests.ExternalObjectConstant1.EO eo;
    1228  algorithm
    1229   external \"C\" eo = constructor(x);
    1230   return;
    1231  end VariabilityTests.ExternalObjectConstant1.EO.constructor;
    1232 
    1233  function VariabilityTests.ExternalObjectConstant1.f
    1234   input VariabilityTests.ExternalObjectConstant1.EO x;
    1235   output Real y;
    1236  algorithm
    1237   external \"C\" y = f(x);
    1238   return;
    1239  end VariabilityTests.ExternalObjectConstant1.f;
    1240 
    1241  type VariabilityTests.ExternalObjectConstant1.EO = ExternalObject;
    1242 end VariabilityTests.ExternalObjectConstant1;
    1243 ")})));
    1244 end ExternalObjectConstant1;
    1245 
    1246 model ExternalObjectConstant2
    1247     model EO
    1248         extends ExternalObject;
    1249         function constructor
    1250             input Real x;
    1251             output EO eo;
    1252             external;
    1253         end constructor;
    1254         function destructor
    1255             input EO eo;
    1256             external;
    1257         end destructor;
    1258     end EO;
    1259    
    1260     function f
    1261         input EO x;
    1262         output Real y;
    1263         external;
    1264     end f;
    1265    
    1266     function g
    1267         input EO x;
    1268         output EO y = x;
    1269     algorithm
    1270         annotation(Inline=false);
    1271     end g;
    1272    
    1273     constant Real x = 1;
    1274     constant EO eo = EO(x);
    1275     constant EO eo1 = g(eo);
    1276     Real y = f(eo1);
    1277    
    1278     annotation(__JModelica(UnitTesting(tests={
    1279         FlatteningTestCase(
    1280             name="ExternalObjectConstant2",
    1281             description="",
    1282             flatModel="
    1283            
    1284 fclass VariabilityTests.ExternalObjectConstant2
    1285  constant Real x = 1;
    1286  Real y = VariabilityTests.ExternalObjectConstant2.f(global(VariabilityTests.ExternalObjectConstant2.eo1));
    1287 package constant
    1288  constant VariabilityTests.ExternalObjectConstant2.EO VariabilityTests.ExternalObjectConstant2.eo = VariabilityTests.ExternalObjectConstant2.EO.constructor(1.0);
    1289  constant VariabilityTests.ExternalObjectConstant2.EO VariabilityTests.ExternalObjectConstant2.eo1 = VariabilityTests.ExternalObjectConstant2.g(global(VariabilityTests.ExternalObjectConstant2.eo));
    1290 
    1291 public
    1292  function VariabilityTests.ExternalObjectConstant2.EO.destructor
    1293   input VariabilityTests.ExternalObjectConstant2.EO eo;
    1294  algorithm
    1295   external \"C\" destructor(eo);
    1296   return;
    1297  end VariabilityTests.ExternalObjectConstant2.EO.destructor;
    1298 
    1299  function VariabilityTests.ExternalObjectConstant2.EO.constructor
    1300   input Real x;
    1301   output VariabilityTests.ExternalObjectConstant2.EO eo;
    1302  algorithm
    1303   external \"C\" eo = constructor(x);
    1304   return;
    1305  end VariabilityTests.ExternalObjectConstant2.EO.constructor;
    1306 
    1307  function VariabilityTests.ExternalObjectConstant2.g
    1308   input VariabilityTests.ExternalObjectConstant2.EO x;
    1309   output VariabilityTests.ExternalObjectConstant2.EO y;
    1310  algorithm
    1311   y := x;
    1312   return;
    1313  annotation(Inline = false);
    1314  end VariabilityTests.ExternalObjectConstant2.g;
    1315 
    1316  function VariabilityTests.ExternalObjectConstant2.f
    1317   input VariabilityTests.ExternalObjectConstant2.EO x;
    1318   output Real y;
    1319  algorithm
    1320   external \"C\" y = f(x);
    1321   return;
    1322  end VariabilityTests.ExternalObjectConstant2.f;
    1323 
    1324  type VariabilityTests.ExternalObjectConstant2.EO = ExternalObject;
    1325 end VariabilityTests.ExternalObjectConstant2;
    1326 ")})));
    1327 end ExternalObjectConstant2;
    1328 
    1329 model ExternalObjectGlobalConstant1
    1330    
    1331     package P
    1332         model EO
    1333             extends ExternalObject;
    1334             function constructor
    1335                 input Real x;
    1336                 output EO eo;
    1337                 external;
    1338             end constructor;
    1339             function destructor
    1340                 input EO eo;
    1341                 external;
    1342             end destructor;
    1343         end EO;
    1344        
    1345         function f
    1346             output Real y;
    1347             external "C" y = f(eo1);
    1348         end f;
    1349        
    1350         constant Real x = 1;
    1351         constant EO eo = EO(x);
    1352         constant EO eo1 = eo;
    1353     end P;
    1354    
    1355     function f
    1356         input Real x;
    1357         output Real y = x + P.f();
    1358     algorithm
    1359     end f;
    1360 
    1361     Real y = f(time);
    1362 
    1363     annotation(__JModelica(UnitTesting(tests={
    1364         FlatteningTestCase(
    1365             name="ExternalObjectGlobalConstant1",
    1366             description="",
    1367             flatModel="
    1368 fclass VariabilityTests.ExternalObjectGlobalConstant1
    1369  Real y = VariabilityTests.ExternalObjectGlobalConstant1.f(time);
    1370 package constant
    1371  constant VariabilityTests.ExternalObjectGlobalConstant1.P.EO VariabilityTests.ExternalObjectGlobalConstant1.P.eo = VariabilityTests.ExternalObjectGlobalConstant1.P.EO.constructor(1.0);
    1372  constant VariabilityTests.ExternalObjectGlobalConstant1.P.EO VariabilityTests.ExternalObjectGlobalConstant1.P.eo1 = global(VariabilityTests.ExternalObjectGlobalConstant1.P.eo);
    1373 
    1374 public
    1375  function VariabilityTests.ExternalObjectGlobalConstant1.f
    1376   input Real x;
    1377   output Real y;
    1378  algorithm
    1379   y := x + VariabilityTests.ExternalObjectGlobalConstant1.P.f();
    1380   return;
    1381  end VariabilityTests.ExternalObjectGlobalConstant1.f;
    1382 
    1383  function VariabilityTests.ExternalObjectGlobalConstant1.P.f
    1384   output Real y;
    1385  algorithm
    1386   external \"C\" y = f(global(VariabilityTests.ExternalObjectGlobalConstant1.P.eo1));
    1387   return;
    1388  end VariabilityTests.ExternalObjectGlobalConstant1.P.f;
    1389 
    1390  function VariabilityTests.ExternalObjectGlobalConstant1.P.EO.destructor
    1391   input VariabilityTests.ExternalObjectGlobalConstant1.P.EO eo;
    1392  algorithm
    1393   external \"C\" destructor(eo);
    1394   return;
    1395  end VariabilityTests.ExternalObjectGlobalConstant1.P.EO.destructor;
    1396 
    1397  function VariabilityTests.ExternalObjectGlobalConstant1.P.EO.constructor
    1398   input Real x;
    1399   output VariabilityTests.ExternalObjectGlobalConstant1.P.EO eo;
    1400  algorithm
    1401   external \"C\" eo = constructor(x);
    1402   return;
    1403  end VariabilityTests.ExternalObjectGlobalConstant1.P.EO.constructor;
    1404 
    1405  type VariabilityTests.ExternalObjectGlobalConstant1.P.EO = ExternalObject;
    1406 end VariabilityTests.ExternalObjectGlobalConstant1;
    1407 ")})));
    1408 end ExternalObjectGlobalConstant1;
    1409 
    1410 model ExternalObjectGlobalConstant2
    1411     model EO
    1412         extends ExternalObject;
    1413         function constructor
    1414             input Real x;
    1415             output EO eo;
    1416             external;
    1417         end constructor;
    1418         function destructor
    1419             input EO eo;
    1420             external;
    1421         end destructor;
    1422     end EO;
    1423    
    1424     function f
    1425         input EO x;
    1426         output Real y;
    1427         external;
    1428     end f;
    1429    
    1430     record R
    1431         EO eo;
    1432     end R;
    1433    
    1434     package P
    1435         constant Real x = 1;
    1436         constant EO[:] eo = {EO(x)};
    1437     end P;
    1438    
    1439     Real y1 = f(P.eo[1]);
    1440 
    1441     annotation(__JModelica(UnitTesting(tests={
    1442         ComplianceErrorTestCase(
    1443             name="ExternalObjectGlobalConstant2",
    1444             description="",
    1445             errorMessage="
    1446 Compliance error at line 27, column 9, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE:
    1447   Access to external object constants in arrays or records is not supported
    1448 
    1449 Compliance error at line 30, column 17, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE:
    1450   Access to external object constants in arrays or records is not supported
    1451 
    1452 Compliance error at line 30, column 19, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE:
    1453   Access to external object constants in arrays or records is not supported
    1454 ")})));
    1455 end ExternalObjectGlobalConstant2;
    1456 
    1457 model ExternalObjectGlobalConstant3
    1458     model EO
    1459         extends ExternalObject;
    1460         function constructor
    1461             input Real x;
    1462             output EO eo;
    1463             external;
    1464         end constructor;
    1465         function destructor
    1466             input EO eo;
    1467             external;
    1468         end destructor;
    1469     end EO;
    1470    
    1471     function f
    1472         input EO x;
    1473         output Real y;
    1474         external;
    1475     end f;
    1476    
    1477     record R
    1478         EO eo;
    1479     end R;
    1480    
    1481     package P
    1482         constant Real x = 1;
    1483         constant R r = R(EO(x));
    1484     end P;
    1485    
    1486     Real y2 = f(P.r.eo);
    1487 
    1488     annotation(__JModelica(UnitTesting(tests={
    1489         ComplianceErrorTestCase(
    1490             name="ExternalObjectGlobalConstant3",
    1491             description="",
    1492             errorMessage="
    1493 Compliance error at line 22, column 9, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE,
    1494 In component r:
    1495   Access to external object constants in arrays or records is not supported
    1496 
    1497 Compliance error at line 30, column 17, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE:
    1498   Access to external object constants in arrays or records is not supported
    1499 
    1500 Compliance error at line 30, column 21, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE:
    1501   Access to external object constants in arrays or records is not supported
    1502 ")})));
    1503 end ExternalObjectGlobalConstant3;
    1504 
    1505 
    15061179end VariabilityTests;
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/Globals.jrag

    r11578 r11631  
    188188    }
    189189   
    190     @Override
    191     public void FExternalObjectType.markUsedGlobals(Global.UseType type) {
    192         super.markUsedGlobals(type);
    193         getConstructor().myFCallable().markUsedGlobals(type);
    194         getDestructor ().myFCallable().markUsedGlobals(type);
    195     }
    196    
    197190    public void Size.markUsedGlobals(Global.UseType type) {
    198191       
     
    226219   
    227220    @Override
    228     public void FGlobalAccessExp.markUsedGlobals(Global.UseType type) {
    229         super.markUsedGlobals(type);
    230         getCommonAccess().asFAccess().myTopFV().markUsedGlobalVariable(type);
     221    public void FAccess.markUsedGlobals(Global.UseType type) {
     222        super.markUsedGlobals(type);
     223        myTopFV().markUsedGlobalVariable(type);
    231224    }
    232225   
     
    234227    public void FGlobalVariable.markUsedGlobalVariable(Global.UseType type) {
    235228        if (global().update(type)) {
    236             markUsedGlobals(type);
    237             //type().markUsedGlobals(type);
     229            super.markUsedGlobals(type);
    238230        }
    239231    }
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/InlineFunctions.jrag

    r11611 r11631  
    15511551    }
    15521552
    1553     @Override
    1554     public FExp FGlobalAccessExp.replaceReferences(AbstractFunctionInliner fi) {
    1555         replaceReferencesInSubscripts(fi);
    1556         return this;
    1557     }
    15581553
    15591554    public FIdUseExp FIdUseExp.copyWithNonLiteralSubscriptsAsColon() {
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/Scalarization.jrag

    r11611 r11631  
    14591459        String fin = myFV().myForIndexName();
    14601460        if (fin != null) {
    1461             return setLocationOf(createNode(new FAccessString(fin)));
    1462         }
    1463         return setLocationOf(createNode(getCommonAccess().asFAccess().scalarize(s, indexNames)));
     1461            return setLocationOf(new FIdUseExp(fin));
     1462        }
     1463        return setLocationOf(new FIdUseExp(getCommonAccess().asFAccess().scalarize(s, indexNames)));
    14641464    }
    14651465
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/FunctionInlining.mo

    r11581 r11631  
    50515051 parameter Integer temp_2;
    50525052 parameter Real y.x;
    5053 package constant
    5054  constant FunctionInlining.GlobalConst2.R2 FunctionInlining.GlobalConst2.f.a = FunctionInlining.GlobalConst2.R2({FunctionInlining.GlobalConst2.R1(2), FunctionInlining.GlobalConst2.R1(3)});
    50555053parameter equation
    50565054 temp_2 = integer(time);
    5057  y.x = global(FunctionInlining.GlobalConst2.f.a.r1[temp_2].x);
    5058 
    5059 public
    5060  record FunctionInlining.GlobalConst2.R1
    5061   parameter Real x;
    5062  end FunctionInlining.GlobalConst2.R1;
    5063 
    5064  record FunctionInlining.GlobalConst2.R2
    5065   parameter FunctionInlining.GlobalConst2.R1 r1[2];
    5066  end FunctionInlining.GlobalConst2.R2;
    5067 
     5055 y.x = ({2, 3})[temp_2];
    50685056end FunctionInlining.GlobalConst2;
    50695057")})));
    50705058end GlobalConst2;
    50715059
    5072 model GlobalConst3
    5073     constant R1[1] r = {R1(2)};
    5074     record R1
    5075         parameter Real x;
    5076     end R1;
    5077     function f
    5078         input Integer i;
    5079         output Real y = 1 + r[i].x;
    5080     algorithm
    5081     end f;
    5082    
    5083     Real y = f(integer(time));
    5084 
    5085     annotation(__JModelica(UnitTesting(tests={
    5086         TransformCanonicalTestCase(
    5087             name="GlobalConst3",
    5088             description="Inlining global constant",
    5089             variability_propagation=false,
    5090             flatModel="
    5091 fclass FunctionInlining.GlobalConst3
    5092  constant Real r[1].x = 2;
    5093  Real y;
    5094  discrete Integer temp_1;
    5095 package constant
    5096  constant FunctionInlining.GlobalConst3.R1 FunctionInlining.GlobalConst3.r[1] = {FunctionInlining.GlobalConst3.R1(2)};
    5097 initial equation
    5098  pre(temp_1) = 0;
    5099 equation
    5100  y = 1 + global(FunctionInlining.GlobalConst3.r[temp_1].x);
    5101  temp_1 = if time < pre(temp_1) or time >= pre(temp_1) + 1 or initial() then integer(time) else pre(temp_1);
    5102 
    5103 public
    5104  record FunctionInlining.GlobalConst3.R1
    5105   parameter Real x;
    5106  end FunctionInlining.GlobalConst3.R1;
    5107 
    5108 end FunctionInlining.GlobalConst3;
    5109 ")})));
    5110 end GlobalConst3;
    5111 
    5112 model GlobalConstExtObj1
    5113     package P
    5114         model EO
    5115             extends ExternalObject;
    5116             function constructor
    5117                 input Real[:] x;
    5118                 output EO eo;
    5119                 external;
    5120             end constructor;
    5121             function destructor
    5122                 input EO eo;
    5123                 external;
    5124             end destructor;
    5125         end EO;
    5126        
    5127         function f
    5128             input EO eo;
    5129             output Real y;
    5130             external;
    5131         end f;
    5132        
    5133         constant Real x = 1;
    5134         constant EO eo = EO({x});
    5135         constant EO eo1 = eo;
    5136     end P;
    5137    
    5138     function f
    5139         input Real x;
    5140         input P.EO eo;
    5141         output Real y = x + P.f(eo);
    5142     algorithm
    5143     end f;
    5144 
    5145     Real y = f(time, P.eo1);
    5146 
    5147 
    5148     annotation(__JModelica(UnitTesting(tests={
    5149         TransformCanonicalTestCase(
    5150             name="GlobalConstExtObj1",
    5151             description="Inlining global constant",
    5152             variability_propagation=false,
    5153             flatModel="
    5154 fclass FunctionInlining.GlobalConstExtObj1
    5155  Real y;
    5156 package constant
    5157  constant FunctionInlining.GlobalConstExtObj1.P.EO FunctionInlining.GlobalConstExtObj1.P.eo = FunctionInlining.GlobalConstExtObj1.P.EO.constructor({1.0});
    5158  constant FunctionInlining.GlobalConstExtObj1.P.EO FunctionInlining.GlobalConstExtObj1.P.eo1 = global(FunctionInlining.GlobalConstExtObj1.P.eo);
    5159 equation
    5160  y = time + FunctionInlining.GlobalConstExtObj1.P.f(global(FunctionInlining.GlobalConstExtObj1.P.eo1));
    5161 
    5162 public
    5163  function FunctionInlining.GlobalConstExtObj1.P.EO.destructor
    5164   input FunctionInlining.GlobalConstExtObj1.P.EO eo;
    5165  algorithm
    5166   external \"C\" destructor(eo);
    5167   return;
    5168  end FunctionInlining.GlobalConstExtObj1.P.EO.destructor;
    5169 
    5170  function FunctionInlining.GlobalConstExtObj1.P.EO.constructor
    5171   input Real[:] x;
    5172   output FunctionInlining.GlobalConstExtObj1.P.EO eo;
    5173  algorithm
    5174   external \"C\" eo = constructor(x, size(x, 1));
    5175   return;
    5176  end FunctionInlining.GlobalConstExtObj1.P.EO.constructor;
    5177 
    5178  function FunctionInlining.GlobalConstExtObj1.P.f
    5179   input FunctionInlining.GlobalConstExtObj1.P.EO eo;
    5180   output Real y;
    5181  algorithm
    5182   external \"C\" y = f(eo);
    5183   return;
    5184  end FunctionInlining.GlobalConstExtObj1.P.f;
    5185 
    5186  type FunctionInlining.GlobalConstExtObj1.P.EO = ExternalObject;
    5187 end FunctionInlining.GlobalConstExtObj1;
    5188 ")})));
    5189 end GlobalConstExtObj1;
    5190 
    51915060end FunctionInlining;
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/VariabilityPropagationTests.mo

    r11578 r11631  
    25832583end StringVariable1;
    25842584
    2585 model ExternalObjectConstant1
    2586     model EO
    2587         extends ExternalObject;
    2588         function constructor
    2589             input Real x;
    2590             output EO eo;
    2591             external;
    2592         end constructor;
    2593         function destructor
    2594             input EO eo;
    2595             external;
    2596         end destructor;
    2597     end EO;
    2598    
    2599     function f
    2600         input EO x;
    2601         output Real y;
    2602         external;
    2603     end f;
    2604    
    2605     constant Real x = 1;
    2606     constant EO eo = EO(x);
    2607     Real y = f(eo);
    2608 
    2609     annotation(__JModelica(UnitTesting(tests={
    2610         TransformCanonicalTestCase(
    2611             name="ExternalObjectConstant1",
    2612             description="",
    2613             flatModel="
    2614            
    2615 fclass VariabilityPropagationTests.ExternalObjectConstant1
    2616  constant Real x = 1;
    2617  parameter Real y;
    2618 package constant
    2619  constant VariabilityPropagationTests.ExternalObjectConstant1.EO VariabilityPropagationTests.ExternalObjectConstant1.eo = VariabilityPropagationTests.ExternalObjectConstant1.EO.constructor(1.0);
    2620 parameter equation
    2621  y = VariabilityPropagationTests.ExternalObjectConstant1.f(global(VariabilityPropagationTests.ExternalObjectConstant1.eo));
    2622 
    2623 public
    2624  function VariabilityPropagationTests.ExternalObjectConstant1.EO.destructor
    2625   input VariabilityPropagationTests.ExternalObjectConstant1.EO eo;
    2626  algorithm
    2627   external \"C\" destructor(eo);
    2628   return;
    2629  end VariabilityPropagationTests.ExternalObjectConstant1.EO.destructor;
    2630 
    2631  function VariabilityPropagationTests.ExternalObjectConstant1.EO.constructor
    2632   input Real x;
    2633   output VariabilityPropagationTests.ExternalObjectConstant1.EO eo;
    2634  algorithm
    2635   external \"C\" eo = constructor(x);
    2636   return;
    2637  end VariabilityPropagationTests.ExternalObjectConstant1.EO.constructor;
    2638 
    2639  function VariabilityPropagationTests.ExternalObjectConstant1.f
    2640   input VariabilityPropagationTests.ExternalObjectConstant1.EO x;
    2641   output Real y;
    2642  algorithm
    2643   external \"C\" y = f(x);
    2644   return;
    2645  end VariabilityPropagationTests.ExternalObjectConstant1.f;
    2646 
    2647  type VariabilityPropagationTests.ExternalObjectConstant1.EO = ExternalObject;
    2648 end VariabilityPropagationTests.ExternalObjectConstant1;
    2649 ")})));
    2650 end ExternalObjectConstant1;
    2651 
    2652 model ExternalObjectConstant2
    2653     model EO
    2654         extends ExternalObject;
    2655         function constructor
    2656             input Real x;
    2657             output EO eo;
    2658             external;
    2659         end constructor;
    2660         function destructor
    2661             input EO eo;
    2662             external;
    2663         end destructor;
    2664     end EO;
    2665    
    2666     function f
    2667         input EO x;
    2668         output Real y;
    2669         external;
    2670     end f;
    2671    
    2672     function g
    2673         input EO x;
    2674         output EO y = x;
    2675     algorithm
    2676         annotation(Inline=false);
    2677     end g;
    2678    
    2679     constant Real x = 1;
    2680     constant EO eo = EO(x);
    2681     Real y = f(g(eo));
    2682 
    2683     annotation(__JModelica(UnitTesting(tests={
    2684         TransformCanonicalTestCase(
    2685             name="ExternalObjectConstant2",
    2686             description="",
    2687             flatModel="
    2688 fclass VariabilityPropagationTests.ExternalObjectConstant2
    2689  constant Real x = 1;
    2690  parameter Real y;
    2691 package constant
    2692  constant VariabilityPropagationTests.ExternalObjectConstant2.EO VariabilityPropagationTests.ExternalObjectConstant2.eo = VariabilityPropagationTests.ExternalObjectConstant2.EO.constructor(1.0);
    2693 parameter equation
    2694  y = VariabilityPropagationTests.ExternalObjectConstant2.f(VariabilityPropagationTests.ExternalObjectConstant2.g(global(VariabilityPropagationTests.ExternalObjectConstant2.eo)));
    2695 
    2696 public
    2697  function VariabilityPropagationTests.ExternalObjectConstant2.EO.destructor
    2698   input VariabilityPropagationTests.ExternalObjectConstant2.EO eo;
    2699  algorithm
    2700   external \"C\" destructor(eo);
    2701   return;
    2702  end VariabilityPropagationTests.ExternalObjectConstant2.EO.destructor;
    2703 
    2704  function VariabilityPropagationTests.ExternalObjectConstant2.EO.constructor
    2705   input Real x;
    2706   output VariabilityPropagationTests.ExternalObjectConstant2.EO eo;
    2707  algorithm
    2708   external \"C\" eo = constructor(x);
    2709   return;
    2710  end VariabilityPropagationTests.ExternalObjectConstant2.EO.constructor;
    2711 
    2712  function VariabilityPropagationTests.ExternalObjectConstant2.f
    2713   input VariabilityPropagationTests.ExternalObjectConstant2.EO x;
    2714   output Real y;
    2715  algorithm
    2716   external \"C\" y = f(x);
    2717   return;
    2718  end VariabilityPropagationTests.ExternalObjectConstant2.f;
    2719 
    2720  function VariabilityPropagationTests.ExternalObjectConstant2.g
    2721   input VariabilityPropagationTests.ExternalObjectConstant2.EO x;
    2722   output VariabilityPropagationTests.ExternalObjectConstant2.EO y;
    2723  algorithm
    2724   y := x;
    2725   return;
    2726  annotation(Inline = false);
    2727  end VariabilityPropagationTests.ExternalObjectConstant2.g;
    2728 
    2729  type VariabilityPropagationTests.ExternalObjectConstant2.EO = ExternalObject;
    2730 end VariabilityPropagationTests.ExternalObjectConstant2;
    2731 ")})));
    2732 end ExternalObjectConstant2;
    2733 
    2734 
    27352585end VariabilityPropagationTests;
Note: See TracChangeset for help on using the changeset viewer.