Changeset 11639


Ignore:
Timestamp:
Sep 21, 2018 11:45:16 AM (15 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Recommiting r11578,r11581,r11596 by reverting r11631

Location:
trunk/Compiler
Files:
28 edited

Legend:

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

    r11631 r11639  
    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       
    698706        String type = myFV().funcArrayType(isAssignUse());
    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         }
     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;
    704719    }
    705720
     
    729744    public void FArraySubscripts.prettyPrint_C(CodePrinter p, CodeStream str, String indent) {
    730745        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;
    757746    }
    758747
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r11631 r11639  
    283283                ArrayList<FGlobalVariable> globals = new ArrayList<>();
    284284                for (FGlobalVariable fv : fclass.getFGlobalVariables()) {
    285                     fv.getBindingExp().genGlobalVariableInit_C(p, str, indent);
     285                    fv.getBindingExp().genGlobalVariableInitFunc_C(p, str, indent, false);
    286286                    globals.add(fv);
    287287                }
     
    295295                    @Override
    296296                    public void gen(FGlobalVariable element) {
    297                         element.genGlobalVariableInit_C(p, str, indent);
     297                        element.genGlobalVariableInitCall_C(p, str, indent);
    298298                    }
    299299                };
     
    313313    }
    314314
    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);
     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        }
    331328       
    332329        String next = p.indent(indent);
    333         str.print(indent, type().nameScalar_C(p), "* jmi_global_", tempName_C(), "(jmi_t* jmi) {\n");
     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");
    334335        str.print(next, "JMI_DYNAMIC_INIT()\n");
    335336       
    336         String typeName = type().nameScalar_C(p);
    337         str.print(next, typeName, "* ", tempName_C(), ";\n");
     337        genGlobalVariableInitFuncDecl_C(p, str, next);
    338338       
    339339        str.print(next, "JMI_GLOBALS_INIT()\n");
    340340       
    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);
     341        genGlobalVariableInitFuncInit_C(p, str, next);
    344342       
    345343        str.print(next, "JMI_GLOBALS_FREE()\n");
     
    348346        str.print(indent, "}\n\n");
    349347    }
    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(",
     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(",
    361380                "DYNA", ", ",
    362381                type().nameScalar_C(p, false), ", ",
    363382                type().nameArray_C(p, false), ", ",
    364383                tempName_C(), ", ");
    365         type().size().printNumElements_C(p, str, next, this);
     384        type().size().printNumElements_C(p, str, indent, this);
    366385        str.print(", ");
    367386        str.print(type().ndims());
    368387        str.print(")\n");
    369        
    370         str.print(next, "JMI_GLOBALS_INIT()\n");
    371        
    372         str.print(next, "JMI_ARRAY_INIT_", ndims(), "(",
     388    }
     389
     390    @Override
     391    public void FArray.genGlobalVariableInitFuncInit_C(CodePrinter p, CodeStream str, String indent) {
     392        str.print(indent, "JMI_ARRAY_INIT_", ndims(), "(",
    373393                "DYNA", ", ",
    374394                type().nameScalar_C(p, false), ", ",
    375395                type().nameArray_C(p, false), ", ",
    376396                tempName_C(), ", ");
    377         type().size().printNumElements_C(p, str, next, this);
     397        type().size().printNumElements_C(p, str, indent, this);
    378398        str.print(", ");
    379399        str.print(type().ndims());
    380400        str.print(", ");
    381         type().size().printDimensions_C(p, str, next, this);
     401        type().size().printDimensions_C(p, str, indent, this);
    382402        str.print(")\n");
    383403       
     
    388408            String cellName = pre + i.toUnclosedString() + ")";
    389409            FExp cellExp = fArrayCell(i, 0);
    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()) {
     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()) {;
    405417            str.print(indent, name, " = ");
    406418            p.print(this, str, indent);
     
    409421    }
    410422
    411     public void FRecordConstructor.genGlobalVariableInitScalar_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
     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) {
    412432        if (expand) {
    413433            for (FRecordComponentType comp : getRecord().recordType().getComponents()) {
    414434                String compName = name + "->" + comp.getName();
    415435                FExp compExp = component(comp.getName());
    416                 compExp.genGlobalVariableInitScalar_C(p, str, indent, compName, false);
     436                compExp.genGlobalVariableInitCall_C(p, str, indent, compName, false);
    417437            }
    418438        } else {
    419             super.genGlobalVariableInitScalar_C(p, str, indent, name, expand);
     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");
    420458        }
    421459    }
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CGenerator.jrag

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

    r11631 r11639  
    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 ^ 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 ^ global(CCodeGenGlobalsTests.GlobalVariables.GlobalConstantForPowInt1.f.c[i])\");
    19841984    }
    19851985    JMI_RET(GEN, y_o, y_v)
     
    21952195end GlobalConstantRef2;
    21962196
     2197model 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
     2211annotation(__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
     2224R1_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
     2235int 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
     2243int jmi_set_globals_start_0(jmi_t* jmi);
     2244
     2245int 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
     2255int 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")})));
     2271end GlobalConstantRef3;
     2272
     2273model 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
     2307annotation(__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
     2321jmi_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
     2334int 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
     2343int jmi_set_globals_start_0(jmi_t* jmi);
     2344
     2345int 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
     2353void 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
     2363jmi_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
     2369void 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
     2377void 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
     2387jmi_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")})));
     2397end GlobalConstantExternalObject1;
     2398
    21972399end GlobalVariables;
    21982400
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenTests.mo

    r11631 r11639  
    1162711627end BlockTest24;
    1162811628
     11629model 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
     11651annotation(__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="
     11658static 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")})));
     11681end BlockTest25;
     11682
    1162911683model NestedUnsolvedScalarInSolvedBlock
    1163011684    Real a;
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

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

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

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

    r11631 r11639  
    7373            res = variablesMap().lookup(name);
    7474        }
    75         if (res == null) {
    76             res = lookupGlobalVariable(name);
    77         }
    7875        return nullUnknown(res);
    7976    }
    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);
    8477
    8578    private FlatVariableMap FFunctionDecl.tempLookupMap = null;
     
    135128        }
    136129    }
    137 
    138     syn FAbstractVariable FAccess.myFV() = lookupFV(name());
     130    syn FAbstractVariable FAccess.myFV();
     131    eq FAccess    .myFV() = isGlobalAccess() ? lookupGlobalVariable(name()) : lookupFV(name());
    139132    eq FAccessFull.myFV() = getFAccessPart(getNumFAccessPart() - 1).myFV();
    140133
     
    147140        FAbstractVariable res = myContextFV();
    148141        if (res == null) {
    149             res = lookupFV(name());
     142            if (isGlobalAccess()) {
     143                res = lookupGlobalVariable(name());
     144            } else {
     145                res = lookupFV(name());
     146            }
    150147        } else if (!res.isUnknown()) {
    151148            res = res.myFRecordDecl().lookupFV(name());
     
    157154    eq FAccessFull.getFAccessPart(int i).myContextFV() =
    158155            i == 0 ? null : getFAccessPart(i - 1).myFV();
    159    
     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
    160168    syn boolean CommonAccess.isForIndex();
    161169    syn boolean FIdUseExp.isForIndex() = getCommonAccess().isForIndex();
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r11631 r11639  
    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    }
    16471653   
    16481654    public void InstAccess.prettyPrint(Printer p, CodeStream str, String indent) {
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

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

    r11631 r11639  
    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_FROM_FUNCTION =
    94             new SimpleErrorProducer("EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION", ProblemKind.COMPLIANCE, "Access to external object constants is not supported in functions");
     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");
    9595   
    9696
     
    102102            ONLY_FMU_NON_FIXED_RECORD_ARRAY_INDEX.invoke(this);
    103103        }
    104         if (decl.isExternalObject() && !decl.inFunction() && decl.getSrcComponentDecl().isConstant() && inFunction()) {
    105             EXTERNAL_OBJECT_CONSTANT_FROM_FUNCTION.invoke(this);
     104        if (decl.isExternalObject() && decl.isConstant() && (decl.inRecord() || decl.isArray())) {
     105            EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE.invoke(this);
    106106        }
    107107    }
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r11631 r11639  
    844844    @Override
    845845    public void InstAssignable.flattenInFunction(Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts) {
    846         if (!flattenAsFunctionConstant()) {
     846        if (!flattenAsGlobalVariableFromFunction()) {
    847847            if (hasInstValueMod())
    848848                getBindingFExp().flattenUsedFuncsAndEnums(f);
     
    12281228
    12291229    public void InstAssignable.flatten(Flattener f, FlattenBindingExp binding, int level, boolean global) {
    1230         if (useInFlattening()) {
     1230        if (useInFlattening() && (global || !flattenAsGlobalVariable())) {
    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);
    17891787                if (cval.hasBuildLiteral()) {
    1790                     return cval.buildLiteral();
     1788                    FExp t = dynamicFExp(cval.buildInstLiteral());
     1789                    t.flattenUsedFuncsAndEnums(f);
     1790                    FExp res = t.flatten(f);
     1791                    clearDynamicFExp();
     1792                    return res;
    17911793                }
    17921794            }
     
    25152517
    25162518    public FExp FLitExp.flatten(Flattener f)     { return fullCopy(); }
    2517     public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), null); }
     2519    public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), new Opt<FEnumType>()); }
    25182520   
    25192521    public FExp FModFuncExp.flatten(Flattener f) {
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningAccess.jrag

    r11631 r11639  
    241241            }
    242242        }
    243         if (ia.inFunction() && flattenAsFunctionConstant()) {
     243        if (ia.flattenAsGlobalAccess()) {
    244244            InstAssignable top = ia.topInstAssignable();
    245245            if (!f.isFlattenedGlobalVariable(top)) {
    246246                top.flatten(f, FlattenBindingExp.ALL, 0, true);
    247247            }
    248             return new FIdUseExp(ia.flatten().copyAndPrepend(top.surroundingInstClass().qualifiedName()));
     248            return new FGlobalAccessExp(ia.flatten().copyAndPrepend(top.surroundingInstClass().qualifiedName()), (String)null);
    249249        }
    250250        return null;
    251251    }
    252252
    253     syn boolean InstAssignable.flattenAsFunctionConstant() =
    254             !isInput() && !isOutput() && variability().knownParameterOrLess();
     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();
    255260
    256261    /**
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstTypeAnalysis.jrag

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

    r11631 r11639  
    6262    eq UnknownInstComponentDecl.calcVariability() = Variability.CONSTANT;
    6363    eq InstAssignable.calcVariability()           = calcVariability(super.calcVariability());
    64     eq InstExternalObject.calcVariability()                        = calcVariability(Variability.FIXEDPARAMETER)
    65                 .combine(Variability.FIXEDPARAMETER).combineDown(Variability.INITIALPARAMETER);
     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    }
    6671   
    6772    // Parameters variabilities also depend on binding expressions since its nice
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

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

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

    r11631 r11639  
    739739end ExtObjInFunction1;
    740740
    741 model 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="
    781 1 errors found:
    782 
    783 Compliance 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 ")})));
    786 end ExtObjInFunction2;
    787 
    788 
    789741model DeprecatedDecoupleTest1
    790742    Real x[2] = time * (1:2);
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/FunctionTests.mo

    r11631 r11639  
    494494 algorithm
    495495  init y as Real[2];
    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);
     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);
    500500 end FunctionTests.FunctionFlatten9.f;
    501501
     
    10091009  output Real y;
    10101010 algorithm
    1011   y := FunctionTests.FunctionFlatten21.f.x;
     1011  y := global(FunctionTests.FunctionFlatten21.f.x);
    10121012  return;
    10131013 end FunctionTests.FunctionFlatten21.f;
     
    10921092 algorithm
    10931093  for i in 1:1 loop
    1094    y := FunctionTests.FunctionFlatten23.f.r.a[i] * x;
     1094   y := global(FunctionTests.FunctionFlatten23.f.r.a[i]) * x;
    10951095  end for;
    10961096  return;
     
    1031210312  output Real y1;
    1031310313 algorithm
    10314   y1 := FunctionTests.UnknownArray29.f2({FunctionTests.UnknownArray29.a[i], FunctionTests.UnknownArray29.a[i + 1]});
    10315   return;
    10316  annotation(Inline=false);
     10314  y1 := FunctionTests.UnknownArray29.f2({global(FunctionTests.UnknownArray29.a[i]), global(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 + FunctionTests.ExtendFunc2.d[c];
     12493  f := a + global(FunctionTests.ExtendFunc2.d[c]);
    1249412494  b := f;
    1249512495  return;
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo

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

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

    r11631 r11639  
    11771177end RecordVariabilityScalarization1;
    11781178
     1179model 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="
     1210fclass VariabilityTests.ExternalObjectConstant1
     1211 constant Real x = 1;
     1212 Real y = VariabilityTests.ExternalObjectConstant1.f(global(VariabilityTests.ExternalObjectConstant1.eo1));
     1213package 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
     1217public
     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;
     1242end VariabilityTests.ExternalObjectConstant1;
     1243")})));
     1244end ExternalObjectConstant1;
     1245
     1246model 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           
     1284fclass VariabilityTests.ExternalObjectConstant2
     1285 constant Real x = 1;
     1286 Real y = VariabilityTests.ExternalObjectConstant2.f(global(VariabilityTests.ExternalObjectConstant2.eo1));
     1287package 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
     1291public
     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;
     1325end VariabilityTests.ExternalObjectConstant2;
     1326")})));
     1327end ExternalObjectConstant2;
     1328
     1329model 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="
     1368fclass VariabilityTests.ExternalObjectGlobalConstant1
     1369 Real y = VariabilityTests.ExternalObjectGlobalConstant1.f(time);
     1370package 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
     1374public
     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;
     1406end VariabilityTests.ExternalObjectGlobalConstant1;
     1407")})));
     1408end ExternalObjectGlobalConstant1;
     1409
     1410model 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="
     1446Compliance 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
     1449Compliance 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
     1452Compliance 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")})));
     1455end ExternalObjectGlobalConstant2;
     1456
     1457model 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="
     1493Compliance error at line 22, column 9, in file '...', EXTERNAL_OBJECT_CONSTANT_IN_COMPOSITE,
     1494In component r:
     1495  Access to external object constants in arrays or records is not supported
     1496
     1497Compliance 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
     1500Compliance 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")})));
     1503end ExternalObjectGlobalConstant3;
     1504
     1505
    11791506end VariabilityTests;
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/Globals.jrag

    r11631 r11639  
    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   
    190197    public void Size.markUsedGlobals(Global.UseType type) {
    191198       
     
    219226   
    220227    @Override
    221     public void FAccess.markUsedGlobals(Global.UseType type) {
    222         super.markUsedGlobals(type);
    223         myTopFV().markUsedGlobalVariable(type);
     228    public void FGlobalAccessExp.markUsedGlobals(Global.UseType type) {
     229        super.markUsedGlobals(type);
     230        getCommonAccess().asFAccess().myTopFV().markUsedGlobalVariable(type);
    224231    }
    225232   
     
    227234    public void FGlobalVariable.markUsedGlobalVariable(Global.UseType type) {
    228235        if (global().update(type)) {
    229             super.markUsedGlobals(type);
     236            markUsedGlobals(type);
     237            //type().markUsedGlobals(type);
    230238        }
    231239    }
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/InlineFunctions.jrag

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

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

    r11631 r11639  
    50515051 parameter Integer temp_2;
    50525052 parameter Real y.x;
     5053package constant
     5054 constant FunctionInlining.GlobalConst2.R2 FunctionInlining.GlobalConst2.f.a = FunctionInlining.GlobalConst2.R2({FunctionInlining.GlobalConst2.R1(2), FunctionInlining.GlobalConst2.R1(3)});
    50535055parameter equation
    50545056 temp_2 = integer(time);
    5055  y.x = ({2, 3})[temp_2];
     5057 y.x = global(FunctionInlining.GlobalConst2.f.a.r1[temp_2].x);
     5058
     5059public
     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
    50565068end FunctionInlining.GlobalConst2;
    50575069")})));
    50585070end GlobalConst2;
    50595071
     5072model 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="
     5091fclass FunctionInlining.GlobalConst3
     5092 constant Real r[1].x = 2;
     5093 Real y;
     5094 discrete Integer temp_1;
     5095package constant
     5096 constant FunctionInlining.GlobalConst3.R1 FunctionInlining.GlobalConst3.r[1] = {FunctionInlining.GlobalConst3.R1(2)};
     5097initial equation
     5098 pre(temp_1) = 0;
     5099equation
     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
     5103public
     5104 record FunctionInlining.GlobalConst3.R1
     5105  parameter Real x;
     5106 end FunctionInlining.GlobalConst3.R1;
     5107
     5108end FunctionInlining.GlobalConst3;
     5109")})));
     5110end GlobalConst3;
     5111
     5112model 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="
     5154fclass FunctionInlining.GlobalConstExtObj1
     5155 Real y;
     5156package 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);
     5159equation
     5160 y = time + FunctionInlining.GlobalConstExtObj1.P.f(global(FunctionInlining.GlobalConstExtObj1.P.eo1));
     5161
     5162public
     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;
     5187end FunctionInlining.GlobalConstExtObj1;
     5188")})));
     5189end GlobalConstExtObj1;
     5190
    50605191end FunctionInlining;
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/VariabilityPropagationTests.mo

    r11631 r11639  
    25832583end StringVariable1;
    25842584
     2585model 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           
     2615fclass VariabilityPropagationTests.ExternalObjectConstant1
     2616 constant Real x = 1;
     2617 parameter Real y;
     2618package constant
     2619 constant VariabilityPropagationTests.ExternalObjectConstant1.EO VariabilityPropagationTests.ExternalObjectConstant1.eo = VariabilityPropagationTests.ExternalObjectConstant1.EO.constructor(1.0);
     2620parameter equation
     2621 y = VariabilityPropagationTests.ExternalObjectConstant1.f(global(VariabilityPropagationTests.ExternalObjectConstant1.eo));
     2622
     2623public
     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;
     2648end VariabilityPropagationTests.ExternalObjectConstant1;
     2649")})));
     2650end ExternalObjectConstant1;
     2651
     2652model 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="
     2688fclass VariabilityPropagationTests.ExternalObjectConstant2
     2689 constant Real x = 1;
     2690 parameter Real y;
     2691package constant
     2692 constant VariabilityPropagationTests.ExternalObjectConstant2.EO VariabilityPropagationTests.ExternalObjectConstant2.eo = VariabilityPropagationTests.ExternalObjectConstant2.EO.constructor(1.0);
     2693parameter equation
     2694 y = VariabilityPropagationTests.ExternalObjectConstant2.f(VariabilityPropagationTests.ExternalObjectConstant2.g(global(VariabilityPropagationTests.ExternalObjectConstant2.eo)));
     2695
     2696public
     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;
     2730end VariabilityPropagationTests.ExternalObjectConstant2;
     2731")})));
     2732end ExternalObjectConstant2;
     2733
     2734
    25852735end VariabilityPropagationTests;
Note: See TracChangeset for help on using the changeset viewer.