Changeset 11578


Ignore:
Timestamp:
Sep 12, 2018 12:55:21 PM (15 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Basic support for external object package constants. Not including in arrays or records.

Location:
trunk/Compiler
Files:
25 edited

Legend:

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

    r11551 r11578  
    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

    r11541 r11578  
    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

    r11551 r11578  
    19811981    i_0ie = 2 + 1 / 2.0;
    19821982    for (i_0i = 1; i_0i < i_0ie; i_0i += 1) {
    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)
     
    21942194end GlobalConstantRef2;
    21952195
     2196model GlobalConstantExternalObject1
     2197   
     2198    package P
     2199        model EO
     2200            extends ExternalObject;
     2201            function constructor
     2202                input Real[:] x;
     2203                output EO eo;
     2204                external;
     2205            end constructor;
     2206            function destructor
     2207                input EO eo;
     2208                external;
     2209            end destructor;
     2210        end EO;
     2211       
     2212        function f
     2213            output Real y;
     2214            external "C" y = f(eo1);
     2215        end f;
     2216       
     2217        constant Real x = 1;
     2218        constant EO eo = EO({x});
     2219        constant EO eo1 = eo;
     2220    end P;
     2221   
     2222    function f
     2223        input Real x;
     2224        output Real y = x + P.f();
     2225    algorithm
     2226    end f;
     2227
     2228    Real y = f(time);
     2229
     2230annotation(__JModelica(UnitTesting(tests={
     2231    CCodeGenTestCase(
     2232        name="GlobalConstantExternalObject1",
     2233        description="",
     2234        template="
     2235$C_global_temps$
     2236$C_set_globals_start$
     2237$C_functions$
     2238$C_destruct_external_object$
     2239",
     2240        generatedCode="
     2241    jmi_extobj_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo;
     2242    jmi_extobj_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1;
     2243
     2244jmi_extobj_t jmi_global_tmp_1(jmi_t* jmi) {
     2245    JMI_DYNAMIC_INIT()
     2246    jmi_extobj_t tmp_1;
     2247    JMI_ARR(STAT, jmi_real_t, jmi_array_t, tmp_2, 1, 1)
     2248    JMI_GLOBALS_INIT()
     2249    JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, tmp_2, 1, 1, 1)
     2250    jmi_array_ref_1(tmp_2, 1) = 1.0;
     2251    tmp_1 = func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_exp2(tmp_2);
     2252    JMI_GLOBALS_FREE()
     2253    JMI_DYNAMIC_FREE()
     2254    return tmp_1;
     2255}
     2256
     2257int jmi_set_globals_start_0(jmi_t* jmi) {
     2258    int ef = 0;
     2259    JMI_DYNAMIC_INIT()
     2260    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo) = jmi_global_tmp_1(jmi);
     2261    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1) = JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo);
     2262    JMI_DYNAMIC_FREE()
     2263    return ef;
     2264}
     2265
     2266int jmi_set_globals_start_0(jmi_t* jmi);
     2267
     2268int jmi_set_globals_start(jmi_t* jmi) {
     2269    int ef = 0;
     2270    JMI_DYNAMIC_INIT()
     2271    ef |= jmi_set_globals_start_0(jmi);
     2272    JMI_DYNAMIC_FREE()
     2273    return ef;
     2274}
     2275
     2276void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_def0(jmi_real_t* y_o) {
     2277    JMI_DYNAMIC_INIT()
     2278    JMI_DEF(REA, y_v)
     2279    extern double f(void*);
     2280    y_v = f(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1));
     2281    JMI_RET(GEN, y_o, y_v)
     2282    JMI_DYNAMIC_FREE()
     2283    return;
     2284}
     2285
     2286jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_exp0() {
     2287    JMI_DEF(REA, y_v)
     2288    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_f_def0(&y_v);
     2289    return y_v;
     2290}
     2291
     2292void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(jmi_extobj_t eo_v) {
     2293    JMI_DYNAMIC_INIT()
     2294    extern void destructor(void*);
     2295    destructor(eo_v);
     2296    JMI_DYNAMIC_FREE()
     2297    return;
     2298}
     2299
     2300void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_def2(jmi_array_t* x_a, jmi_extobj_t* eo_o) {
     2301    JMI_DYNAMIC_INIT()
     2302    JMI_DEF(EXO, eo_v)
     2303    extern void* constructor(double*, size_t);
     2304    eo_v = constructor(x_a->var, jmi_array_size(x_a, 0));
     2305    JMI_RET(GEN, eo_o, eo_v)
     2306    JMI_DYNAMIC_FREE()
     2307    return;
     2308}
     2309
     2310jmi_extobj_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_exp2(jmi_array_t* x_a) {
     2311    JMI_DEF(EXO, eo_v)
     2312    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_constructor_def2(x_a, &eo_v);
     2313    return eo_v;
     2314}
     2315
     2316
     2317    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo));
     2318
     2319")})));
     2320end GlobalConstantExternalObject1;
     2321
    21962322end GlobalVariables;
    21972323
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r11576 r11578  
    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

    r11576 r11578  
    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/FlatNameBinding.jrag

    r11546 r11578  
    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

    r11560 r11578  
    16071607        p.print(getCommonAccess(), str, indent);
    16081608    }
     1609   
     1610    protected void FGlobalAccessExp.prettyPrintExp(Printer p, CodeStream str, String indent) {
     1611        str.print("global(");
     1612        super.prettyPrintExp(p, str, indent);
     1613        str.print(")");
     1614    }
    16091615   
    16101616    public void InstAccess.prettyPrint(Printer p, CodeStream str, String indent) {
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r11576 r11578  
    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

    r10841 r11578  
    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

    r11576 r11578  
    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);
     
    12331233
    12341234    public void InstAssignable.flatten(Flattener f, FlattenBindingExp binding, int level, boolean global) {
    1235         if (useInFlattening()) {
     1235        if (useInFlattening() && (global || !flattenAsGlobalVariable())) {
    12361236            if (hasBindingFExp()) {
    12371237                getBindingFExp().flattenAssertExternal(f);
     
    17901790            if (variability().knownParameterOrLess()) {
    17911791                CValue cval = ceval();
    1792                 FExp t = dynamicFExp(cval.buildInstLiteral());
    1793                 t.flattenUsedFuncsAndEnums(f);
    17941792                if (cval.hasBuildLiteral()) {
    1795                     return cval.buildLiteral();
     1793                    FExp t = dynamicFExp(cval.buildInstLiteral());
     1794                    t.flattenUsedFuncsAndEnums(f);
     1795                    FExp res = t.flatten(f);
     1796                    clearDynamicFExp();
     1797                    return res;
    17961798                }
    17971799            }
     
    25202522
    25212523    public FExp FLitExp.flatten(Flattener f)     { return fullCopy(); }
    2522     public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), null); }
     2524    public FExp FEnumLitExp.flatten(Flattener f) { return new FEnumLitExp(getEnum(), getValue(), new Opt<FEnumType>()); }
    25232525   
    25242526    public FExp FModFuncExp.flatten(Flattener f) {
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningAccess.jrag

    r11576 r11578  
    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

    r11514 r11578  
    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

    r11514 r11578  
    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

    r11576 r11578  
    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

    r11543 r11578  
    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

    r10783 r11578  
    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

    r11543 r11578  
    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

    r11543 r11578  
    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

    r11543 r11578  
    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

    r11559 r11578  
    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

    r11546 r11578  
    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

    r11576 r11578  
    15511551    }
    15521552
     1553    @Override
     1554    public FExp FGlobalAccessExp.replaceReferences(AbstractFunctionInliner fi) {
     1555        FExp res = dynamicFExp(treeCopy());
     1556        for (ASTNode n : res) {
     1557            n.replaceReferences(fi);
     1558        }
     1559        return res;
     1560    }
    15531561
    15541562    public FIdUseExp FIdUseExp.copyWithNonLiteralSubscriptsAsColon() {
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/Scalarization.jrag

    r11576 r11578  
    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

    r11546 r11578  
    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 GlobalConstExtObj1
     5073    package P
     5074        model EO
     5075            extends ExternalObject;
     5076            function constructor
     5077                input Real[:] x;
     5078                output EO eo;
     5079                external;
     5080            end constructor;
     5081            function destructor
     5082                input EO eo;
     5083                external;
     5084            end destructor;
     5085        end EO;
     5086       
     5087        function f
     5088            input EO eo;
     5089            output Real y;
     5090            external;
     5091        end f;
     5092       
     5093        constant Real x = 1;
     5094        constant EO eo = EO({x});
     5095        constant EO eo1 = eo;
     5096    end P;
     5097   
     5098    function f
     5099        input Real x;
     5100        input P.EO eo;
     5101        output Real y = x + P.f(eo);
     5102    algorithm
     5103    end f;
     5104
     5105    Real y = f(time, P.eo1);
     5106
     5107
     5108    annotation(__JModelica(UnitTesting(tests={
     5109        TransformCanonicalTestCase(
     5110            name="GlobalConstExtObj1",
     5111            description="Inlining global constant",
     5112            variability_propagation=false,
     5113            flatModel="
     5114fclass FunctionInlining.GlobalConstExtObj1
     5115 Real y;
     5116package constant
     5117 constant FunctionInlining.GlobalConstExtObj1.P.EO FunctionInlining.GlobalConstExtObj1.P.eo = FunctionInlining.GlobalConstExtObj1.P.EO.constructor({1.0});
     5118 constant FunctionInlining.GlobalConstExtObj1.P.EO FunctionInlining.GlobalConstExtObj1.P.eo1 = global(FunctionInlining.GlobalConstExtObj1.P.eo);
     5119equation
     5120 y = time + FunctionInlining.GlobalConstExtObj1.P.f(global(FunctionInlining.GlobalConstExtObj1.P.eo1));
     5121
     5122public
     5123 function FunctionInlining.GlobalConstExtObj1.P.EO.destructor
     5124  input FunctionInlining.GlobalConstExtObj1.P.EO eo;
     5125 algorithm
     5126  external \"C\" destructor(eo);
     5127  return;
     5128 end FunctionInlining.GlobalConstExtObj1.P.EO.destructor;
     5129
     5130 function FunctionInlining.GlobalConstExtObj1.P.EO.constructor
     5131  input Real[:] x;
     5132  output FunctionInlining.GlobalConstExtObj1.P.EO eo;
     5133 algorithm
     5134  external \"C\" eo = constructor(x, size(x, 1));
     5135  return;
     5136 end FunctionInlining.GlobalConstExtObj1.P.EO.constructor;
     5137
     5138 function FunctionInlining.GlobalConstExtObj1.P.f
     5139  input FunctionInlining.GlobalConstExtObj1.P.EO eo;
     5140  output Real y;
     5141 algorithm
     5142  external \"C\" y = f(eo);
     5143  return;
     5144 end FunctionInlining.GlobalConstExtObj1.P.f;
     5145
     5146 type FunctionInlining.GlobalConstExtObj1.P.EO = ExternalObject;
     5147end FunctionInlining.GlobalConstExtObj1;
     5148")})));
     5149end GlobalConstExtObj1;
     5150
    50605151end FunctionInlining;
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/VariabilityPropagationTests.mo

    r11492 r11578  
    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.