Changeset 11543


Ignore:
Timestamp:
Aug 31, 2018 3:07:32 PM (16 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Update handling of constants, and accesses to package constants, in functions for improved compilation and simulation performance.

Location:
trunk
Files:
44 edited

Legend:

Unmodified
Added
Removed
  • trunk/CHANGELOG.txt

    r11516 r11543  
    11================= Unreleased ==================
     2; Changed ; Minor ; Compiler ; #5670
     3Update handling of constants, and accesses to package constants, in functions
     4for improved compilation and simulation performance.
    25; Fixed ; Minor ; PyFMI ; #5668
    36Fixed issue with reusing the PyFMI computed FD Jacobian.
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGen.jrag

    r11514 r11543  
    293293    syn String FAbstractVariable.preName_C() = null;
    294294    eq FVariable.preName_C() = name_C("pre");
    295    
    296     protected String FVariable.name_C(String prefix) {
    297         return name_C(prefix, Integer.toString(variableIndex()));
    298     }
    299    
     295
     296    protected String FVariable.name_C(String prefix) {
     297        return name_C(prefix, Integer.toString(variableIndex()));
     298    }
     299
     300    protected String FGlobalVariable.name_C(String prefix) {
     301        return FExp.global_C(nameUnderscore());
     302    }
     303
    300304    protected String FAbstractVariable.name_C(String prefix, String suffix) {
    301305        StringBuilder buf = new StringBuilder();
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenAlgorithms.jrag

    r11541 r11543  
    6262
    6363    public class CodePrinter {
    64         public abstract void printInit(FFunctionVariable v, CodeStream str, String indent, FType type);
     64        public abstract void printInit(FAbstractVariable v, CodeStream str, String indent, FType type);
    6565    }
    6666
    6767    public class CPrettyPrinter {
    6868        @Override
    69         public void printInit(FFunctionVariable v, CodeStream str, String indent, FType type) {
     69        public void printInit(FAbstractVariable v, CodeStream str, String indent, FType type) {
    7070            v.printInit(ExecStep, str, indent, type);
    7171        }
    7272    }
    7373
    74     public void FFunctionVariable.printInit(CodePrinter.ExecuteCodePrinter p, CodeStream str, String indent, FType type) {
     74    public void FAbstractVariable.printInit(CodePrinter.ExecuteCodePrinter p, CodeStream str, String indent, FType type) {
    7575        String name = p.name(this);
    7676        TypePrinter_C tp = p.codePrinter().createInitSetPrinter(str);
     
    193193    @Override
    194194    public void FInitArrayStmt.prettyPrint_C(CodePrinter p, CodeStream str, String indent) {
    195         p.printInit(getFIdUseExp().myFuncFV(), str, indent, type());
     195        p.printInit(getFIdUseExp().getCommonAccess().asFAccess().myTopFV(), str, indent, type());
    196196    }
    197197
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r11514 r11543  
    708708     */
    709709    public String FAbstractVariable.genUse_C(CodePrinter.ExecuteCodePrinter p, FArraySubscripts fas, String type) {
    710         return p.name(this);
    711     }
    712 
    713     @Override
    714     public String FFunctionArray.genUse_C(CodePrinter.ExecuteCodePrinter p, FArraySubscripts fas, String type) {
    715710        if (fas == null) {
    716711            return p.name(this);
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r11541 r11543  
    259259    }
    260260   
    261     public ExternalArgument FExp.externalArgument() {
    262         return this;
    263     }
    264    
    265     public ExternalArgument FIdUseExp.externalArgument() {
    266         return myCommonVarDecl();
    267     }
    268 
     261    syn ExternalArgument FExp.externalArgument();
     262    eq FExp     .externalArgument() = this;
     263    eq FIdUseExp.externalArgument() = myCommonVarDecl().externalArgument(this);
     264
     265    interface CommonVariableDecl {
     266        ExternalArgument externalArgument(FExp exp);
     267    }
     268
     269    syn ExternalArgument InstComponentDecl.externalArgument(FExp exp) = variability().constantVariability() ? exp : this;
     270
     271    syn ExternalArgument FAbstractVariable.externalArgument(FExp exp);
     272    eq FAbstractVariable.externalArgument(FExp exp) = exp;
     273    eq FFunctionVariable.externalArgument(FExp exp) = this;
    269274
    270275    syn ArrayList<ExternalArgument> FExternalStmt.externalObjectsToSerialize() {
    271276        ArrayList<ExternalArgument> externalObjects = new ArrayList<ExternalArgument>();
    272 
    273277        for (ExternalArgument var : varsToSerialize()) {
    274278            if (var.type().isExternalObject()) {
     
    276280            }
    277281        }
    278 
    279282        return externalObjects;
    280283    }
    281    
     284
    282285    syn ArrayList<ExternalArgument> FExternalStmt.functionArgsToSerialize() {
    283286        ArrayList<ExternalArgument> functionArgs = new ArrayList<ExternalArgument>();
     
    309312    private ArrayList<CommonVariableDecl> FExternalStmt.myCommonVarDecls() {
    310313        FFunctionDecl decl = containingFFunctionDecl();
    311         if (decl != null)
     314        if (decl != null) {
    312315            return new ArrayList<CommonVariableDecl>(decl.getFFunctionVariables().toArrayList());
    313         else
    314             return new ArrayList<CommonVariableDecl>(enclosingInstClassDecl().getInstComponentDecls().toArrayList());
     316        } else {
     317            ArrayList<CommonVariableDecl> res = new ArrayList<>();
     318            for (CommonVariableDecl cvd : enclosingInstClassDecl().allInstComponentDecls()) {
     319                if (!cvd.variability().constantVariability()) {
     320                    res.add(cvd);
     321                }
     322            }
     323            return res;
     324        }
    315325    }
    316326
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenFunctionIO.jrag

    r10802 r11543  
    172172        public abstract String arrayAccessConst();
    173173       
     174        public abstract void printAssign(CodeStream str, String indent, String name, FExp exp);
     175       
    174176        /**
    175177         * Notify printer that a component has ended.
     
    247249                firstUse.genTempInputCellAssignsMemcpy_C(str, indent, firstName, n);
    248250            }
     251           
     252            public void printAssign(CodeStream str, String indent, String name, FExp exp) {
     253                str.print(indent, "JMI_ASG(", exp.type().macroType(), ", ", name, ", ");
     254                CodePrinter.this.print(exp, str, indent);
     255                str.print(")\n");
     256            }
    249257        }
    250258
     
    295303            @Override
    296304            public abstract void printCellUse(CodeStream str, String indent, String name, FIdUseExp exp);
     305           
     306            public void printAssign(CodeStream str, String indent, String name, FExp exp) {
     307                str.print(indent, "JMI_ASG(", exp.type().macroType(), ", ");
     308                CodePrinter.this.print(exp, str, indent);
     309                str.print(", ", name, ")");
     310            }
    297311        }
    298312    }
     
    424438        if (isArray()) {
    425439            if (exp.genAssignMacro()) {
    426                 // Works for now!
    427                 str.format("%sJMI_ASG(%s, ", indent, macroType());
    428                 ASTNode.printer_C.print(exp, str, indent);
    429                 str.formatln(", %s)", name);
     440                p.printAssign(str, indent, name, exp);
    430441            } else {
    431442                String type = isRecord() ? C_ARRAY_RECORD : p.arrayAccessConst();
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r11388 r11543  
    3838                for (AbstractEquationBlock block : fclass.getDAEStructuredBLT().getAllBlocks()) {
    3939                    block.genSetupNodeDecls_C(p, str, indent);
     40                }
     41                for (FVariable fv : fclass.getGlobalVariables()) {
     42                    fv.genGlobalVariableDecl_C(p, str, indent);
    4043                }
    4144            }
     
    262265    }
    263266}
     267
     268aspect CCodeGenGlobalVariables {
     269
     270    public class CGenerator {
     271        public class DAETag_C_set_globals_start extends DAETag {
     272           
     273            public DAETag_C_set_globals_start(AbstractGenerator myGenerator, FClass fclass) {
     274                super("C_set_globals_start", myGenerator, fclass);
     275            }
     276           
     277           
     278            public void generate(CodeStream str) {
     279                CodePrinter p = ASTNode.printer_C;
     280                String indent = "";
     281                String next = p.indent(indent);
     282               
     283                ArrayList<FVariable> globals = new ArrayList<FVariable>();
     284                for (FVariable fv : fclass.getGlobalVariables()) {
     285                    globals.add(fv);
     286                }
     287               
     288                CodeSplitter<FVariable> splitter = new CodeSplitter<FVariable>(p, str, next, false,
     289                        "jmi_set_globals_start_", fclass.myOptions(), globals) {
     290                    @Override
     291                    public void genDecl(FVariable element) {
     292                        element.genGlobalVariableInitDecl_C(p, str, indent);
     293                    }
     294                    @Override
     295                    public void gen(FVariable element) {
     296                        element.genGlobalVariableInit_C(p, str, indent);
     297                    }
     298                    @Override
     299                    public void genPre() {
     300                        str.print(indent, "JMI_GLOBALS_INIT()\n");
     301                    }
     302                    @Override
     303                    public void genPost() {
     304                        str.print(indent, "JMI_GLOBALS_FREE()\n");
     305                    }
     306                };
     307                splitter.genFuncImpls();
     308                splitter.genFuncHeads();
     309                str.print("int jmi_set_globals_start(jmi_t* jmi) {\n");
     310                splitter.printStatusDecl();
     311                splitter.genFuncCalls();
     312                splitter.printStatusReturn();
     313                str.print("}\n");
     314            }
     315        }
     316    }
     317
     318    public void FVariable.genGlobalVariableDecl_C(CodePrinter p, CodeStream str, String indent) {
     319        str.print(indent, type().type_C(p), " ", nameUnderscore(), ";\n");
     320    }
     321
     322    public void FVariable.genGlobalVariableInitDecl_C(CodePrinter p, CodeStream str, String indent) {
     323        if (isComposite()) {
     324            p.print(getBindingExp(), indent, type(), p.createDeclPrinter(str).forceDynamic());
     325        }
     326    }
     327
     328    public void FVariable.genGlobalVariableInit_C(CodePrinter p, CodeStream str, String indent) {
     329        if (isComposite()) {
     330            p.print(getBindingExp(), indent, type(), p.createInitPrinter(str).forceDynamic());
     331            p.printTempInputAssigns(str, indent, getBindingExp());
     332        }
     333       
     334        str.print(indent, FExp.global_C(nameUnderscore()), " = ");
     335        p.printIOExec(getBindingExp(), str, indent);
     336        str.print(";\n");
     337    }
     338
     339}
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenTypes.jrag

    r11541 r11543  
    174174        protected boolean external = false;
    175175        protected boolean subDecls = false; // Used in CAD
     176        boolean forceDynamic = false;
    176177       
    177178        private Stack<Level> levels   = new Stack<Level>();
     
    185186            this(p, str);
    186187            reset(name, src, s, external, indent);
     188        }
     189       
     190        public TypePrinter_C forceDynamic() {
     191            forceDynamic = true;
     192            return this;
    187193        }
    188194       
     
    234240       
    235241        protected String dynStr(FType type) {
    236             return (dynamic() ? "DYNA" : "STAT");
     242            return (forceDynamic || dynamic() ? "DYNA" : "STAT");
    237243        }
    238244       
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CodeGen/CodeSplitter.jrag

    r11492 r11543  
    134134                genDecl(element);
    135135            }
     136            genPre();
    136137            for (T element : splitElements) {
    137138                genPre(element);
     
    143144                genPost(element);
    144145            }
     146            genPost();
    145147        }
    146148       
     
    149151        public abstract void gen(T element);
    150152        public void genPost(T element) {}
     153        public void genPre() {}
     154        public void genPost() {}
    151155    }
    152156
  • trunk/Compiler/ModelicaCBackEnd/templates/FMIBase/base.h

    r10879 r11543  
    9191$C_global_temps$
    9292} jmi_globals_t;
    93 #define JMI_GLOBAL(v)        (((jmi_globals_t*)jmi->globals)->v)
     93#define JMI_GLOBAL(v)        (((jmi_globals_t*)jmi_get_current()->globals)->v)
    9494#define JMI_CACHED(var, exp) ((!JMI_GLOBAL(var##_computed) && (JMI_GLOBAL(var##_computed) = 1)) ? (JMI_GLOBAL(var) = exp) : JMI_GLOBAL(var))
    9595
  • trunk/Compiler/ModelicaCBackEnd/templates/FMIBase/start.c

    r10573 r11543  
    1616$C_enum_strings$
    1717
     18$C_set_globals_start$
     19
    1820$C_set_start_values$
    1921
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalCevalTests.mo

    r11541 r11543  
    12141214end RecordExternalObject;
    12151215
     1216model PackageConstant1
     1217type E = enumeration(A,B);
     1218function f
     1219    input Real[:] a;
     1220    output Real[size(a,1)] b;
     1221    constant Real[:] c = {2};
     1222    external "C" f(a,b,c);
     1223end f;
     1224    Real[1] x1 = f({1});
     1225
     1226    annotation(__JModelica(UnitTesting(tests={
     1227        CCodeGenTestCase(
     1228            name="PackageConstant1",
     1229            description="",
     1230            variability_propagation=false,
     1231            inline_functions="none",
     1232            template="
     1233$ECE_external_includes$
     1234$ECE_record_definitions$
     1235$ECE_decl$
     1236---
     1237$ECE_setup_decl$
     1238---
     1239$ECE_setup_init$
     1240---
     1241$ECE_setup_free$
     1242---
     1243$ECE_calc_decl$
     1244---
     1245$ECE_calc_init$
     1246---
     1247$ECE_calc$
     1248---
     1249$ECE_calc_free$
     1250---
     1251$ECE_free$
     1252",
     1253            generatedCode="
     1254---
     1255
     1256---
     1257
     1258---
     1259
     1260---
     1261        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a_a, -1, 1)
     1262        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b_a, -1, 1)
     1263        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, f_arg2, -1, 1)
     1264        extern void f(double*, double*, double*);
     1265
     1266---
     1267        JMCEVAL_parseArrayDims(1);
     1268        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a_a, d[0], 1, d[0])
     1269        JMCEVAL_parseArray(Real, a_a);
     1270        JMCEVAL_parseArrayDims(1);
     1271        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b_a, d[0], 1, d[0])
     1272        JMCEVAL_parseArray(Real, b_a);
     1273        JMCEVAL_parseArrayDims(1);
     1274        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, f_arg2, d[0], 1, d[0])
     1275        JMCEVAL_parseArray(Real, f_arg2);
     1276
     1277---
     1278            f(a_a->var, b_a->var, f_arg2->var);
     1279            JMCEVAL_check(\"DONE\");
     1280            JMCEVAL_printArray(Real, b_a);
     1281
     1282
     1283---
     1284
     1285---
     1286")})));
     1287end PackageConstant1;
     1288
    12161289end CCodeGenExternalCevalTests;
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalTests.mo

    r11541 r11543  
    11351135")})));
    11361136end ExternalLiteral3;
    1137 
    1138 model ExternalConstant1
    1139     function f1
    1140         input Real x;
    1141         output Real y;
    1142         constant Real c = 3;
    1143         constant Real[1] d = {3};
    1144         external "C" y = f(x,c,d);
    1145     end f1;
    1146     function f2
    1147         input Real x;
    1148         output Real y;
    1149         constant Real c = 3;
    1150         constant Real[1] d = {3};
    1151         external "C";
    1152     end f2;
    1153    
    1154     Real y = f1(time) + f2(time);
    1155 
    1156     annotation(__JModelica(UnitTesting(tests={
    1157         CCodeGenTestCase(
    1158             name="ExternalConstant1",
    1159             description="Constants in external calls",
    1160             variability_propagation=false,
    1161             template="
    1162 $C_function_headers$
    1163 $C_functions$
    1164 ",
    1165             generatedCode="
    1166 void func_CCodeGenExternalTests_ExternalConstant1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o);
    1167 jmi_real_t func_CCodeGenExternalTests_ExternalConstant1_f1_exp0(jmi_real_t x_v);
    1168 void func_CCodeGenExternalTests_ExternalConstant1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o);
    1169 jmi_real_t func_CCodeGenExternalTests_ExternalConstant1_f2_exp1(jmi_real_t x_v);
    1170 
    1171 void func_CCodeGenExternalTests_ExternalConstant1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o) {
    1172     JMI_DYNAMIC_INIT()
    1173     JMI_DEF(REA, c_v)
    1174     JMI_ARR(STAT, jmi_real_t, jmi_array_t, d_a, 1, 1)
    1175     JMI_DEF(REA, y_v)
    1176     extern double f(double, double, double*);
    1177     c_v = 3;
    1178     JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, d_a, 1, 1, 1)
    1179     jmi_array_ref_1(d_a, 1) = 3;
    1180     y_v = f(x_v, c_v, d_a->var);
    1181     JMI_RET(GEN, y_o, y_v)
    1182     JMI_DYNAMIC_FREE()
    1183     return;
    1184 }
    1185 
    1186 jmi_real_t func_CCodeGenExternalTests_ExternalConstant1_f1_exp0(jmi_real_t x_v) {
    1187     JMI_DEF(REA, y_v)
    1188     func_CCodeGenExternalTests_ExternalConstant1_f1_def0(x_v, &y_v);
    1189     return y_v;
    1190 }
    1191 
    1192 void func_CCodeGenExternalTests_ExternalConstant1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o) {
    1193     JMI_DYNAMIC_INIT()
    1194     JMI_DEF(REA, c_v)
    1195     JMI_ARR(STAT, jmi_real_t, jmi_array_t, d_a, 1, 1)
    1196     JMI_DEF(REA, y_v)
    1197     extern double f2(double, double, double*, size_t);
    1198     c_v = 3;
    1199     JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, d_a, 1, 1, 1)
    1200     jmi_array_ref_1(d_a, 1) = 3;
    1201     y_v = f2(x_v, c_v, d_a->var, jmi_array_size(d_a, 0));
    1202     JMI_RET(GEN, y_o, y_v)
    1203     JMI_DYNAMIC_FREE()
    1204     return;
    1205 }
    1206 
    1207 jmi_real_t func_CCodeGenExternalTests_ExternalConstant1_f2_exp1(jmi_real_t x_v) {
    1208     JMI_DEF(REA, y_v)
    1209     func_CCodeGenExternalTests_ExternalConstant1_f2_def1(x_v, &y_v);
    1210     return y_v;
    1211 }
    1212 
    1213 
    1214 ")})));
    1215 end ExternalConstant1;
    12161137
    12171138model ExternalArray1
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenGlobalsTests.mo

    r11388 r11543  
    13841384end WhenTestCache;
    13851385
     1386package GlobalVariables
     1387
     1388model GlobalConstantScalar1
     1389    function f1
     1390        input Real x;
     1391        output Real y;
     1392        constant Real c = 3;
     1393        constant Real[1] d = {3};
     1394        external "C" y = f(x,c,d);
     1395    end f1;
     1396    function f2
     1397        input Real x;
     1398        output Real y;
     1399        constant Real c = 3;
     1400        constant Real[1] d = {3};
     1401        external "C";
     1402    end f2;
     1403   
     1404    Real y = f1(time) + f2(time);
     1405
     1406    annotation(__JModelica(UnitTesting(tests={
     1407        CCodeGenTestCase(
     1408            name="GlobalConstantScalar1",
     1409            description="Constants in external calls",
     1410            variability_propagation=false,
     1411            template="
     1412$C_global_temps$
     1413$C_set_globals_start$
     1414$C_function_headers$
     1415$C_functions$
     1416",
     1417            generatedCode="
     1418    jmi_real_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c;
     1419    jmi_array_t* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d;
     1420    jmi_real_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c;
     1421    jmi_array_t* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d;
     1422
     1423int jmi_set_globals_start_0(jmi_t* jmi) {
     1424    int ef = 0;
     1425    JMI_DYNAMIC_INIT()
     1426    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 1, 1)
     1427    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_2, 1, 1)
     1428    JMI_GLOBALS_INIT()
     1429    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c) = 3;
     1430    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 1, 1, 1)
     1431    jmi_array_ref_1(tmp_1, 1) = 3;
     1432    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d) = tmp_1;
     1433    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c) = 3;
     1434    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_2, 1, 1, 1)
     1435    jmi_array_ref_1(tmp_2, 1) = 3;
     1436    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d) = tmp_2;
     1437    JMI_GLOBALS_FREE()
     1438    JMI_DYNAMIC_FREE()
     1439    return ef;
     1440}
     1441
     1442int jmi_set_globals_start_0(jmi_t* jmi);
     1443
     1444int jmi_set_globals_start(jmi_t* jmi) {
     1445    int ef = 0;
     1446    JMI_DYNAMIC_INIT()
     1447    ef |= jmi_set_globals_start_0(jmi);
     1448    JMI_DYNAMIC_FREE()
     1449    return ef;
     1450}
     1451
     1452void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o);
     1453jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_exp0(jmi_real_t x_v);
     1454void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o);
     1455jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_exp1(jmi_real_t x_v);
     1456
     1457void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o) {
     1458    JMI_DYNAMIC_INIT()
     1459    JMI_DEF(REA, y_v)
     1460    extern double f(double, double, double*);
     1461    y_v = f(x_v, JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c), JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d)->var);
     1462    JMI_RET(GEN, y_o, y_v)
     1463    JMI_DYNAMIC_FREE()
     1464    return;
     1465}
     1466
     1467jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_exp0(jmi_real_t x_v) {
     1468    JMI_DEF(REA, y_v)
     1469    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(x_v, &y_v);
     1470    return y_v;
     1471}
     1472
     1473void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o) {
     1474    JMI_DYNAMIC_INIT()
     1475    JMI_DEF(REA, y_v)
     1476    extern double f2(double, double, double*, size_t);
     1477    y_v = f2(x_v, JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c), JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d)->var, jmi_array_size(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d), 0));
     1478    JMI_RET(GEN, y_o, y_v)
     1479    JMI_DYNAMIC_FREE()
     1480    return;
     1481}
     1482
     1483jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_exp1(jmi_real_t x_v) {
     1484    JMI_DEF(REA, y_v)
     1485    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(x_v, &y_v);
     1486    return y_v;
     1487}
     1488")})));
     1489end GlobalConstantScalar1;
     1490
     1491model GlobalConstantArray1
     1492   
     1493    constant Real[:] c = {4,5};
     1494   
     1495    function f
     1496        input Real x;
     1497        input Integer i;
     1498        output Real y = x .+ c[i];
     1499    algorithm
     1500        annotation(Inline=false);
     1501    end f;
     1502
     1503    Real y = f(time, 2);
     1504
     1505annotation(__JModelica(UnitTesting(tests={
     1506    CCodeGenTestCase(
     1507        name="GlobalConstantArray1",
     1508        description="",
     1509        template="
     1510$C_global_temps$
     1511$C_set_globals_start$
     1512$C_functions$
     1513",
     1514        generatedCode="
     1515    jmi_array_t* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c;
     1516
     1517int jmi_set_globals_start_0(jmi_t* jmi) {
     1518    int ef = 0;
     1519    JMI_DYNAMIC_INIT()
     1520    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     1521    JMI_GLOBALS_INIT()
     1522    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     1523    jmi_array_ref_1(tmp_1, 1) = 4;
     1524    jmi_array_ref_1(tmp_1, 2) = 5;
     1525    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c) = tmp_1;
     1526    JMI_GLOBALS_FREE()
     1527    JMI_DYNAMIC_FREE()
     1528    return ef;
     1529}
     1530
     1531int jmi_set_globals_start_0(jmi_t* jmi);
     1532
     1533int jmi_set_globals_start(jmi_t* jmi) {
     1534    int ef = 0;
     1535    JMI_DYNAMIC_INIT()
     1536    ef |= jmi_set_globals_start_0(jmi);
     1537    JMI_DYNAMIC_FREE()
     1538    return ef;
     1539}
     1540
     1541void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1542    JMI_DYNAMIC_INIT()
     1543    JMI_DEF(REA, y_v)
     1544    y_v = x_v + jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c), i_v);
     1545    JMI_RET(GEN, y_o, y_v)
     1546    JMI_DYNAMIC_FREE()
     1547    return;
     1548}
     1549
     1550jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1551    JMI_DEF(REA, y_v)
     1552    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_def0(x_v, i_v, &y_v);
     1553    return y_v;
     1554}
     1555")})));
     1556end GlobalConstantArray1;
     1557
     1558model GlobalConstantRecordArray1
     1559    record R
     1560        Real[:] a;
     1561    end R;
     1562   
     1563    function f
     1564        input Real x;
     1565        input Integer i;
     1566        constant R[:] c = {R(1:2), R(3:4)};
     1567        output Real y = c[i].a[i] + x;
     1568        algorithm
     1569    annotation(Inline=false);
     1570    end f;
     1571   
     1572    Real y = f(time, 2);
     1573   
     1574annotation(__JModelica(UnitTesting(tests={
     1575    CCodeGenTestCase(
     1576        name="GlobalConstantRecordArray1",
     1577        description="",
     1578        variability_propagation=false,
     1579        template="
     1580$C_global_temps$
     1581$C_set_globals_start$
     1582$C_functions$
     1583",
     1584        generatedCode="
     1585    R_0_ra* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c;
     1586
     1587int jmi_set_globals_start_0(jmi_t* jmi) {
     1588    int ef = 0;
     1589    JMI_DYNAMIC_INIT()
     1590    JMI_ARR(DYNA, R_0_r, R_0_ra, tmp_1, 2, 1)
     1591    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_2, 2, 1)
     1592    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_3, 2, 1)
     1593    JMI_GLOBALS_INIT()
     1594    JMI_ARRAY_INIT_1(DYNA, R_0_r, R_0_ra, tmp_1, 2, 1, 2)
     1595    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_2, 2, 1, 2)
     1596    jmi_array_rec_1(tmp_1, 1)->a = tmp_2;
     1597    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_3, 2, 1, 2)
     1598    jmi_array_rec_1(tmp_1, 2)->a = tmp_3;
     1599    jmi_array_ref_1(jmi_array_rec_1(tmp_1, 1)->a, 1) = AD_WRAP_LITERAL(1);
     1600    jmi_array_ref_1(jmi_array_rec_1(tmp_1, 1)->a, 2) = AD_WRAP_LITERAL(2);
     1601    jmi_array_ref_1(jmi_array_rec_1(tmp_1, 2)->a, 1) = AD_WRAP_LITERAL(3);
     1602    jmi_array_ref_1(jmi_array_rec_1(tmp_1, 2)->a, 2) = AD_WRAP_LITERAL(4);
     1603    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c) = tmp_1;
     1604    JMI_GLOBALS_FREE()
     1605    JMI_DYNAMIC_FREE()
     1606    return ef;
     1607}
     1608
     1609int jmi_set_globals_start_0(jmi_t* jmi);
     1610
     1611int jmi_set_globals_start(jmi_t* jmi) {
     1612    int ef = 0;
     1613    JMI_DYNAMIC_INIT()
     1614    ef |= jmi_set_globals_start_0(jmi);
     1615    JMI_DYNAMIC_FREE()
     1616    return ef;
     1617}
     1618
     1619void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1620    JMI_DYNAMIC_INIT()
     1621    JMI_DEF(REA, y_v)
     1622    y_v = jmi_array_val_1(jmi_array_rec_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c), i_v)->a, i_v) + x_v;
     1623    JMI_RET(GEN, y_o, y_v)
     1624    JMI_DYNAMIC_FREE()
     1625    return;
     1626}
     1627
     1628jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1629    JMI_DEF(REA, y_v)
     1630    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_def0(x_v, i_v, &y_v);
     1631    return y_v;
     1632}
     1633")})));
     1634end GlobalConstantRecordArray1;
     1635
     1636
     1637end GlobalVariables;
     1638
    13861639end CCodeGenGlobalsTests;
  • trunk/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenTests.mo

    r11492 r11543  
    53465346end CUnknownArray11;
    53475347
    5348 model CUnknownArray12
    5349     record R
    5350         Real[:] a;
    5351     end R;
    5352    
    5353     function f
    5354         input Integer i;
    5355         constant R[:] c = {R(1:2)};
    5356         output Real y = c[i].a[1];
    5357         algorithm
    5358     end f;
    5359    
    5360     Real x = f(1);
    5361    
    5362 annotation(__JModelica(UnitTesting(tests={
    5363     CCodeGenTestCase(
    5364         name="CUnknownArray12",
    5365         description="Sorted initialization",
    5366         variability_propagation=false,
    5367         inline_functions="none",
    5368         template="$C_functions$",
    5369         generatedCode="
    5370 void func_CCodeGenTests_CUnknownArray12_f_def0(jmi_real_t i_v, jmi_real_t* y_o) {
    5371     JMI_DYNAMIC_INIT()
    5372     JMI_ARR(STAT, R_0_r, R_0_ra, c_a, 1, 1)
    5373     JMI_ARR(STAT, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
    5374     JMI_DEF(REA, y_v)
    5375     JMI_ARRAY_INIT_1(STAT, R_0_r, R_0_ra, c_a, 1, 1, 1)
    5376     JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
    5377     jmi_array_rec_1(c_a, 1)->a = tmp_1;
    5378     jmi_array_ref_1(jmi_array_rec_1(c_a, 1)->a, 1) = 1;
    5379     jmi_array_ref_1(jmi_array_rec_1(c_a, 1)->a, 2) = 2;
    5380     y_v = jmi_array_val_1(jmi_array_rec_1(c_a, i_v)->a, 1);
    5381     JMI_RET(GEN, y_o, y_v)
    5382     JMI_DYNAMIC_FREE()
    5383     return;
    5384 }
    5385 
    5386 jmi_real_t func_CCodeGenTests_CUnknownArray12_f_exp0(jmi_real_t i_v) {
    5387     JMI_DEF(REA, y_v)
    5388     func_CCodeGenTests_CUnknownArray12_f_def0(i_v, &y_v);
    5389     return y_v;
    5390 }
    5391 
    5392 ")})));
    5393 end CUnknownArray12;
    5394 
    53955348model CUnknownArray13
    53965349    function f
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r11534 r11543  
    26892689                if (!bexp.type().isUnknown())
    26902690                    val = bexp.ceval(evaluator, i);
    2691             } else if (!func && !inRecordDecl()) {
     2691            } else if ((!func && !inRecordDecl()) || isRecord()) {
    26922692                val = cevalNoBExp(evaluator, i);
    26932693            }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluationStatements.jrag

    r11534 r11543  
    139139
    140140    public void FAccessString.assignToInFuncEval(AlgorithmEvaluator evaluator, CValue right) {
    141         FFunctionVariable var = myFuncFV();
    142         var.setEvaluationValue(evaluator, right);
     141        myTopFV().setEvaluationValue(evaluator, right);
    143142    }
    144143
    145144    public void FAccessFull.assignToInFuncEval(AlgorithmEvaluator evaluator, CValue right) {
    146         FFunctionVariable var = myFuncFV();
     145        FAbstractVariable var = myTopFV();
    147146        FAccessPart firstPart = getFAccessPart(0);
    148147        CValue val = var.type().assignToPartInFuncEval(firstPart, var.evaluationValue(evaluator), right);
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/Constructors.jrag

    r11514 r11543  
    12781278   
    12791279    public abstract FVariable FVariable.createEmptyNode();
     1280    public FGlobalVariable  FGlobalVariable.createEmptyNode()                   { return new FGlobalVariable(); }
    12801281    public FRealVariable    FRealVariable.createEmptyNode()                     { return new FRealVariable(); }
    12811282    public FIntegerVariable FIntegerVariable.createEmptyNode()                  { return new FIntegerVariable(); }
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r11514 r11543  
    33413341   
    33423342    /**
    3343      * All uses of this variable that are the left-hand side of an assignment or
    3344      * function call statement.
    3345      */
    3346     coll HashSet<FIdUseExp> FFunctionVariable.assigningUses() [new HashSet<FIdUseExp>()]
    3347         with add root FFunctionDecl;
    3348     FIdUseExp contributes this when isAssignedTo() && myFuncFV() != null
    3349         to FFunctionVariable.assigningUses() for myFuncFV();
    3350    
    3351     /**
    33523343     * Check if this is the left hand side of an equation.
    33533344     */
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatNameBinding.jrag

    r11514 r11543  
    2626    syn FAbstractVariable FReinit.myFV()        = getVar().asFIdUseExp().myFV();
    2727
     28    syn FAbstractVariable      FAccess    .myTopFV() = myFV();
     29    syn lazy FAbstractVariable FAccessFull.myTopFV() = getFAccessPart(0).myFV();
     30
    2831    syn FAbstractVariable FIdUseExp.myDerFV(int index) = getCommonAccess().myDerFV(index);
    2932    syn FAbstractVariable CommonAccess.myDerFV(int index) { throw new UnsupportedOperationException(); }
     
    3134
    3235    syn FAbstractVariable FAccess.myPreFV() = lookupFV(preName());
    33 
    34     syn FFunctionVariable FIdUseExp.myFuncFV() = getCommonAccess().asFAccess().myFuncFV();
    35     syn FFunctionVariable FAccess.myFuncFV()    = (FFunctionVariable) myOutermostFV();
    3636
    3737    syn CommonVariableDecl FIdUseExp.myCommonVarDecl() = getCommonAccess().myCommonVarDecl();
     
    7373            res = variablesMap().lookup(name);
    7474        }
     75        if (res == null) {
     76            res = lookupGlobalVariable(name);
     77        }
    7578        return nullUnknown(res);
    7679    }
     80
     81    inh FAbstractVariable FFunctionDecl.lookupGlobalVariable(String name);
     82    eq Root.getChild().lookupGlobalVariable(String name)   = null;
     83    eq FClass.getChild().lookupGlobalVariable(String name) = globalVariablesMap().lookup(name);
    7784
    7885    private FlatVariableMap FFunctionDecl.tempLookupMap = null;
     
    104111   
    105112    syn lazy FlatVariableMap FClass.variablesMap()        = new FlatVariableMap(getFVariables(), getAliasVariables());
     113    syn lazy FlatVariableMap FClass.globalVariablesMap() = new FlatVariableMap(getGlobalVariables());
    106114    syn lazy FlatVariableMap FFunctionDecl.variablesMap() = new FlatVariableMap(getFFunctionVariables());
    107115    syn lazy FlatVariableMap FRecordDecl.variablesMap()   = new FlatVariableMap(getFVariables());
     
    276284   
    277285    syn lazy FRecordDecl FAbstractVariable.myFRecordDecl() = null;
     286    eq FGlobalVariable.myFRecordDecl()   = type().myFRecordDecl();
    278287    eq FRecordVariable.myFRecordDecl()   = lookupFRec(getRecord().name());
    279288    eq FFunctionVariable.myFRecordDecl() = type().myFRecordDecl();
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/FlatUtil.jrag

    r11514 r11543  
    603603   
    604604    /**
    605      * Create a copy of the name, with another name appended, and <code>fas</code> applied to the last part.
    606      *
    607      * Passing <code>null</code> as <code>fas</code> is supported, and equivalent
    608      * to using {@link #copyAndAppend(FAccess)}.
    609      */
    610     public FAccess FAccess.copyAndAppend(FAccess name, FArraySubscripts fas) {
    611         if (fas == null || fas.ndims() == 0)
    612             return copyAndAppend(name);
    613         FAccess res = copyAndAppend(name);
    614         return res.asFAccessFull().addFArraySubscripts(fas);
    615     }
    616    
    617     /**
    618605     * Create a copy of the name as an FAccessFull.
    619606     */
     
    659646   
    660647    public FAccessFull FAccessFull.copyAndPrepend(String name) {
    661         FAccessFull res = new FAccessFull(name);
    662         int n = res.getNumFAccessPart();
    663         for (int i = getNumFAccessPart() - 1; i >= 0; i--)
    664             res.setFAccessPart(getFAccessPart(i).fullCopy(), i + n);
     648        FAccessFull res = treeCopy();
     649        FAccessPart first = res.getFAccessPart(0);
     650        first.setName(name + "." + first.getName());
    665651        return res;
    666652    }
     
    696682        res.getFAccessPart(0).setName(prefix + name);
    697683        return res;
    698     }
    699    
    700     /**
    701      * Create a copy of the name, with another FAccess appended.
    702      */
    703     public abstract FAccess FAccess.copyAndAppend(FAccess name);
    704    
    705     public FAccess FAccessEmpty.copyAndAppend(FAccess name) {
    706         return name.fullCopy();
    707     }
    708    
    709     public FAccess FAccessString.copyAndAppend(FAccess name) {
    710         return name.copyAndPrepend(getName());
    711     }
    712    
    713     public FAccess FAccessFull.copyAndAppend(FAccess name) {
    714         return fullCopy().append(name);
    715684    }
    716685   
     
    14131382     
    14141383     /**
    1415       * Set to a class to make all children behave as if this was declared in that function.
    1416       */
    1417      private InstClassDecl InstAssignable.temporarilyInFunction = null;
    1418      
    1419      /**
    14201384      * Check is this node is in a function.
    14211385      */
     
    14241388     eq FFunctionDecl.getChild().inFunction()     = true;
    14251389     eq InstBaseClassDecl.getChild().inFunction() = isFunction();
    1426      eq InstAssignable.getChild().inFunction()    = (temporarilyInFunction != null) || inFunction();
    14271390     eq InstNormalExtends.getInstClassModification().inFunction() = extendsInFunction();
    14281391     
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r11514 r11543  
    10031003            }
    10041004        }
    1005 
     1005        if (getNumGlobalVariable() > 0) {
     1006            str.println(indent, "package constant");
     1007            for (FVariable fv : getGlobalVariables()) {
     1008                p.print(fv, str, nextInd);
     1009                str.println(";");
     1010            }
     1011        }
    10061012        if (getNumFInitialEquation() > 0) {
    10071013            str.println(indent, "initial equation");
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r11514 r11543  
    3030
    3131    syn lazy FType FAbstractVariable.type();
     32    eq FGlobalVariable.type()           = getFType();
    3233    eq FRealVariable.type()             = fRealType(size());
    3334    eq FIntegerVariable.type()          = fIntegerType(size());
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/Variability.jrag

    r11514 r11543  
    404404
    405405
    406     syn TypePrefixVariability FAbstractVariable.variability() {
    407         throw new UnsupportedOperationException("Unable to get variability of FAbstractVariable type " + getClass().getSimpleName());
    408     }
    409     eq FVariable.variability() = getTypePrefixVariability();
     406    syn TypePrefixVariability FAbstractVariable.variability();
     407    eq FVariable        .variability() = getTypePrefixVariability();
     408    eq FFunctionVariable.variability() = Variability.CONTINUOUS;
     409    eq FEnumLiteral     .variability() = Variability.CONTINUOUS;
     410    eq UnknownFVariable .variability() = Variability.CONTINUOUS;
    410411   
    411412    syn boolean FExp.isConstantExp()   = variability().constantVariability();
     
    546547
    547548    syn TypePrefixVariability CommonAccess.variability();
    548     eq FAccess.variability() {
    549         FAbstractVariable variable = myFV();
    550         if (variable instanceof FVariable) {
    551             FVariable fVariable = (FVariable) variable;
    552             return(fVariable.variability());
    553         } else {
    554             return (Variability.CONTINUOUS);
    555         }
    556     }
     549    eq FAccess.variability() = myTopFV().variability();
    557550
    558551    syn TypePrefixVariability FSubscript.variability() = Variability.CONSTANT;
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r11514 r11543  
    3030FClass : BaseNode ::= FAccess
    3131                      FVariable*
    32                       AliasVariable:FVariable*
     32                      AliasVariable:FVariable*
     33                      GlobalVariable:FVariable*
    3334                      FInitialEquation:FAbstractEquation*
    3435                      ParameterEquation:FAbstractEquation*
     
    133134abstract FTypePrefix : BaseNode;
    134135
     136FGlobalVariable : FVariable ::= FType;
     137
    135138/**
    136139 * FVariable of type Real.
  • trunk/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r11524 r11543  
    42184218 constant Real r[2].x = 2;
    42194219 constant Real y = 6.0;
     4220package constant
     4221 constant EvaluationTests.ConstantInFunction1.R EvaluationTests.ConstantInFunction1.r[2] = {EvaluationTests.ConstantInFunction1.R(1), EvaluationTests.ConstantInFunction1.R(2)};
     4222
     4223public
     4224 record EvaluationTests.ConstantInFunction1.R
     4225  Real x;
     4226 end EvaluationTests.ConstantInFunction1.R;
     4227
    42204228end EvaluationTests.ConstantInFunction1;
    42214229")})));
     
    42494257 constant Real y1 = 4.0;
    42504258 constant Real y2 = 2.0;
     4259package constant
     4260 constant EvaluationTests.ConstantInFunction2.R EvaluationTests.ConstantInFunction2.r[2] = {EvaluationTests.ConstantInFunction2.R(1), EvaluationTests.ConstantInFunction2.R(2)};
     4261
     4262public
     4263 record EvaluationTests.ConstantInFunction2.R
     4264  Real x;
     4265 end EvaluationTests.ConstantInFunction2.R;
     4266
    42514267end EvaluationTests.ConstantInFunction2;
    42524268")})));
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r11534 r11543  
    130130    public class Flattener {
    131131        private FClass fc;
    132         private List<FVariable>         variables   = new List<FVariable>();
    133         private List<FAbstractEquation> normalEqns  = new List<FAbstractEquation>();
    134         private List<FAbstractEquation> initialEqns = new List<FAbstractEquation>();
    135         private List<FAbstractEquation> parameterEqns = new List<FAbstractEquation>();
     132        private List<FVariable>         globalVariables = new List<FVariable>();
     133        private List<FVariable>         variables       = new List<FVariable>();
     134        private List<FAbstractEquation> normalEqns      = new List<FAbstractEquation>();
     135        private List<FAbstractEquation> initialEqns     = new List<FAbstractEquation>();
     136        private List<FAbstractEquation> parameterEqns   = new List<FAbstractEquation>();
    136137       
    137138        private List<FFunctionDecl> functionDecls = new List<FFunctionDecl>();
     
    159160        }
    160161
     162        public boolean isFlattenedGlobalVariable(InstNode n) {
     163            return flattenedNodes.contains(n.surroundingInstClass().qualifiedName() + "." + n.qualifiedName());
     164        }
     165
    161166        public List<FAbstractEquation> getNormalEquations() {
    162167            return normalEqns;
     
    171176        }
    172177       
     178        public List<FVariable> getGlobalVariables() {
     179            return globalVariables;
     180        }
     181       
    173182        public List<FVariable> getFVariables() {
    174183            return variables;
     
    189198        public List<FDerivedType> getFDerivedTypes() {
    190199            return derivedTypes;
     200        }
     201       
     202        public List<FVariable> addGlobalVariable(FVariable fvariable) {
     203            addFlattened(fvariable.name());
     204            return globalVariables.add(fvariable);
    191205        }
    192206       
     
    249263    // refined in OptimicaFlattening
    250264    public void FClass.update(Flattener f) {
     265        setGlobalVariableList(f.getGlobalVariables());
    251266        setFVariableList(f.getFVariables());
    252267        setFAbstractEquationList(f.getNormalEquations());
     
    472487            ffd.copyInlineAnnotation(findInlineAnnotationRoot());
    473488            ffd.smoothOrder(smoothOrder());
    474            
    475             addLocalFunctionConstants(f, ffd);
    476489            flattenUsedFuncsAndEnums(f);
    477490            ffd.updateRecordArraySizes();
     
    622635    }
    623636
    624     private void InstBaseClassDecl.addLocalFunctionConstants(Flattener f, FFunctionDecl ffd) {
    625         Set<InstAssignable> added = new HashSet<InstAssignable>();
    626         Set<InstAssignable> all = localFunctionConstantList();
    627         List<FFunctionVariable> ffvs = new List<FFunctionVariable>();
    628         List<FStatement> stmts = new List<FStatement>();
    629         int n = 0;
    630         while (n < all.size()) {
    631             n = all.size();
    632             // We need a copy of all since it can be modified during iteration
    633             for (InstAssignable cons : all.toArray(new InstAssignable[n])) {
    634                 if (added.add(cons)) {
    635                     cons.flattenInFunction(f, ffvs, stmts, true, this);
    636                     cons.flattenUsedFuncsAndEnums(f);
    637                     all.remove(cons);
    638                 }
    639             }
    640         }
    641         ffvs.addAll(ffd.getFFunctionVariableListNoTransform());
    642         stmts.addAll(ffd.getFAlgorithmNoTransform().getFStatementListNoTransform());
    643         ffd.setFFunctionVariableList(ffvs);
    644         ffd.getFAlgorithmNoTransform().setFStatementList(stmts);
    645     }
    646 
    647637    public void FFunctionDecl.updateRecordArraySizes() {
    648638        for (FFunctionVariable ffv : getFFunctionVariables())
     
    686676            if (added.add(icd.name())) {
    687677                HashMap<InstNode,Integer> oldLevels2 = icd.setModificationLevel(level + 1);
    688                 icd.flattenInFunction(f, vars, stmts, false, null);
     678                icd.flattenInFunction(f, vars, stmts);
    689679                icd.flattenUsedFuncsAndEnums(f);
    690680                icd.clearModificationLevel(oldLevels2);
     
    850840    }
    851841   
    852     public void InstComponentDecl.flattenInFunction(
    853             Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts, boolean useConstant, InstClassDecl func) {}
     842    public void InstComponentDecl.flattenInFunction(Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts) {}
    854843   
    855844    @Override
    856     public void InstAssignable.flattenInFunction(
    857             Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts, boolean useConstant, InstClassDecl func) {
    858         if (useConstant || !flattenAsFunctionConstant()) {
    859             InstClassDecl old = temporarilyInFunction;
    860             temporarilyInFunction = func;
     845    public void InstAssignable.flattenInFunction(Flattener f, List<FFunctionVariable> vars, List<FStatement> stmts) {
     846        if (!flattenAsFunctionConstant()) {
    861847            if (hasInstValueMod())
    862848                getBindingFExp().flattenUsedFuncsAndEnums(f);
    863849            Opt eo = new Opt();
    864             FAccess fqn = createFAccessForFuncVar(func);
    865             fqn.removeFArraySubscripts();
     850            FAccess fqn = getFAccess().treeCopy().removeFArraySubscripts();
    866851            FFunctionVariable ffv = createFFunctionVariable(f, eo, fqn);
    867852            if (isInput())
     
    879864            }
    880865            myInstClass().flattenRecord(f);
    881             temporarilyInFunction = old;
    882866        }
    883867    }
     
    956940        }
    957941    }
    958    
    959     syn FAccess InstAssignable.expandedFAccessCalc() {
    960         if (temporarilyInFunction != null) {
    961             return createFAccessForFuncUse(temporarilyInFunction);
    962         } else {
    963             return expandedFAccess().append(name());
    964         }
    965     }
     942
     943    syn FAccess InstAssignable.expandedFAccessCalc() = expandedFAccess().append(name());
    966944
    967945    inh FAccess InstComponentDecl.expandedFAccess();
     
    971949    eq InstArrayComponentDecl.getChild().expandedFAccess() = appendMyName(expandedFAccess());
    972950    eq InstAssignable.getChild().expandedFAccess() {
    973         if (temporarilyInFunction != null) {
    974             return createFAccessForFuncUse(temporarilyInFunction);
    975         }
    976951        if (size().isUnknown()) {
    977952            return expandedFAccess().append(name(), size().flattenSubscript());
     
    981956    }
    982957
    983     /**
    984      * Get the list of constants that need to be added to the surrounding function.
    985      */
    986     inh Set<InstAssignable> InstAccess.functionConstantList();
    987     inh Set<InstAssignable> InstAssignable.functionConstantList();
    988     eq InstClassDecl.getChild().functionConstantList()  = localFunctionConstantList();
    989     eq InstAssignable.getChild().functionConstantList() =
    990         (temporarilyInFunction != null) ?
    991                 temporarilyInFunction.localFunctionConstantList() :
    992                 functionConstantList();
    993     eq Root.getChild().functionConstantList()           = null;
    994    
    995     /**
    996      * The list of constants that need to be added to this function.
    997      *
    998      * The list will be populated when expressions in the function are flattened.
    999      */
    1000     syn lazy Set<InstAssignable> InstClassDecl.localFunctionConstantList() =
    1001         new LinkedHashSet<InstAssignable>();
    1002    
    1003    
    1004958    public class InstLookupResult<T extends InstNode> {
    1005959        /**
     
    1011965    }
    1012966
    1013     public FAccess InstComponentDecl.createFAccessForFuncVar(InstClassDecl func) {
    1014         FAccess name = getFAccess();
    1015         if (func != null) {
    1016             if (name.numParts() > 1 || func.memberInstComponent(name.name()).foundOther(this))
    1017                 return new FAccessString(func.localTempVarName(this));
    1018         }
    1019         return name.fullCopy();
    1020     }
    1021    
    1022     public FAccess InstAssignable.createFAccessForFuncUse(InstClassDecl func) {
    1023         return createFAccessForFuncVar(func).asFAccessFull().addFArraySubscripts(null);
    1024     }
    1025    
    1026967    public FFunctionVariable InstAssignable.createFFunctionVariable(Flattener f, Opt eo, FAccess fqn) {
    1027968        // TODO: if we need separate variable class for records, override this
     
    12511192                fqn = new FAccessString(name());
    12521193            }
    1253             FVariable fv = createFVariable(f, fqn, FlattenBindingExp.NONE);
     1194            FVariable fv = createFVariable(f, fqn, FlattenBindingExp.NONE, false);
    12541195            fv.modifiableInRecord = isModifiable();
    12551196            frd.addFVariableNoTransform(fv);
     
    12831224
    12841225    public void InstAssignable.flatten(Flattener f, FlattenBindingExp binding, int level) {
     1226        flatten(f, binding, level, false);
     1227    }
     1228
     1229    public void InstAssignable.flatten(Flattener f, FlattenBindingExp binding, int level, boolean global) {
    12851230        if (useInFlattening()) {
    12861231            if (hasBindingFExp()) {
     
    12881233            }
    12891234            HashMap<InstNode,Integer> oldLevels = setModificationLevel(level);
    1290             f.addFVariable(createFVariable(f, getFAccess().copyAndAddFas(size().flattenFArraySubscripts(f)), binding));
     1235            FAccess name;
     1236            if (global) {
     1237                name = getFAccess().copyAndPrepend(surroundingInstClass().qualifiedName()).copyAndAddFas(size().flattenFArraySubscripts(f));
     1238            } else {
     1239                name = getFAccess().copyAndAddFas(size().flattenFArraySubscripts(f));
     1240            }
     1241            FVariable fv = createFVariable(f, name, binding, global);
     1242            if (global) {
     1243                f.addGlobalVariable(fv);
     1244            } else {
     1245                f.addFVariable(fv);
     1246            }
    12911247            flattenMyType(f);
    12921248            clearModificationLevel(oldLevels);
     
    15511507    public void InstLibNode.flattenEnum(Flattener f) {
    15521508        actualInstClass().flattenEnum(f);
     1509    }
     1510
     1511    public FVariable InstAssignable.createEmptyFGlobalVariable(Flattener f) {
     1512        FGlobalVariable res = new FGlobalVariable();
     1513        res.setFType(type().flatten(f, this, false));
     1514        return res;
    15531515    }
    15541516   
     
    16501612        }
    16511613        boolean flattenBinding = binding.shouldFlattenExp(this);
    1652         if (flattenBinding && declaredSizeCalc().isUnknownNoEval()) {
     1614        if (flattenBinding && !isConstant() && declaredSizeCalc().isUnknownNoEval()) {
    16531615            FInternalAttribute ia = (FInternalAttribute)findMatching(list, "size()");
    16541616            if (ia == null) {
     
    17131675
    17141676    public FVariable InstAssignable.createFVariable(Flattener f) {
    1715         return createFVariable(f, getFAccess(), FlattenBindingExp.ALL);
    1716     }
    1717 
    1718     public FVariable InstAssignable.createFVariable(Flattener f, FAccess name, FlattenBindingExp binding) {
    1719         FVariable fv = createEmptyFVariable();
     1677        return createFVariable(f, getFAccess(), FlattenBindingExp.ALL, false);
     1678    }
     1679
     1680    public FVariable InstAssignable.createFVariable(Flattener f, FAccess name, FlattenBindingExp binding, boolean global) {
     1681        FVariable fv = global ? createEmptyFGlobalVariable(f) : createEmptyFVariable();
    17201682        fv.setVisibilityType(createVisibilityType());
    17211683        fv.setTypePrefixVariability(variability());
  • trunk/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningAccess.jrag

    r11514 r11543  
    223223aspect FlatteningFunctionConstant {
    224224    public FExp InstAssignable.flattenAccessToConst(Flattener f, FIdUseExp iae) {
    225         // If the FInstAccess refers to a constant or string parameter, then inline expression
    226         // Checks in the instance tree ensures that constants always
    227         // have binding expressions, however, array subscripts may need to be
    228         // flattened during error checks, when using qualifiedName()
     225        FType t = iae.type();
     226        if (t.isEmpty()) {
     227            return t.createEmptyExp();
     228        }
    229229        InstAccess ia = iae.asInstAccess();
    230         if (variability().indexParameterOrLess()) {
    231             if (iae.canInlineConstant()) {
    232                 try {
    233                     FType t = iae.type();
    234                     if (t.isEmpty()) {
    235                         return t.createEmptyExp();
    236                     }
    237                     // Check if we have non-constant array subscripts
    238                     if (ia.hasUnknownIndices()) {
    239                         // If this is a package constant, then the variable will not be available in the flattened model
    240                         if (!ia.inFunction() && variability().constantVariability()) {
    241                             // Inline entire array wrapped in an FSubscriptedExp, and resolve index later
    242                             FExp exp = getBindingFExp().buildLiteral(isReal());
    243                             FArraySubscripts fas = ia.getFArraySubscripts().flatten(f);
    244                             return new FSubscriptedExp(exp, fas);
    245                         }
    246                     } else {
    247                         // Inline value
    248                         CValue cval = iae.ceval();
    249                         if (isReal() && cval.hasConvertReal()) {
    250                             cval = cval.convertReal();
    251                         }
    252                         if (cval.hasBuildLiteral()) {
    253                             return cval.buildLiteral();
    254                         }
    255                     }
    256                 } catch (ConstantEvaluationException e) {
    257                     // In this case, simply don't inline value if we aren't in a function
     230        if (iae.canInlineConstant() && !ia.hasUnknownIndices()) {
     231            try {
     232                CValue cval = iae.ceval();
     233                if (isReal() && cval.hasConvertReal()) {
     234                    cval = cval.convertReal();
    258235                }
    259             }
    260             if (ia.inFunction() && flattenAsFunctionConstant())
    261                 return ia.topInstAssignable().flattenAccessToConstInFunction(f, ia);
     236                if (cval.hasBuildLiteral()) {
     237                    return cval.buildLiteral();
     238                }
     239            } catch (ConstantEvaluationException e) {
     240                // TODO: Error
     241            }
     242        }
     243        if (ia.inFunction() && flattenAsFunctionConstant()) {
     244            InstAssignable top = ia.topInstAssignable();
     245            if (!f.isFlattenedGlobalVariable(top)) {
     246                top.flatten(f, FlattenBindingExp.ALL, 0, true);
     247            }
     248            return new FIdUseExp(ia.flatten().copyAndPrepend(top.surroundingInstClass().qualifiedName()));
    262249        }
    263250        return null;
    264251    }
    265    
     252
    266253    syn boolean InstAssignable.flattenAsFunctionConstant() =
    267254            !isInput() && !isOutput() && variability().knownParameterOrLess();
     
    289276    eq InstFunctionArgument.getChild().canInlineConstant()  = canInlineConstant();
    290277    eq InstRecordConstructor.getArg().canInlineConstant()   = canInlineConstant();
    291 
    292     /**
    293      * Flatten an access to this constant in a function.
    294      *
    295      * Used when the access can't be constant evaluated. The constant is added to the function.
    296      */
    297     public FExp InstAssignable.flattenAccessToConstInFunction(Flattener f, InstAccess ia) {
    298         ia.functionConstantList().add(this);
    299         FAccess name = getFAccess();
    300         FAccess use = ia.flatten();
    301         if (name.numParts() > 1 || ia.localLookupInstComponent(name.name()).foundOther(this)) {
    302             // TODO: this should probably be a helper function on FAccess
    303             FAccessFull fullUse = use.asFAccessFull();
    304             fullUse.getFAccessPart(0).setName(ia.findTempVarName(this));
    305             use = fullUse;
    306         }
    307         return new FIdUseExp(use);
    308     }
    309278
    310279    private Map<InstComponentDecl,String> InstClassDecl.tempVarNames;
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/ArrayTests.mo

    r11460 r11543  
    89868986
    89878987model ArrayConst3
    8988     function f
    8989         input Real i;
    8990         output Real o;
    8991     algorithm
    8992         o := testConst[integer(i)];
    8993     end f;
    8994    
    8995     Real x = f(1);
    8996 
    8997     annotation(__JModelica(UnitTesting(tests={
    8998         TransformCanonicalTestCase(
    8999             name="Other_ArrayConst3",
    9000             description="Array constants used with index of discrete variability",
    9001             flatModel="
     8988
     8989    constant Real[:] c = {2,3};
     8990
     8991    function f
     8992        input Real i;
     8993        output Real o;
     8994    algorithm
     8995        o := c[integer(i)];
     8996        annotation(Inline=false);
     8997    end f;
     8998
     8999    Real x = f(1);
     9000
     9001    annotation(__JModelica(UnitTesting(tests={
     9002        TransformCanonicalTestCase(
     9003            name="Other_ArrayConst3",
     9004            description="Array constants used with index of discrete variability",
     9005            variability_propagation=false,
     9006            flatModel="
    90029007fclass ArrayTests.Other.ArrayConst3
    9003  constant Real x = 1;
     9008 constant Real c[1] = 2;
     9009 constant Real c[2] = 3;
     9010 Real x;
     9011package constant
     9012 constant Real ArrayTests.Other.ArrayConst3.c[2] = {2, 3};
     9013equation
     9014 x = ArrayTests.Other.ArrayConst3.f(1);
     9015
     9016public
     9017 function ArrayTests.Other.ArrayConst3.f
     9018  input Real i;
     9019  output Real o;
     9020 algorithm
     9021  o := ArrayTests.Other.ArrayConst3.c[integer(i)];
     9022  return;
     9023 annotation(Inline = false);
     9024 end ArrayTests.Other.ArrayConst3.f;
     9025
    90049026end ArrayTests.Other.ArrayConst3;
    90059027")})));
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/FunctionTests.mo

    r11534 r11543  
    465465    algorithm
    466466        y := x .+ a[i] .+ a[i+1];
     467        annotation(Inline=false);
    467468    end f;
    468469   
     
    481482 Real z[1];
    482483 Real z[2];
     484package constant
     485 constant Real FunctionTests.FunctionFlatten9.a[3] = {1, 2, 3};
    483486equation
    484487 ({z[1], z[2]}) = FunctionTests.FunctionFlatten9.f({3, 4}, 1);
     
    486489public
    487490 function FunctionTests.FunctionFlatten9.f
    488   Real[:] a;
    489491  input Real[:] x;
    490492  input Integer i;
    491493  output Real[:] y;
    492494 algorithm
    493   init a as Real[3];
    494   a[1] := 1;
    495   a[2] := 2;
    496   a[3] := 3;
    497495  init y as Real[2];
    498   y[1] := x[1] .+ a[i] .+ a[i + 1];
    499   y[2] := x[2] .+ a[i] .+ a[i + 1];
    500   return;
     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);
    501500 end FunctionTests.FunctionFlatten9.f;
    502501
     
    10031002fclass FunctionTests.FunctionFlatten21
    10041003 Real x = FunctionTests.FunctionFlatten21.f();
     1004package constant
     1005 constant Real FunctionTests.FunctionFlatten21.f.x; // TODO: Compilation error?
    10051006
    10061007public
    10071008 function FunctionTests.FunctionFlatten21.f
    1008   Real x;
    10091009  output Real y;
    10101010 algorithm
    1011   y := x;
     1011  y := FunctionTests.FunctionFlatten21.f.x;
    10121012  return;
    10131013 end FunctionTests.FunctionFlatten21.f;
     
    10811081fclass FunctionTests.FunctionFlatten23
    10821082 Real y;
     1083package constant
     1084 constant FunctionTests.FunctionFlatten23.R FunctionTests.FunctionFlatten23.f.r = FunctionTests.FunctionFlatten23.R(1, {3.14});
    10831085equation
    10841086 y = FunctionTests.FunctionFlatten23.f(time);
     
    10861088public
    10871089 function FunctionTests.FunctionFlatten23.f
    1088   FunctionTests.FunctionFlatten23.R r;
    10891090  input Real x;
    10901091  output Real y;
    10911092 algorithm
    1092   r.n := 1;
    1093   r.a[1] := 3.14;
    10941093  for i in 1:1 loop
    1095    y := r.a[i] * x;
     1094   y := FunctionTests.FunctionFlatten23.f.r.a[i] * x;
    10961095  end for;
    10971096  return;
     
    1028010279    algorithm
    1028110280      y1 := f2({a[i], a[i+1]});
     10281        annotation(Inline=false);
    1028210282    end f1;
    1028310283   
     
    1028610286        output Real y2 = sum(x2);
    1028710287    algorithm
     10288        annotation(Inline=false);
    1028810289    end f2;
    1028910290   
     
    1030110302 constant Real a[3] = 3;
    1030210303 Real x;
     10304package constant
     10305 constant Real FunctionTests.UnknownArray29.a[3] = {1, 2, 3};
    1030310306equation
    1030410307 x = FunctionTests.UnknownArray29.f1(1);
     
    1030610309public
    1030710310 function FunctionTests.UnknownArray29.f1
    10308   Real[:] a;
    1030910311  input Integer i;
    1031010312  output Real y1;
    1031110313 algorithm
    10312   init a as Real[3];
    10313   a[1] := 1;
    10314   a[2] := 2;
    10315   a[3] := 3;
    10316   y1 := FunctionTests.UnknownArray29.f2({a[i], a[i + 1]});
    10317   return;
     10314  y1 := FunctionTests.UnknownArray29.f2({FunctionTests.UnknownArray29.a[i], FunctionTests.UnknownArray29.a[i + 1]});
     10315  return;
     10316 annotation(Inline=false);
    1031810317 end FunctionTests.UnknownArray29.f1;
    1031910318
     
    1032910328  y2 := temp_1;
    1033010329  return;
     10330 annotation(Inline=false);
    1033110331 end FunctionTests.UnknownArray29.f2;
    1033210332
     
    1248112481 constant Real d[2] = {1, 2};
    1248212482 Real x = FunctionTests.ExtendFunc2.f2(1, 2);
     12483package constant
     12484 constant Real FunctionTests.ExtendFunc2.d[2] = {1, 2};
    1248312485
    1248412486public
    1248512487 function FunctionTests.ExtendFunc2.f2
    12486   Real[:] d;
    1248712488  input Real a;
    1248812489  output Real b;
     
    1249012491  Real f;
    1249112492 algorithm
    12492   init d as Real[2];
    12493   d := {1, 2};
    12494   f := a + d[c];
     12493  f := a + FunctionTests.ExtendFunc2.d[c];
    1249512494  b := f;
    1249612495  return;
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo

    r11427 r11543  
    17111711 parameter Integer j = 1 /* 1 */;
    17121712 Real y = NameTests.ConstantLookup32.f(j);
     1713package constant
     1714 constant NameTests.ConstantLookup32.A NameTests.ConstantLookup32.C.d[2] = {NameTests.ConstantLookup32.A(3), NameTests.ConstantLookup32.A(4)};
    17131715
    17141716public
    17151717 function NameTests.ConstantLookup32.f
    1716   NameTests.ConstantLookup32.A[:] d;
    17171718  input Integer i;
    17181719  output Real x;
    17191720 algorithm
    1720   init d as NameTests.ConstantLookup32.A[2];
    1721   d := {NameTests.ConstantLookup32.A(3), NameTests.ConstantLookup32.A(4)};
    1722   x := d[i].b;
     1721  x := NameTests.ConstantLookup32.C.d[i].b;
    17231722  return;
    17241723 end NameTests.ConstantLookup32.f;
     
    17691768 parameter Integer j = 1 /* 1 */;
    17701769 Real y = NameTests.ConstantLookup33.f(j);
     1770package constant
     1771 constant NameTests.ConstantLookup33.D.A NameTests.ConstantLookup33.C.d[2] = {NameTests.ConstantLookup33.D.A(3), NameTests.ConstantLookup33.D.A(4)};
    17711772
    17721773public
    17731774 function NameTests.ConstantLookup33.f
    1774   NameTests.ConstantLookup33.D.A[:] d;
    17751775  input Integer i;
    17761776  output Real x;
    17771777 algorithm
    1778   init d as NameTests.ConstantLookup33.D.A[2];
    1779   d := {NameTests.ConstantLookup33.D.A(3), NameTests.ConstantLookup33.D.A(4)};
    1780   x := d[i].b;
     1778  x := NameTests.ConstantLookup33.C.d[i].b;
    17811779  return;
    17821780 end NameTests.ConstantLookup33.f;
     
    18051803    algorithm
    18061804        x := A.x[i].y[i];
     1805        annotation(Inline=false);
    18071806    end f;
    18081807   
     
    18181817 parameter Integer j = 1 /* 1 */;
    18191818 parameter Real z;
     1819package constant
     1820 constant NameTests.ConstantLookup34.A.B NameTests.ConstantLookup34.A.x[2] = {NameTests.ConstantLookup34.A.B({1, 2}), NameTests.ConstantLookup34.A.B({3, 4})};
    18201821parameter equation
    18211822 z = NameTests.ConstantLookup34.f(j);
     
    18231824public
    18241825 function NameTests.ConstantLookup34.f
    1825   NameTests.ConstantLookup34.A.B[:] temp_1;
    18261826  input Integer i;
    18271827  output Real x;
    18281828 algorithm
    1829   init temp_1 as NameTests.ConstantLookup34.A.B[2];
    1830   temp_1[1].y[1] := 1;
    1831   temp_1[1].y[2] := 2;
    1832   temp_1[2].y[1] := 3;
    1833   temp_1[2].y[2] := 4;
    1834   x := temp_1[i].y[i];
     1829  x := NameTests.ConstantLookup34.A.x[i].y[i];
    18351830  return;
     1831 annotation(Inline = false);
    18361832 end NameTests.ConstantLookup34.f;
    18371833
     
    19031899 parameter Integer b.j = 1 /* 1 */;
    19041900 parameter Real b.z;
     1901package constant
     1902 constant Real NameTests.ConstantLookup35.L.a[2] = {1, 2};
    19051903parameter equation
    19061904 b.z = NameTests.ConstantLookup35.J.f1(b.j);
     
    19081906public
    19091907 function NameTests.ConstantLookup35.J.f1
    1910   Real[:] a;
    19111908  input Integer i;
    19121909  output Real x;
    19131910  Real y;
    19141911 algorithm
    1915   init a as Real[2];
    1916   a[1] := 1;
    1917   a[2] := 2;
    1918   y := a[i];
     1912  y := NameTests.ConstantLookup35.L.a[i];
    19191913  x := y;
    19201914  return;
     
    19381932    algorithm
    19391933        x := a[i].b[i];
     1934        annotation(Inline=false);
    19401935    end f;
    19411936   
     
    19511946 parameter Integer j = 1 /* 1 */;
    19521947 parameter Real z;
     1948package constant
     1949 constant NameTests.ConstantLookup36.B NameTests.ConstantLookup36.f.a[2] = {NameTests.ConstantLookup36.B({1, 2}), NameTests.ConstantLookup36.B({3, 4})};
    19531950parameter equation
    19541951 z = NameTests.ConstantLookup36.f(j);
     
    19561953public
    19571954 function NameTests.ConstantLookup36.f
    1958   NameTests.ConstantLookup36.B[:] a;
    19591955  input Integer i;
    19601956  output Real x;
    19611957 algorithm
    1962   init a as NameTests.ConstantLookup36.B[2];
    1963   a[1].b[1] := 1;
    1964   a[1].b[2] := 2;
    1965   a[2].b[1] := 3;
    1966   a[2].b[2] := 4;
    1967   x := a[i].b[i];
     1958  x := NameTests.ConstantLookup36.f.a[i].b[i];
    19681959  return;
     1960 annotation(Inline = false);
    19691961 end NameTests.ConstantLookup36.f;
    19701962
  • trunk/Compiler/ModelicaFrontEnd/test/modelica/RecordTests.mo

    r11460 r11543  
    20342034    algorithm
    20352035        x := f2(r[i]);
     2036        annotation(Inline=false);
    20362037    end f1;
    20372038   
     
    20592060 Real w;
    20602061 discrete Integer i;
     2062package constant
     2063 constant RecordTests.UnmodifiableComponent5.R RecordTests.UnmodifiableComponent5.r[2] = {RecordTests.UnmodifiableComponent5.R(1), RecordTests.UnmodifiableComponent5.R(2)};
    20612064initial equation
    20622065 pre(i) = 0;
     
    20672070public
    20682071 function RecordTests.UnmodifiableComponent5.f1
    2069   RecordTests.UnmodifiableComponent5.R[:] r;
    20702072  input Integer i;
    20712073  output Real x;
    20722074 algorithm
    2073   init r as RecordTests.UnmodifiableComponent5.R[2];
    2074   r[1].x := 1;
    2075   r[2].x := 2;
    2076   x := RecordTests.UnmodifiableComponent5.f2(r[i]);
     2075  x := RecordTests.UnmodifiableComponent5.f2(RecordTests.UnmodifiableComponent5.r[i]);
    20772076  return;
     2077 annotation(Inline = false);
    20782078 end RecordTests.UnmodifiableComponent5.f1;
    20792079
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/TransformCanonical.jrag

    r11514 r11543  
    11251125     */
    11261126    abstract public FVariable FVariable.createPreVariable();
    1127    
     1127
     1128    public FVariable FGlobalVariable.createPreVariable() {
     1129        throw new UnsupportedOperationException();
     1130    }
     1131
    11281132    public FVariable FRealVariable.createPreVariable() {
    11291133        return new FPreRealVariable(this);
     
    29442948            decl.resetUsedIndicator();
    29452949        getFVariables().markUsedFunctionsAndRecords();
     2950        getGlobalVariables().markUsedFunctionsAndRecords();
    29462951        getFInitialEquations().markUsedFunctionsAndRecords();
    29472952        getParameterEquations().markUsedFunctionsAndRecords();
     
    30683073        }
    30693074    }
    3070    
     3075
     3076    @Override
     3077    public void FRecordVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
     3078        super.markUsedFunctionsAndRecords(type);
     3079        myFRecordDecl().markUsedFunctionsAndRecords(type);
     3080    }
     3081
    30713082    @Override
    30723083    public void FType.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/InlineFunctions.jrag

    r11514 r11543  
    10451045    }
    10461046
     1047    /**
     1048     * All uses of this variable that are the left-hand side of an assignment or
     1049     * function call statement.
     1050     */
     1051    coll HashSet<FIdUseExp> FFunctionVariable.assigningUses() [new HashSet<FIdUseExp>()]
     1052        with add root FFunctionDecl;
     1053    FIdUseExp contributes this when isAssignedTo() && myFuncFV() != null
     1054        to FFunctionVariable.assigningUses() for myFuncFV();
     1055
     1056    syn FFunctionVariable FIdUseExp.myFuncFV() = getCommonAccess().asFAccess().myFuncFV();
     1057    syn FFunctionVariable FAccess.myFuncFV()    = (FFunctionVariable) myOutermostFV();
     1058
    10471059    syn boolean FFunctionVariable.isTrivialInlinable(boolean late, FFunctionCall call) = false;
    10481060
     
    15231535                exp = dynamicFExp(exp.treeCopyNoTransform());
    15241536            } else {
    1525                 if (isArray() && !size().isUnknown()) {
     1537                if (variability().knownParameterOrLess()) {
     1538                    exp = ceval().buildLiteral();
     1539                } else if (isArray() && !size().isUnknown()) {
    15261540                    exp = getArray().buildWithReplacedReferences(fi, this);
    15271541                } else if (type().isRecord()) {
  • trunk/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/Scalarization.jrag

    r11514 r11543  
    10771077          fqn = fqn.copyAndAddFas(createIndexNameFas());
    10781078      }
    1079       fqn = fqn.asFAccessFull().copyAndAppend(suffix);
     1079      fqn = fqn.asFAccessFull().treeCopy().append(suffix);
    10801080      fqn.scalarized = false;
    10811081      FExp res = createNode(fqn);
  • trunk/Compiler/ModelicaMiddleEnd/test/modelica/FunctionInlining.mo

    r11409 r11543  
    49984998end EqType1;
    49994999
     5000model GlobalConst1
     5001    constant Real[:] c = {2,3};
     5002
     5003    function f
     5004        input Real i;
     5005        output Real o;
     5006    algorithm
     5007        o := c[integer(i)];
     5008    end f;
     5009
     5010    Real x = f(1);
     5011
     5012    annotation(__JModelica(UnitTesting(tests={
     5013        TransformCanonicalTestCase(
     5014            name="GlobalConst1",
     5015            description="Inlining global constant",
     5016            variability_propagation=false,
     5017            flatModel="
     5018fclass FunctionInlining.GlobalConst1
     5019 constant Real c[1] = 2;
     5020 constant Real c[2] = 3;
     5021 Real x;
     5022package constant
     5023 constant Real FunctionInlining.GlobalConst1.c[2] = {2, 3};
     5024equation
     5025 x = 2.0;
     5026end FunctionInlining.GlobalConst1;
     5027")})));
     5028end GlobalConst1;
     5029
     5030model GlobalConst2
     5031    record R1
     5032        parameter Real x;
     5033    end R1;
     5034    record R2
     5035        parameter R1[2] r1;
     5036    end R2;
     5037    function f
     5038        input Integer i;
     5039        constant R2 a = R2({R1(2),R1(3)});
     5040        output R1 y = a.r1[i];
     5041    algorithm
     5042    end f;
     5043   
     5044    R1 y = f(integer(time));
     5045
     5046    annotation(__JModelica(UnitTesting(tests={
     5047        TransformCanonicalTestCase(
     5048            name="GlobalConst2",
     5049            description="Inlining global constant",
     5050            variability_propagation=false,
     5051            flatModel="
     5052fclass FunctionInlining.GlobalConst2
     5053 parameter Integer temp_2;
     5054 parameter Real y.x;
     5055package constant
     5056 constant FunctionInlining.GlobalConst2.R2 FunctionInlining.GlobalConst2.f.a = FunctionInlining.GlobalConst2.R2({FunctionInlining.GlobalConst2.R1(2), FunctionInlining.GlobalConst2.R1(3)});
     5057parameter equation
     5058 temp_2 = integer(time);
     5059 y.x = ({2, 3})[temp_2];
     5060
     5061public
     5062 record FunctionInlining.GlobalConst2.R1
     5063  parameter Real x;
     5064 end FunctionInlining.GlobalConst2.R1;
     5065
     5066 record FunctionInlining.GlobalConst2.R2
     5067  parameter FunctionInlining.GlobalConst2.R1 r1[2];
     5068 end FunctionInlining.GlobalConst2.R2;
     5069
     5070end FunctionInlining.GlobalConst2;
     5071")})));
     5072end GlobalConst2;
     5073
    50005074end FunctionInlining;
  • trunk/Python/src/tests_jmodelica/files/Modelica/ExtFunctionTests.mo

    r11541 r11543  
    421421        constant Real a1 = f1(1) + f2(2) + f3(3) + f4(4);
    422422    end ShortClass;
     423   
     424    model PackageConstantTest
     425      constant Real[2] c = {4,5};
     426     
     427      function f
     428        output Real[2] x_out;
     429      external "C" fRealArray(c, size(c,1), x_out, size(x_out,1)) annotation(
     430        Library="externalFunctionsC",
     431        Include="#include \"externalFunctionsC.h\"");
     432      end f;
     433   
     434      constant Real[2] x  = f();
     435    end PackageConstantTest;
     436   
    423437  end C;
    424438 
  • trunk/Python/src/tests_jmodelica/files/Modelica/FunctionTests.mo

    r10446 r11543  
    373373end FuncCallInputOutputArray1;
    374374
     375model GlobalConstant1
     376    record R
     377        Real[:] a;
     378    end R;
     379   
     380    function f
     381        input Real x;
     382        input Integer i;
     383        constant R[:] c = {R(1:2), R(3:4)};
     384        output Real y = c[i].a[i] + x;
     385        algorithm
     386    annotation(Inline=false);
     387    end f;
     388   
     389    Real y = f(time, 2);
     390end GlobalConstant1;
     391
    375392  annotation (uses(Modelica(version="3.1")));
    376393end FunctionTests;
  • trunk/Python/src/tests_jmodelica/general/test_extfunctions.py

    r11541 r11543  
    473473        nose.tools.assert_almost_equal(resConst.final('a1'), 10*3.14)
    474474
     475    @testattr(stddist_full = True)
     476    def testCEvalPackageConstant(self):
     477        cpath = "ExtFunctionTests.CEval.C.PackageConstantTest"
     478        fmu_name = compile_fmu(cpath, self.fpath)
     479        model = load_fmu(fmu_name)
     480        res = model.simulate()
     481        nose.tools.assert_equals(res.final('x[2]'), 4)
     482
    475483class TestFortranBasic:
    476484    '''
  • trunk/Python/src/tests_jmodelica/general/test_functions.py

    r10320 r11543  
    227227        self.assert_end_value('p2[1]', 3)
    228228        self.assert_end_value('p2[2]', 3)
     229
     230class TestGlobalConstant1(SimulationTest):
     231    @classmethod
     232    def setUpClass(cls):
     233        SimulationTest.setup_class_base('FunctionTests.mo',
     234            'FunctionTests.GlobalConstant1')
     235
     236    @testattr(stddist_full = True)
     237    def setUp(self):
     238        self.setup_base()
     239        self.run()
     240       
     241    @testattr(stddist_full = True)
     242    def test_GlobalConstant1(self):
     243        self.assert_end_value('y', 14)
  • trunk/RuntimeLibrary/src/jmi/jmi.c

    r11379 r11543  
    298298
    299299    jmi_->dyn_fcn_mem = jmi_dynamic_function_pool_create(JMI_MEMORY_POOL_SIZE);
     300    jmi_->dyn_fcn_mem_globals = jmi_dynamic_function_pool_create(JMI_MEMORY_POOL_SIZE);
    300301
    301302    return 0;
     
    353354    jmi_destroy_delay_if(jmi);
    354355    jmi_dynamic_function_pool_destroy(jmi->dyn_fcn_mem);
     356    jmi_dynamic_function_pool_destroy(jmi->dyn_fcn_mem_globals);
    355357
    356358    free(jmi->globals);
  • trunk/RuntimeLibrary/src/jmi/jmi.h

    r10866 r11543  
    468468
    469469    jmi_dynamic_function_memory_t* dyn_fcn_mem;
     470    jmi_dynamic_function_memory_t* dyn_fcn_mem_globals;
    470471   
    471472    void* globals;                       /**< \brief Global temporaries used in generated code */
     
    601602int jmi_set_start_values(jmi_t *jmi);
    602603
     604int jmi_set_globals_start(jmi_t *jmi);
     605
    603606/* Initialize delay interface
    604607 * Called when initializing jmi struct */
  • trunk/RuntimeLibrary/src/jmi/jmi_dyn_mem.h

    r10639 r11543  
    4848/* Dynamic deallocation of all dynamically allocated arrays and record arrays - should be called before return */
    4949#define JMI_DYNAMIC_FREE() jmi_dynamic_function_free(&dyn_mem);
     50
     51/* Repoint to a persistent memory pool, used for functions that set up memory that should not
     52   be freed when exiting function. */
     53#define JMI_GLOBALS_INIT() \
     54    dyn_mem.mem = jmi->dyn_fcn_mem_globals;
     55
     56/* Reset the pool pointer, avoiding freeing of the memory in the persistent pool */
     57#define JMI_GLOBALS_FREE() \
     58    dyn_mem.mem = NULL;
    5059
    5160/**
  • trunk/RuntimeLibrary/src/jmi/jmi_me.c

    r11379 r11543  
    5959   
    6060    /* set start values*/
     61    if (jmi_generic_func(jmi_, jmi_set_globals_start) != 0) {
     62        jmi_log_node(jmi_->log, logError, "SetGlobalsValuesFailure","Failed to set globals start values.");
     63        jmi_delete(jmi_);
     64        return -1;
     65    }
     66   
    6167    if (jmi_generic_func(jmi_, jmi_set_start_values) != 0) {
    6268        jmi_log_node(jmi_->log, logError, "SetStartValuesFailure","Failed to set start values.");
Note: See TracChangeset for help on using the changeset viewer.