Changeset 11573


Ignore:
Timestamp:
Sep 10, 2018 4:25:00 PM (15 months ago)
Author:
Jonathan Kämpe
Message:

#5670 Merging all changesets related to #5670 to release branch

Location:
branches/2.4.x
Files:
55 edited
2 copied

Legend:

Unmodified
Added
Removed
  • branches/2.4.x

  • branches/2.4.x/CHANGELOG.txt

    r11571 r11573  
    33Fixed an issue where gcc compiled FMUs did not work on Windows 10 together
    44with a VS2017 compiled software.
     5
     6; Changed ; Minor ; Compiler ; #5670
     7Update handling of constants, and accesses to package constants, in functions
     8for improved compilation and simulation performance.
    59
    610; Fixed ; Minor ; Runtime ; #5665
  • branches/2.4.x/Compiler/GenericCodeGen/src/jastadd/ExternalCEvalTag.jrag

    r10338 r11573  
    5151   
    5252    /* Used when unit testing. Temp names will accumulate over all tests */
    53     private static final CodeGenContext unitCgc = new CodeGenContext();
    5453    private static final Map<String,String> unitTempMap = new HashMap<String,String>();
    5554   
    5655    public  void generate(CodeStream str) {
    5756        if (ext == null) {
     57            CodeGenContext unitCgc = new CodeGenContext().createProxy();
    5858            for (FExternalStmt ext : fClass.myExternals()) {
    59                 if (ext.canEvaluate(ASTNode.defaultVariableEvaluator().createEmptyAlgorithmEvaluator(ext.myOptions()))
    60                         && !ext.isConstructorStmt() && !ext.isDestructorStmt()) {
     59                if (!ext.isConstructorStmt() && !ext.isDestructorStmt()) {
    6160                    generate_wrap(str, ext, unitCgc, unitTempMap);
    6261                }
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGen.jrag

    r11572 r11573  
    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();
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenAlgorithms.jrag

    r11572 r11573  
    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);
     
    122122    public void FExternalStmt.genVarDecls_C(CodePrinter p, CodeStream str, String indent) {
    123123        FExternalLanguage lang = getFExternalLanguage();
    124         lang.genVarDecls_C(p, str, indent, this);
     124        lang.genVarDecls_C(p, str, indent, this, codeGenContext != null);
    125125        lang.genFuncDecl(p, str, indent, this);
    126126    }
     
    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
     
    394394    @Override
    395395    public void FExternalStmt.prettyPrint_C(CodePrinter p, CodeStream str, String indent) {
     396        boolean ceval = codeGenContext != null;
    396397        // Generate temp arrays for all array inputs and outputs
    397398        // and transpose array for if array is input (Fortran 77 only)
    398         getFExternalLanguage().prepExternalArg(p, str, indent, this, false);
     399        getFExternalLanguage().prepExternalArg(p, str, indent, this, false, getCodeGenContext(), ceval);
    399400       
    400401        str.print(indent);
    401402        // return variable?
    402403        if(hasReturnVar()) {
    403             String name = getReturnVar().type().isRecord() ?
     404            String name = getCodeGenContext().alias(getReturnVar().myCommonVarDecl());
     405            if (name == null) {
     406                name = getReturnVar().type().isRecord() ?
    404407                    "*"+getReturnVar().tempName_C() :
    405408                    getReturnVar().getCommonAccess().name_C();
    406             str.print(getCodeGenContext().alias(name));
     409            }
     410            str.print(name);
    407411            str.print(" = ");
    408412        }
    409413       
    410         // print function call
    411         getFExternalLanguage().genFuncCall(p, str, indent, this);
     414        CodeGenContext cgc = getCodeGenContext().createProxy();
     415        getFExternalLanguage().extraContext(this, cgc, ceval);
     416        getFExternalLanguage().genFuncCall(p, str, indent, this, cgc);
    412417       
    413418        // If there are any output arrays, transpose these before returning (Fortran 77 only)
    414         getFExternalLanguage().prepExternalArg(p, str, indent, this, true);
     419        getFExternalLanguage().prepExternalArg(p, str, indent, this, true, getCodeGenContext(), ceval);
    415420    }
    416421
     
    437442    }
    438443
    439     public void FExternalLanguage.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, boolean writeback){
     444    public void FExternalLanguage.extraContext(FExternalStmt stmt, CodeGenContext cgc, boolean ceval) {
    440445        for (FExp arg : stmt.getArgs()) {
    441             if (extShouldArgConvert(arg)) {
    442                 arg.prepExternalArg(p, str, indent, this, writeback);
     446            if (extShouldArgConvert(arg, ceval)) {
     447                cgc.setAlias(arg.externalArgument(), arg.tempName_C());
     448            }
     449        }
     450    }
     451
     452    public void FExternalLanguage.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, boolean writeback, CodeGenContext cgc, boolean ceval){
     453        for (FExp arg : stmt.getArgs()) {
     454            if (extShouldArgConvert(arg, ceval)) {
     455                arg.prepExternalArg(p, str, indent, this, writeback, cgc);
    443456            }
    444457        }
    445458        if (writeback && stmt.hasReturnVar() && stmt.getReturnVar().type().isRecord()) {
    446             stmt.getReturnVar().prepExternalArg(p, str, indent, this, writeback);
    447         }
    448     }
    449 
    450     public void FExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback) {
     459            stmt.getReturnVar().prepExternalArg(p, str, indent, this, writeback, cgc);
     460        }
     461    }
     462
     463    public void FExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback, CodeGenContext cgc) {
    451464        String tempName = tempName_C();
    452         String src = alias_C(p);
    453         useTempVar = true;
     465        String src = alias_C(p, cgc);
    454466        if (isArray()) {
    455467            MatrixOp op = new MatrixOp(type(), lang, writeback);
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r11572 r11573  
    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) {
    715         if (fas == null) {
     710        if (fas == null || fas.ndims() == 0) {
    716711            return p.name(this);
    717712        } else {
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternal.jrag

    r11471 r11573  
    1919     * Generates temporaries for an argument to an external function when necessary.
    2020     */
    21     public void FExternalLanguage.genVarDecls_C(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt) {
     21    public void FExternalLanguage.genVarDecls_C(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, boolean ceval) {
    2222        for (FExp arg: stmt.getArgs()) {
    23             if (extShouldArgConvert(arg)) {
     23            if (extShouldArgConvert(arg, ceval)) {
    2424                arg.type().printDeclBase_C(p, str, indent, arg.tempName_C(), arg, true);
    2525            }
     
    3636     *  Fortran matrix => transpose
    3737     */
    38     syn boolean FExternalLanguage.extShouldArgConvert(FExp arg) = false;
    39     eq FCExternalLanguage.extShouldArgConvert(FExp arg)         = arg.extShouldArgConvert(false);
    40     eq FFortran77ExternalLanguage.extShouldArgConvert(FExp arg) = arg.extShouldArgConvert(true);
     38    syn boolean FExternalLanguage.extShouldArgConvert(FExp arg, boolean ceval) = false;
     39    eq FCExternalLanguage.extShouldArgConvert(FExp arg, boolean ceval)         = arg.extShouldArgConvert(false, ceval);
     40    eq FFortran77ExternalLanguage.extShouldArgConvert(FExp arg, boolean ceval) = arg.extShouldArgConvert(true, ceval);
    4141   
    42     syn boolean FExp.extShouldArgConvert(boolean fortran) = false;
    43     eq FLitExp.extShouldArgConvert(boolean fortran)       = fortran;
    44     eq FIdUseExp.extShouldArgConvert(boolean fortran)     =
     42    syn boolean FExp.extShouldArgConvert(boolean fortran, boolean ceval) { throw new UnsupportedOperationException(); }
     43    eq FLitExp.extShouldArgConvert(boolean fortran, boolean ceval)   = ceval || fortran;
     44    eq FSizeExp.extShouldArgConvert(boolean fortran, boolean ceval)  = ceval;
     45    eq FIdUseExp.extShouldArgConvert(boolean fortran, boolean ceval) =
    4546            type().isInteger() || type().isBoolean() || type().isEnum() || type().isRecord() ||
    4647            (fortran && type().isReal() && ndims() > 1);
     
    4849   
    4950    @Override
    50     public void FIdUseExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback) {
     51    public void FIdUseExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback, CodeGenContext cgc) {
    5152        if (!writeback || myCommonVarDecl().isOutput()) {
    5253            if (isArray() && !writeback) {
    5354                type().print(p.createInitPrinter(str), indent, tempName_C(), this, true);
    5455            }
    55             super.prepExternalArg(p, str, indent, lang, writeback);
     56            super.prepExternalArg(p, str, indent, lang, writeback, cgc);
    5657        }
    5758    }
    5859   
    5960    @Override
    60     public void FLitExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback) {
     61    public void FLitExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback, CodeGenContext cgc) {
    6162        if (!writeback)
    62             super.prepExternalArg(p, str, indent, lang, writeback);
     63            super.prepExternalArg(p, str, indent, lang, writeback, cgc);
    6364    }
    6465   
    65     public void FExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt) {}
     66    @Override
     67    public void FSizeExp.prepExternalArg(CodePrinter p, CodeStream str, String indent, FExternalLanguage lang, boolean writeback, CodeGenContext cgc) {
     68        if (!writeback)
     69            super.prepExternalArg(p, str, indent, lang, writeback, cgc);
     70    }
     71   
     72    public void FExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, CodeGenContext cgc) {}
    6673   
    6774    @Override
    68     public void FCExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt) {
     75    public void FCExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, CodeGenContext cgc) {
    6976        str.print(stmt.getName()+"(");
    7077        String prefix = "";
    7178        for (FExp arg : stmt.getArgs()) {
    7279            str.print(prefix);
    73             arg.genExternalCFuncArgs(p, str, indent);
     80            arg.genExternalCFuncArgs(p, str, indent, cgc);
    7481            prefix = ", ";
    7582        }
     
    7885   
    7986    @Override
    80     public void FFortran77ExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt) {
     87    public void FFortran77ExternalLanguage.genFuncCall(CodePrinter p, CodeStream str, String indent, FExternalStmt stmt, CodeGenContext cgc) {
    8188        str.print(stmt.getName()+"_(");
    8289        String prefix = "";
    8390        for (FExp arg : stmt.getArgs()) {
    8491            str.print(prefix);
    85             arg.genExternalFortranFuncArgs(p, str, indent);
     92            arg.genExternalFortranFuncArgs(p, str, indent, cgc);
    8693            prefix = ", ";
    8794        }
     
    120127    eq FIdUseExp.isExternalArgumentRef(boolean fortran)     = super.isExternalArgumentRef(fortran) || myCommonVarDecl().isOutput();
    121128   
    122     public void FExp.genExternalFortranFuncArgs(CodePrinter p, CodeStream str, String indent) {
     129    public void FExp.genExternalFortranFuncArgs(CodePrinter p, CodeStream str, String indent, CodeGenContext cgc) {
    123130        if (!isArray() && !type().isString()) {
    124131            str.print("&");
    125132        }
    126         if (useTempVar) {
    127             str.print(tempName_C());
    128         } else {
    129             str.print(alias_C(p));
    130         }
     133        str.print(alias_C(p, cgc));
    131134        if (isArray()) {
    132135            str.print("->var");
     
    134137    }
    135138   
    136     public void FExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent) {
    137         p.print(this, str, indent);
    138     }
    139    
    140     @Override
    141     public void FIdUseExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent) {
    142         if (myCommonVarDecl().isOutput() && !isComposite())
    143             str.print("&");
    144         if (useTempVar) {
    145             str.print(tempName_C());
    146         } else {
    147             str.print(alias_C(p));
    148         }
     139    public void FExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent, CodeGenContext cgc) {
     140        str.print(alias_C(p, cgc));
    149141        if (isArray()) {
    150142            str.print("->var");
    151143        }
    152144    }
    153 
     145   
    154146    @Override
    155     public void FSizeExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent) {
    156         str.print(alias_C(p));
     147    public void FIdUseExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent, CodeGenContext cgc) {
     148        if (myCommonVarDecl().isOutput() && !isComposite())
     149            str.print("&");
     150        super.genExternalCFuncArgs(p, str, indent, cgc);
    157151    }
    158152   
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r11572 r11573  
    2121
    2222aspect CCodeGenExternalCeval {
     23
     24    public void FExternalStmt.setExternalArgumentAliases(CodeGenContext cgc) {
     25        setExternalArgumentAliases(cgc, getName(), false);
     26    }
     27
     28    public void FExternalStmt.setExternalArgumentAliases(CodeGenContext cgc, String name, boolean all) {
     29        int i = 0;
     30        for (ExternalArgument arg : varsToSerialize()) {
     31            if (all || arg instanceof FExp) {
     32                cgc.setAlias(arg, name + "_arg" + i);
     33            }
     34            i++;
     35        }
     36    }
     37
     38    public void FExternalStmt.setExternalArgumentAliases(CodeGenContext cgc, String outName, String name) {
     39        setExternalArgumentAliases(cgc, name, true);
     40        cgc.setAlias(myConstructorOutput(), outName);
     41    }
     42
    2343    public class DeclPrinter_ECE extends DeclPrinter_C {
    2444        private CodeGenContext cgc;
     
    4464        protected void printComps(FExternalObjectType type) {
    4565            FExternalStmt stmt = type.myConstructorStmt();
    46             stmt.setCodeGenContext(cgc.createProxy());
     66            stmt.setExternalArgumentAliases(cgc, name(), acquireTemp(name()));
     67            stmt.setCodeGenContext(cgc);
    4768            stmt.genVarDecls_C(p, str, indent());
    4869            stmt.setCodeGenContext(null);
     
    94115        }
    95116        protected void printExt(FExternalObjectType type) {
    96             int i = 0;
    97117            FExternalStmt stmt = type.myConstructorStmt();
    98             stmt.setCodeGenContext(cgc.createProxy());
    99             ArrayList<FExp> args = stmt.myConstructorArgs();
    100             CommonVariableDecl out = stmt.myConstructorOutput();
    101             String name = acquireTemp(name());
    102             stmt.getCodeGenContext().setAlias(out.name_C(), name());
    103             for (FExp arg : args)
    104                 stmt.getCodeGenContext().setAlias(arg.prettyPrint_C(), name + "_arg" + i++);
     118            stmt.setExternalArgumentAliases(cgc, name(), acquireTemp(name()));
     119            stmt.setCodeGenContext(cgc);
    105120            stmt.prettyPrint_C(p, str, indent());
    106121            stmt.setCodeGenContext(null);
     
    144159        protected void printExt(FExternalObjectType type) {
    145160            FExternalStmt stmt = type.myDestructorStmt();
    146             ArrayList<FExp> args = stmt.myConstructorArgs();
    147             stmt.setCodeGenContext(cgc.createProxy());
    148             stmt.getCodeGenContext().setAlias(args.get(0).prettyPrint_C(), name());
     161            cgc.setAlias(stmt.varsToSerialize().iterator().next(), name());
     162            stmt.setCodeGenContext(cgc);
    149163            stmt.prettyPrint_C(p, str, indent());
    150164            stmt.setCodeGenContext(null);
     
    165179     */
    166180    public void FExternalStmt.genSerialize_C(TypePrinter_C tp, String indent,
    167             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    168         for (CommonVariableDecl cvd : cvds) {
    169             tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
     181            CodeGenContext cgc, Map<String,String> tempMap, Iterable<ExternalArgument> cvds) {
     182        for (ExternalArgument cvd : cvds) {
     183            String name = cgc.alias(cvd);
     184            if (name == null) {
     185                name = cvd.name_C();
     186            }
     187            tp.resetUnknown(name, cvd.type(), indent);
    170188            cvd.type().print(tp);
    171189        }
     
    173191   
    174192    public void FExternalStmt.genSerializeComps_C(TypePrinter_C tp, String indent,
    175             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    176         for (CommonVariableDecl cvd : cvds) {
     193            CodeGenContext cgc, Map<String,String> tempMap, Iterable<ExternalArgument> cvds) {
     194        for (ExternalArgument cvd : cvds) {
    177195            tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
    178196            tp.printComps((FExternalObjectType)cvd.type());
    179         }
    180     }
    181    
    182     public void FExternalStmt.genSerializeNoComps_C(TypePrinter_C tp, String indent,
    183             CodeGenContext cgc, Map<String,String> tempMap, Iterable<CommonVariableDecl> cvds) {
    184         for (CommonVariableDecl cvd : cvds) {
    185             tp.resetUnknown(cvd.name_C(), cvd.type(), indent);
    186             tp.printExt((FExternalObjectType)cvd.type());
    187197        }
    188198    }
     
    198208        prettyPrint_C(p, str, indent);
    199209        genCheckPoint(str, indent, "DONE");
    200         for (CommonVariableDecl cvd : varsToDeserialize())
     210        for (ExternalArgument cvd : varsToDeserialize())
    201211            cvd.type().genSerialize_C(str, indent, cvd.name_C(), false);
    202212        str.println();
     
    232242   
    233243    /**
    234      * List of CommonVariableDecl which has to be sent to the process
     244     * List of ExternalArgument which has to be sent to the process
    235245     * when evaluating an external function.
    236246     */
    237     syn ArrayList<CommonVariableDecl> FExternalStmt.varsToSerialize() {
     247    syn Collection<ExternalArgument> FExternalStmt.varsToSerialize() {
    238248        if (!hasArg() && !hasReturnVar())
    239             return myCommonVarDecls();
     249            return new ArrayList<ExternalArgument>(myCommonVarDecls());
    240250       
    241         ArrayList<CommonVariableDecl> res = new ArrayList<CommonVariableDecl>();
    242         if (hasReturnVar())
    243             res.add(getReturnVar().myCommonVarDecl());
     251        Collection<ExternalArgument> res = new LinkedHashSet<>();
     252        if (hasReturnVar()) {
     253            res.add(getReturnVar().externalArgument());
     254        }
    244255        for (FExp e : getArgs()) {
    245             e.varsToSerialize(res);
     256            res.add(e.externalArgument());
    246257        }
    247258        return res;
    248259    }
    249260   
    250     public void FExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
    251        
    252     }
    253    
    254     public void FIdUseExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
    255         CommonVariableDecl cvd = myCommonVarDecl();
    256         if (!decls.contains(cvd))
    257             decls.add(cvd);
    258     }
    259    
    260     public void FSizeExp.varsToSerialize(ArrayList<CommonVariableDecl> decls) {
    261         getFExp().varsToSerialize(decls);
    262         //getDim().varsToSerialize(decls);
    263     }
    264    
    265     syn ArrayList<CommonVariableDecl> FExternalStmt.externalObjectsToSerialize() {
    266         ArrayList<CommonVariableDecl> externalObjects = new ArrayList<CommonVariableDecl>();
    267 
    268         for (CommonVariableDecl var : varsToSerialize()) {
     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;
     274
     275    syn ArrayList<ExternalArgument> FExternalStmt.externalObjectsToSerialize() {
     276        ArrayList<ExternalArgument> externalObjects = new ArrayList<ExternalArgument>();
     277        for (ExternalArgument var : varsToSerialize()) {
    269278            if (var.type().isExternalObject()) {
    270279                externalObjects.add(var);
    271280            }
    272281        }
    273 
    274282        return externalObjects;
    275283    }
    276    
    277     syn ArrayList<CommonVariableDecl> FExternalStmt.functionArgsToSerialize() {
    278         ArrayList<CommonVariableDecl> functionArgs = new ArrayList<CommonVariableDecl>();
    279 
    280         for (CommonVariableDecl var : varsToSerialize()) {
     284
     285    syn ArrayList<ExternalArgument> FExternalStmt.functionArgsToSerialize() {
     286        ArrayList<ExternalArgument> functionArgs = new ArrayList<ExternalArgument>();
     287        for (ExternalArgument var : varsToSerialize()) {
    281288            if (!var.type().isExternalObject()) {
    282289                functionArgs.add(var);
    283290            }
    284291        }
    285 
    286292        return functionArgs;
    287293    }
     
    291297     * when evaluating an external function.
    292298     */
    293     syn ArrayList<CommonVariableDecl> FExternalStmt.varsToDeserialize() {
    294         ArrayList<CommonVariableDecl> res = new ArrayList<CommonVariableDecl>();
    295         for (CommonVariableDecl cvd : varsToSerialize())
    296             if (cvd.isOutput())
     299    syn ArrayList<ExternalArgument> FExternalStmt.varsToDeserialize() {
     300        ArrayList<ExternalArgument> res = new ArrayList<>();
     301        for (ExternalArgument cvd : varsToSerialize()) {
     302            if (cvd.isOutput()) {
    297303                res.add(cvd);
     304            }
     305        }
    298306        return res;
    299307    }
     
    304312    private ArrayList<CommonVariableDecl> FExternalStmt.myCommonVarDecls() {
    305313        FFunctionDecl decl = containingFFunctionDecl();
    306         if (decl != null)
     314        if (decl != null) {
    307315            return new ArrayList<CommonVariableDecl>(decl.getFFunctionVariables().toArrayList());
    308         else
    309             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        }
    310325    }
    311326
     
    315330    public Map<String,FType> FExternalStmt.usedTypes() {
    316331        Map<String,FType> res = new LinkedHashMap<String,FType>();
    317         for (CommonVariableDecl cvd : varsToSerialize()) {
     332        for (ExternalArgument cvd : varsToSerialize()) {
    318333            cvd.type().usedTypes(res);
    319334        }
     
    342357        res.put(name(), this);
    343358        FExternalStmt stmt = myConstructorStmt();
    344         for (FExp exp : stmt.myConstructorArgs()) {
    345             FType t = exp.type();
     359        for (ExternalArgument arg : stmt.varsToSerialize()) {
     360            FType t = arg.type();
    346361            boolean par = t.getParent() == null;
    347362            if (par) {
     
    420435        res.add(this);
    421436       
    422         for (FExp exp : myConstructorArgs()) {
    423             FType t = exp.type();
     437        for (ExternalArgument arg : varsToSerialize()) {
     438            FType t = arg.type();
    424439            boolean par = t.getParent() == null;
    425440            if (par) {
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenFunctionIO.jrag

    r10802 r11573  
    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();
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r11388 r11573  
    3838                for (AbstractEquationBlock block : fclass.getDAEStructuredBLT().getAllBlocks()) {
    3939                    block.genSetupNodeDecls_C(p, str, indent);
     40                }
     41                for (FGlobalVariable fv : fclass.getFGlobalVariables()) {
     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<FGlobalVariable> globals = new ArrayList<>();
     284                for (FGlobalVariable fv : fclass.getFGlobalVariables()) {
     285                    fv.getBindingExp().genGlobalVariableInit_C(p, str, indent);
     286                    globals.add(fv);
     287                }
     288               
     289                CodeSplitter<FGlobalVariable> splitter = new CodeSplitter<FGlobalVariable>(p, str, next, false,
     290                        "jmi_set_globals_start_", fclass.myOptions(), globals) {
     291                    @Override
     292                    public void genDecl(FGlobalVariable element) {
     293                       
     294                    }
     295                    @Override
     296                    public void gen(FGlobalVariable element) {
     297                        element.genGlobalVariableInit_C(p, str, indent);
     298                    }
     299                };
     300                splitter.genFuncImpls();
     301                splitter.genFuncHeads();
     302                str.print("int jmi_set_globals_start(jmi_t* jmi) {\n");
     303                splitter.printStatusDecl();
     304                splitter.genFuncCalls();
     305                splitter.printStatusReturn();
     306                str.print("}\n");
     307            }
     308        }
     309    }
     310
     311    public void FGlobalVariable.genGlobalVariableDecl_C(CodePrinter p, CodeStream str, String indent) {
     312        str.print(indent, type().type_C(p), " ", nameUnderscore(), ";\n");
     313    }
     314
     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);
     331       
     332        String next = p.indent(indent);
     333        str.print(indent, type().nameScalar_C(p), "* jmi_global_", tempName_C(), "(jmi_t* jmi) {\n");
     334        str.print(next, "JMI_DYNAMIC_INIT()\n");
     335       
     336        String typeName = type().nameScalar_C(p);
     337        str.print(next, typeName, "* ", tempName_C(), ";\n");
     338       
     339        str.print(next, "JMI_GLOBALS_INIT()\n");
     340       
     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);
     344       
     345        str.print(next, "JMI_GLOBALS_FREE()\n");
     346        str.print(next, "JMI_DYNAMIC_FREE()\n");
     347        str.print(next, "return ", tempName_C(), ";\n");
     348        str.print(indent, "}\n\n");
     349    }
     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(",
     361                "DYNA", ", ",
     362                type().nameScalar_C(p, false), ", ",
     363                type().nameArray_C(p, false), ", ",
     364                tempName_C(), ", ");
     365        type().size().printNumElements_C(p, str, next, this);
     366        str.print(", ");
     367        str.print(type().ndims());
     368        str.print(")\n");
     369       
     370        str.print(next, "JMI_GLOBALS_INIT()\n");
     371       
     372        str.print(next, "JMI_ARRAY_INIT_", ndims(), "(",
     373                "DYNA", ", ",
     374                type().nameScalar_C(p, false), ", ",
     375                type().nameArray_C(p, false), ", ",
     376                tempName_C(), ", ");
     377        type().size().printNumElements_C(p, str, next, this);
     378        str.print(", ");
     379        str.print(type().ndims());
     380        str.print(", ");
     381        type().size().printDimensions_C(p, str, next, this);
     382        str.print(")\n");
     383       
     384        String name = tempName_C();
     385        String type = type().isRecord() ? C_ARRAY_RECORD : C_ARRAY_VALUE;
     386        String pre = String.format("jmi_array_%s_%d(%s, ", type, ndims(), name);
     387        for (Index i : indices()) {
     388            String cellName = pre + i.toUnclosedString() + ")";
     389            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()) {
     405            str.print(indent, name, " = ");
     406            p.print(this, str, indent);
     407            str.print(";\n");
     408        }
     409    }
     410
     411    public void FRecordConstructor.genGlobalVariableInitScalar_C(CodePrinter p, CodeStream str, String indent, String name, boolean expand) {
     412        if (expand) {
     413            for (FRecordComponentType comp : getRecord().recordType().getComponents()) {
     414                String compName = name + "->" + comp.getName();
     415                FExp compExp = component(comp.getName());
     416                compExp.genGlobalVariableInitScalar_C(p, str, indent, compName, false);
     417            }
     418        } else {
     419            super.genGlobalVariableInitScalar_C(p, str, indent, name, expand);
     420        }
     421    }
     422}
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenNames.jrag

    r11572 r11573  
    6565            return "tmp_" + nextTempNbr_C++;
    6666        }
    67         public void setAlias(String key, String val) {
     67        public void setAlias(ExternalArgument arg, String val) {
    6868            throw new UnsupportedOperationException();
    6969        }
    70         public String alias(String key) {
    71             return key;
     70        public String alias(ExternalArgument arg) {
     71            return null;
    7272        }
    7373        public CodeGenContext createProxy() {
     
    7979        private class CodeGenContextProxy extends CodeGenContext {
    8080            private CodeGenContext redirect;
    81             private Map<String,String> aliases = new HashMap<String,String>();
     81            private Map<ExternalArgument,String> aliases = new HashMap<>();
    8282            public CodeGenContextProxy(CodeGenContext redirect) {
    8383                this.redirect = redirect;
     
    8686                return redirect.nextTempName_C();
    8787            }
    88             public void setAlias(String key, String val) {
    89                 aliases.put(key,val);
     88            public void setAlias(ExternalArgument arg, String val) {
     89                aliases.put(arg,val);
    9090            }
    91             public String alias(String key) {
    92                 return aliases.get(key);
     91            public String alias(ExternalArgument arg) {
     92                String res = aliases.get(arg);
     93                if (res == null) {
     94                    res = redirect.alias(arg);
     95                }
     96                return res;
    9397            }
    9498            public Map<String,String> recordChildTempNames() {
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenTypes.jrag

    r11471 r11573  
    134134    syn boolean FAbstractVariable.useAlias_C() = true;
    135135
    136     syn String FExp             .alias_C(CodePrinter p) = myCodeGenContext().alias(prettyPrint_C());
     136    syn String FExp.alias_C(CodePrinter p) {
     137        return alias_C(p, myCodeGenContext());
     138    }
     139
     140    syn String FExp.alias_C(CodePrinter p, CodeGenContext cgc) {
     141        String res = cgc.alias(this);
     142        if (res == null) {
     143            res = prettyPrint_C();
     144        }
     145        return res;
     146    }
     147    eq FIdUseExp.alias_C(CodePrinter p, CodeGenContext cgc) {
     148        String res = cgc.alias(myCommonVarDecl());
     149        if (res == null) {
     150            res = super.alias_C(p, cgc);
     151        }
     152        return res;
     153    }
    137154    syn String FFunctionCallLeft.alias_C(CodePrinter p) = getFExp().alias_C(p);
    138155    syn String FAbstractVariable.alias_C(CodePrinter p) = p.getExecStep().name(this);
     
    157174        protected boolean external = false;
    158175        protected boolean subDecls = false; // Used in CAD
     176        boolean forceDynamic = false;
    159177       
    160178        private Stack<Level> levels   = new Stack<Level>();
     
    168186            this(p, str);
    169187            reset(name, src, s, external, indent);
     188        }
     189       
     190        public TypePrinter_C forceDynamic() {
     191            forceDynamic = true;
     192            return this;
    170193        }
    171194       
     
    217240       
    218241        protected String dynStr(FType type) {
    219             return (dynamic() ? "DYNA" : "STAT");
     242            return (forceDynamic || dynamic() ? "DYNA" : "STAT");
    220243        }
    221244       
     
    310333            int i = 0;
    311334            String name = acquireTemp(name());
    312             for (FExp arg : type.myConstructorStmt().myConstructorArgs()) {
    313                 pushLevelExt(name + "_arg" + i, false, arg.size());
     335            for (ExternalArgument arg : type.myConstructorStmt().varsToSerialize()) {
     336                if (arg.isOutput()) {
     337                    i++;
     338                    continue;
     339                }
    314340                FType t = arg.type();
     341                pushLevelExt(name + "_arg" + i, false, t.size());
    315342                boolean b = t.parent == null;
    316343                if (b) {
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CGenerator.jrag

    r11572 r11573  
    14021402            indent = p.indent(indent);
    14031403            TypePrinter_C tp = new DeclPrinter_ECE(p, str, tempMap, cgc);
    1404             for (CommonVariableDecl cvd : ext.externalObjectsToSerialize()) {
    1405                  tp.reset(cvd.name_C(), null, cvd.size(), false, indent);
     1404            for (ExternalArgument cvd : ext.externalObjectsToSerialize()) {
     1405                 tp.reset(cvd.name_C(), null, cvd.type().size(), false, indent);
    14061406                 tp.print(cvd.type());
    14071407            }
     
    14191419            indent = p.indent(indent);
    14201420            TypePrinter_C tp = new FreePrinter_ECE(p, str, tempMap, cgc);
    1421             for (CommonVariableDecl cvd : ext.externalObjectsToSerialize()) {
    1422                  tp.reset(cvd.name_C(), null, cvd.size(), false, indent);
     1421            for (ExternalArgument cvd : ext.externalObjectsToSerialize()) {
     1422                 tp.reset(cvd.name_C(), null, cvd.type().size(), false, indent);
    14231423                 tp.printExt((FExternalObjectType)cvd.type());
    14241424            }
     
    14771477                CodeGenContext cgc, Map<String,String> tempMap) {
    14781478            indent = p.indent(indent);
     1479            ext.setExternalArgumentAliases(cgc);
    14791480            TypePrinter_C tp = new DeclPrinter_ECE(p, str, tempMap, cgc);
    14801481            ext.genSerialize_C(tp, indent, cgc, tempMap, ext.functionArgsToSerialize());
     
    14921493                CodeGenContext cgc, Map<String,String> tempMap) {
    14931494            indent = p.indent(indent);
     1495            ext.setExternalArgumentAliases(cgc);
    14941496            TypePrinter_C tp = new InitPrinter_ECE(p, str, tempMap, cgc);
    14951497            ext.genSerialize_C(tp, indent, cgc, tempMap, ext.functionArgsToSerialize());
     
    15051507        public void generate(CodePrinter p, CodeStream str, String indent, FExternalStmt ext,
    15061508                CodeGenContext cgc, Map<String,String> tempMap) {
    1507             indent = p.indent(indent);
    1508             indent = p.indent(indent);
     1509            indent = p.indent(p.indent(indent));
     1510            ext.setExternalArgumentAliases(cgc);
    15091511            ext.genSerializeCalc_C(p, str, indent, cgc, tempMap);
    15101512        }
     
    15211523            indent = p.indent(indent);
    15221524            TypePrinter_C tp = new FreePrinter_ECE(p, str, tempMap, cgc);
     1525            ext.setExternalArgumentAliases(cgc);
    15231526            ext.genSerialize_C(tp, indent, cgc, tempMap, ext.functionArgsToSerialize());
    15241527        }
  • branches/2.4.x/Compiler/ModelicaCBackEnd/src/jastadd/CodeGen/CodeSplitter.jrag

    r10802 r11573  
    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
  • branches/2.4.x/Compiler/ModelicaCBackEnd/templates/FMIBase/base.h

    r10879 r11573  
    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
  • branches/2.4.x/Compiler/ModelicaCBackEnd/templates/FMIBase/start.c

    r10573 r11573  
    1616$C_enum_strings$
    1717
     18$C_set_globals_start$
     19
    1820$C_set_start_values$
    1921
  • branches/2.4.x/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenArrayTests.mo

    r10859 r11573  
    1717
    1818package CCodeGenArrayTests
     19
     20model VectorLength1
     21    function f
     22        input Real x[:];
     23        output Real y;
     24      algorithm
     25        y := sqrt(x*x);
     26        annotation(Inline=false);
     27    end f;
     28
     29    Real y = f({time});
     30annotation(__JModelica(UnitTesting(tests={
     31    CCodeGenTestCase(
     32        name="VectorLength1",
     33        description="",
     34        template="
     35$C_functions$
     36",
     37        generatedCode="
     38void func_CCodeGenArrayTests_VectorLength1_f_def0(jmi_array_t* x_a, jmi_real_t* y_o) {
     39    JMI_DYNAMIC_INIT()
     40    JMI_DEF(REA, y_v)
     41    JMI_DEF(REA, temp_1_v)
     42    JMI_DEF(REA, temp_2_v)
     43    jmi_real_t i1_0i;
     44    jmi_real_t i1_0ie;
     45    temp_2_v = 0.0;
     46    i1_0ie = jmi_array_size(x_a, 0) + 1 / 2.0;
     47    for (i1_0i = 1; i1_0i < i1_0ie; i1_0i += 1) {
     48        temp_2_v = temp_2_v + jmi_array_val_1(x_a, i1_0i) * jmi_array_val_1(x_a, i1_0i);
     49    }
     50    temp_1_v = temp_2_v;
     51    y_v = sqrt(temp_1_v);
     52    JMI_RET(GEN, y_o, y_v)
     53    JMI_DYNAMIC_FREE()
     54    return;
     55}
     56
     57jmi_real_t func_CCodeGenArrayTests_VectorLength1_f_exp0(jmi_array_t* x_a) {
     58    JMI_DEF(REA, y_v)
     59    func_CCodeGenArrayTests_VectorLength1_f_def0(x_a, &y_v);
     60    return y_v;
     61}
     62")})));
     63end VectorLength1;
    1964
    2065model UnknownSizeInEquation1
  • branches/2.4.x/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalCevalTests.mo

    r11471 r11573  
    192192---
    193193        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a1_a, -1, 1)
     194        JMI_DEF(INT, f_arg1)
    194195        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a2_a, -1, 1)
     196        JMI_DEF(INT, f_arg3)
    195197        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a3_a, -1, 1)
     198        JMI_DEF(INT, f_arg5)
    196199        JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, a4_a, -1, 1)
     200        JMI_DEF(INT, f_arg7)
    197201        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a5_a, -1, 1)
     202        JMI_DEF(INT, f_arg9)
    198203        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b1_a, -1, 1)
     204        JMI_DEF(INT, f_arg11)
    199205        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b2_a, -1, 1)
     206        JMI_DEF(INT, f_arg13)
    200207        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b3_a, -1, 1)
     208        JMI_DEF(INT, f_arg15)
    201209        JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, b4_a, -1, 1)
     210        JMI_DEF(INT, f_arg17)
    202211        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b5_a, -1, 1)
     212        JMI_DEF(INT, f_arg19)
     213        JMI_DEF(INT_EXT, tmp_1)
     214        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_2, -1, 1)
     215        JMI_DEF(INT_EXT, tmp_3)
     216        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_4, -1, 1)
     217        JMI_DEF(INT_EXT, tmp_5)
     218        JMI_DEF(INT_EXT, tmp_6)
    203219        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_7, -1, 1)
    204         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_8, -1, 1)
    205         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_9, -1, 1)
     220        JMI_DEF(INT_EXT, tmp_8)
     221        JMI_DEF(INT_EXT, tmp_9)
    206222        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_10, -1, 1)
    207         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_11, -1, 1)
     223        JMI_DEF(INT_EXT, tmp_11)
    208224        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_12, -1, 1)
     225        JMI_DEF(INT_EXT, tmp_13)
     226        JMI_DEF(INT_EXT, tmp_14)
     227        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_15, -1, 1)
     228        JMI_DEF(INT_EXT, tmp_16)
    209229        extern void f(double*, size_t, int*, size_t, int*, size_t, const char**, size_t, int*, size_t, double*, size_t, int*, size_t, int*, size_t, const char**, size_t, int*, size_t);
    210230
     
    213233        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a1_a, d[0], 1, d[0])
    214234        JMCEVAL_parseArray(Real, a1_a);
     235        JMCEVAL_parse(Integer, f_arg1);
    215236        JMCEVAL_parseArrayDims(1);
    216237        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a2_a, d[0], 1, d[0])
    217238        JMCEVAL_parseArray(Integer, a2_a);
     239        JMCEVAL_parse(Integer, f_arg3);
    218240        JMCEVAL_parseArrayDims(1);
    219241        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a3_a, d[0], 1, d[0])
    220242        JMCEVAL_parseArray(Boolean, a3_a);
     243        JMCEVAL_parse(Integer, f_arg5);
    221244        JMCEVAL_parseArrayDims(1);
    222245        JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, a4_a, d[0], 1, d[0])
    223246        JMCEVAL_parseArray(String, a4_a);
     247        JMCEVAL_parse(Integer, f_arg7);
    224248        JMCEVAL_parseArrayDims(1);
    225249        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a5_a, d[0], 1, d[0])
    226250        JMCEVAL_parseArray(Enum, a5_a);
     251        JMCEVAL_parse(Integer, f_arg9);
    227252        JMCEVAL_parseArrayDims(1);
    228253        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b1_a, d[0], 1, d[0])
    229254        JMCEVAL_parseArray(Real, b1_a);
     255        JMCEVAL_parse(Integer, f_arg11);
    230256        JMCEVAL_parseArrayDims(1);
    231257        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b2_a, d[0], 1, d[0])
    232258        JMCEVAL_parseArray(Integer, b2_a);
     259        JMCEVAL_parse(Integer, f_arg13);
    233260        JMCEVAL_parseArrayDims(1);
    234261        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b3_a, d[0], 1, d[0])
    235262        JMCEVAL_parseArray(Boolean, b3_a);
     263        JMCEVAL_parse(Integer, f_arg15);
    236264        JMCEVAL_parseArrayDims(1);
    237265        JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, b4_a, d[0], 1, d[0])
    238266        JMCEVAL_parseArray(String, b4_a);
     267        JMCEVAL_parse(Integer, f_arg17);
    239268        JMCEVAL_parseArrayDims(1);
    240269        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b5_a, d[0], 1, d[0])
    241270        JMCEVAL_parseArray(Enum, b5_a);
    242 
    243 ---
    244             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_7, jmi_array_size(a2_a, 0), 1, jmi_array_size(a2_a, 0))
    245             jmi_copy_matrix_to_int(a2_a, a2_a->var, tmp_7->var);
    246             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_8, jmi_array_size(a3_a, 0), 1, jmi_array_size(a3_a, 0))
    247             jmi_copy_matrix_to_int(a3_a, a3_a->var, tmp_8->var);
    248             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_9, jmi_array_size(a5_a, 0), 1, jmi_array_size(a5_a, 0))
    249             jmi_copy_matrix_to_int(a5_a, a5_a->var, tmp_9->var);
     271        JMCEVAL_parse(Integer, f_arg19);
     272
     273---
     274            tmp_1 = (int)f_arg1;
     275            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_2, jmi_array_size(a2_a, 0), 1, jmi_array_size(a2_a, 0))
     276            jmi_copy_matrix_to_int(a2_a, a2_a->var, tmp_2->var);
     277            tmp_3 = (int)f_arg3;
     278            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_4, jmi_array_size(a3_a, 0), 1, jmi_array_size(a3_a, 0))
     279            jmi_copy_matrix_to_int(a3_a, a3_a->var, tmp_4->var);
     280            tmp_5 = (int)f_arg5;
     281            tmp_6 = (int)f_arg7;
     282            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_7, jmi_array_size(a5_a, 0), 1, jmi_array_size(a5_a, 0))
     283            jmi_copy_matrix_to_int(a5_a, a5_a->var, tmp_7->var);
     284            tmp_8 = (int)f_arg9;
     285            tmp_9 = (int)f_arg11;
    250286            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_10, jmi_array_size(b2_a, 0), 1, jmi_array_size(b2_a, 0))
    251287            jmi_copy_matrix_to_int(b2_a, b2_a->var, tmp_10->var);
    252             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_11, jmi_array_size(b3_a, 0), 1, jmi_array_size(b3_a, 0))
    253             jmi_copy_matrix_to_int(b3_a, b3_a->var, tmp_11->var);
    254             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_12, jmi_array_size(b5_a, 0), 1, jmi_array_size(b5_a, 0))
    255             jmi_copy_matrix_to_int(b5_a, b5_a->var, tmp_12->var);
    256             f(a1_a->var, jmi_array_size(a1_a, 0), tmp_7->var, jmi_array_size(a2_a, 0), tmp_8->var, jmi_array_size(a3_a, 0), a4_a->var, jmi_array_size(a4_a, 0), tmp_9->var, jmi_array_size(a5_a, 0), b1_a->var, jmi_array_size(b1_a, 0), tmp_10->var, jmi_array_size(b2_a, 0), tmp_11->var, jmi_array_size(b3_a, 0), b4_a->var, jmi_array_size(b4_a, 0), tmp_12->var, jmi_array_size(b5_a, 0));
     288            tmp_11 = (int)f_arg13;
     289            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_12, jmi_array_size(b3_a, 0), 1, jmi_array_size(b3_a, 0))
     290            jmi_copy_matrix_to_int(b3_a, b3_a->var, tmp_12->var);
     291            tmp_13 = (int)f_arg15;
     292            tmp_14 = (int)f_arg17;
     293            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_15, jmi_array_size(b5_a, 0), 1, jmi_array_size(b5_a, 0))
     294            jmi_copy_matrix_to_int(b5_a, b5_a->var, tmp_15->var);
     295            tmp_16 = (int)f_arg19;
     296            f(a1_a->var, tmp_1, tmp_2->var, tmp_3, tmp_4->var, tmp_5, a4_a->var, tmp_6, tmp_7->var, tmp_8, b1_a->var, tmp_9, tmp_10->var, tmp_11, tmp_12->var, tmp_13, b4_a->var, tmp_14, tmp_15->var, tmp_16);
    257297            jmi_copy_matrix_from_int(b2_a, tmp_10->var, b2_a->var);
    258             jmi_copy_matrix_from_int(b3_a, tmp_11->var, b3_a->var);
    259             jmi_copy_matrix_from_int(b5_a, tmp_12->var, b5_a->var);
     298            jmi_copy_matrix_from_int(b3_a, tmp_12->var, b3_a->var);
     299            jmi_copy_matrix_from_int(b5_a, tmp_15->var, b5_a->var);
    260300            JMCEVAL_check(\"DONE\");
    261301            JMCEVAL_printArray(Real, b1_a);
     
    301341            input String[:] s;
    302342            output Obj2 o2;
    303             external "C" my_constructor2(x,y,o2,b,s)
     343            external "C" my_constructor2(x,y,o2,b,s,size(x,1),3.14)
    304344                annotation(Library="extObjects", Include="#include \"extObjects.h\"");
    305345        end constructor;
     
    374414
    375415---
    376         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_13, -1, 1)
    377         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_14, -1, 1)
    378         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg0, -1, 1)
    379         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg1, -1, 1)
    380         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg2, -1, 1)
    381         JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, tmp_15_arg3, -1, 1)
    382 
    383 ---
    384         JMCEVAL_parseArrayDims(1);
    385         JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg0, d[0], 1, d[0])
    386         JMCEVAL_parseArray(Real, tmp_15_arg0);
    387         JMCEVAL_parseArrayDims(1);
    388         JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg1, d[0], 1, d[0])
    389         JMCEVAL_parseArray(Integer, tmp_15_arg1);
    390         JMCEVAL_parseArrayDims(1);
    391         JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_15_arg2, d[0], 1, d[0])
    392         JMCEVAL_parseArray(Boolean, tmp_15_arg2);
    393         JMCEVAL_parseArrayDims(1);
    394         JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, tmp_15_arg3, d[0], 1, d[0])
    395         JMCEVAL_parseArray(String, tmp_15_arg3);
    396         JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_13, jmi_array_size(tmp_15_arg1, 0), 1, jmi_array_size(tmp_15_arg1, 0))
    397         jmi_copy_matrix_to_int(tmp_15_arg1, tmp_15_arg1->var, tmp_13->var);
    398         JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_14, jmi_array_size(tmp_15_arg2, 0), 1, jmi_array_size(tmp_15_arg2, 0))
    399         jmi_copy_matrix_to_int(tmp_15_arg2, tmp_15_arg2->var, tmp_14->var);
    400         my_constructor2(tmp_15_arg0->var, tmp_13->var, &o2_v, tmp_14->var, tmp_15_arg3->var);
     416        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_2, -1, 1)
     417        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_3, -1, 1)
     418        JMI_DEF(INT_EXT, tmp_4)
     419        JMI_DEF(REA_EXT, tmp_5)
     420        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg0, -1, 1)
     421        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg1, -1, 1)
     422        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg3, -1, 1)
     423        JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, tmp_6_arg4, -1, 1)
     424        JMI_DEF(INT, tmp_6_arg5)
     425        JMI_DEF(REA, tmp_6_arg6)
     426
     427---
     428        JMCEVAL_parseArrayDims(1);
     429        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg0, d[0], 1, d[0])
     430        JMCEVAL_parseArray(Real, tmp_6_arg0);
     431        JMCEVAL_parseArrayDims(1);
     432        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg1, d[0], 1, d[0])
     433        JMCEVAL_parseArray(Integer, tmp_6_arg1);
     434        JMCEVAL_parseArrayDims(1);
     435        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_6_arg3, d[0], 1, d[0])
     436        JMCEVAL_parseArray(Boolean, tmp_6_arg3);
     437        JMCEVAL_parseArrayDims(1);
     438        JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, tmp_6_arg4, d[0], 1, d[0])
     439        JMCEVAL_parseArray(String, tmp_6_arg4);
     440        JMCEVAL_parse(Integer, tmp_6_arg5);
     441        JMCEVAL_parse(Real, tmp_6_arg6);
     442        JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_2, jmi_array_size(tmp_6_arg1, 0), 1, jmi_array_size(tmp_6_arg1, 0))
     443        jmi_copy_matrix_to_int(tmp_6_arg1, tmp_6_arg1->var, tmp_2->var);
     444        JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_3, jmi_array_size(tmp_6_arg3, 0), 1, jmi_array_size(tmp_6_arg3, 0))
     445        jmi_copy_matrix_to_int(tmp_6_arg3, tmp_6_arg3->var, tmp_3->var);
     446        tmp_4 = (int)tmp_6_arg5;
     447        tmp_5 = (double)tmp_6_arg6;
     448        my_constructor2(tmp_6_arg0->var, tmp_2->var, &o2_v, tmp_3->var, tmp_6_arg4->var, tmp_4, tmp_5);
    401449
    402450---
     
    459507
    460508---
    461         JMI_DEF(EXO, tmp_16_arg0)
    462         JMI_DEF(INT_EXT, tmp_17)
    463         JMI_DEF(BOO_EXT, tmp_18)
    464         JMI_DEF(REA, tmp_19_arg0)
    465         JMI_DEF(INT, tmp_19_arg1)
    466         JMI_DEF(BOO, tmp_19_arg2)
    467         JMI_DEF(STR, tmp_19_arg3)
    468         JMI_ARR(DYNA, jmi_extobj_t, jmi_extobj_array_t, tmp_16_arg1, -1, 1)
    469         JMI_DEF(REA, tmp_20)
    470         JMI_DEF(REA, tmp_20_max)
    471         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_21, -1, 1)
    472         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_22, -1, 1)
    473         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg0, -1, 1)
    474         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg1, -1, 1)
    475         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg2, -1, 1)
    476         JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, tmp_23_arg3, -1, 1)
    477 
    478 ---
    479         JMCEVAL_parse(Real, tmp_19_arg0);
    480         JMCEVAL_parse(Integer, tmp_19_arg1);
    481         JMCEVAL_parse(Boolean, tmp_19_arg2);
    482         JMCEVAL_parse(String, tmp_19_arg3);
    483         tmp_17 = (int)tmp_19_arg1;
    484         tmp_18 = (int)tmp_19_arg2;
    485         tmp_16_arg0 = my_constructor1(tmp_19_arg0, tmp_17, tmp_18, tmp_19_arg3);
    486         JMCEVAL_parseArrayDims(1);
    487         JMI_ARRAY_INIT_1(DYNA, jmi_extobj_t, jmi_extobj_array_t, tmp_16_arg1, d[0], 1, d[0])
    488         tmp_20_max = d[0] + 1;
    489         for (tmp_20 = 1; tmp_20 < tmp_20_max; tmp_20++) {
     509        JMI_DEF(EXO, tmp_2_arg0)
     510        JMI_DEF(INT_EXT, tmp_4)
     511        JMI_DEF(BOO_EXT, tmp_5)
     512        JMI_DEF(REA, tmp_6_arg1)
     513        JMI_DEF(INT, tmp_6_arg2)
     514        JMI_DEF(BOO, tmp_6_arg3)
     515        JMI_DEF(STR, tmp_6_arg4)
     516        JMI_ARR(DYNA, jmi_extobj_t, jmi_extobj_array_t, tmp_2_arg1, -1, 1)
     517        JMI_DEF(REA, tmp_7)
     518        JMI_DEF(REA, tmp_7_max)
     519        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_9, -1, 1)
     520        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_10, -1, 1)
     521        JMI_DEF(INT_EXT, tmp_11)
     522        JMI_DEF(REA_EXT, tmp_12)
     523        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg0, -1, 1)
     524        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg1, -1, 1)
     525        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg3, -1, 1)
     526        JMI_ARR(DYNA, jmi_string_t, jmi_string_array_t, tmp_13_arg4, -1, 1)
     527        JMI_DEF(INT, tmp_13_arg5)
     528        JMI_DEF(REA, tmp_13_arg6)
     529
     530---
     531        JMCEVAL_parse(Real, tmp_6_arg1);
     532        JMCEVAL_parse(Integer, tmp_6_arg2);
     533        JMCEVAL_parse(Boolean, tmp_6_arg3);
     534        JMCEVAL_parse(String, tmp_6_arg4);
     535        tmp_4 = (int)tmp_6_arg2;
     536        tmp_5 = (int)tmp_6_arg3;
     537        tmp_2_arg0 = my_constructor1(tmp_6_arg1, tmp_4, tmp_5, tmp_6_arg4);
     538        JMCEVAL_parseArrayDims(1);
     539        JMI_ARRAY_INIT_1(DYNA, jmi_extobj_t, jmi_extobj_array_t, tmp_2_arg1, d[0], 1, d[0])
     540        tmp_7_max = d[0] + 1;
     541        for (tmp_7 = 1; tmp_7 < tmp_7_max; tmp_7++) {
    490542            JMCEVAL_parseArrayDims(1);
    491             JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg0, d[0], 1, d[0])
    492             JMCEVAL_parseArray(Real, tmp_23_arg0);
     543            JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg0, d[0], 1, d[0])
     544            JMCEVAL_parseArray(Real, tmp_13_arg0);
    493545            JMCEVAL_parseArrayDims(1);
    494             JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg1, d[0], 1, d[0])
    495             JMCEVAL_parseArray(Integer, tmp_23_arg1);
     546            JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg1, d[0], 1, d[0])
     547            JMCEVAL_parseArray(Integer, tmp_13_arg1);
    496548            JMCEVAL_parseArrayDims(1);
    497             JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_23_arg2, d[0], 1, d[0])
    498             JMCEVAL_parseArray(Boolean, tmp_23_arg2);
     549            JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_13_arg3, d[0], 1, d[0])
     550            JMCEVAL_parseArray(Boolean, tmp_13_arg3);
    499551            JMCEVAL_parseArrayDims(1);
    500             JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, tmp_23_arg3, d[0], 1, d[0])
    501             JMCEVAL_parseArray(String, tmp_23_arg3);
    502             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_21, jmi_array_size(tmp_23_arg1, 0), 1, jmi_array_size(tmp_23_arg1, 0))
    503             jmi_copy_matrix_to_int(tmp_23_arg1, tmp_23_arg1->var, tmp_21->var);
    504             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_22, jmi_array_size(tmp_23_arg2, 0), 1, jmi_array_size(tmp_23_arg2, 0))
    505             jmi_copy_matrix_to_int(tmp_23_arg2, tmp_23_arg2->var, tmp_22->var);
    506             my_constructor2(tmp_23_arg0->var, tmp_21->var, &jmi_array_ref_1(tmp_16_arg1, tmp_20), tmp_22->var, tmp_23_arg3->var);
     552            JMI_ARRAY_INIT_1(DYNA, jmi_string_t, jmi_string_array_t, tmp_13_arg4, d[0], 1, d[0])
     553            JMCEVAL_parseArray(String, tmp_13_arg4);
     554            JMCEVAL_parse(Integer, tmp_13_arg5);
     555            JMCEVAL_parse(Real, tmp_13_arg6);
     556            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_9, jmi_array_size(tmp_13_arg1, 0), 1, jmi_array_size(tmp_13_arg1, 0))
     557            jmi_copy_matrix_to_int(tmp_13_arg1, tmp_13_arg1->var, tmp_9->var);
     558            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_10, jmi_array_size(tmp_13_arg3, 0), 1, jmi_array_size(tmp_13_arg3, 0))
     559            jmi_copy_matrix_to_int(tmp_13_arg3, tmp_13_arg3->var, tmp_10->var);
     560            tmp_11 = (int)tmp_13_arg5;
     561            tmp_12 = (double)tmp_13_arg6;
     562            my_constructor2(tmp_13_arg0->var, tmp_9->var, &jmi_array_ref_1(tmp_2_arg1, tmp_7), tmp_10->var, tmp_13_arg4->var, tmp_11, tmp_12);
    507563        }
    508         my_constructor3(tmp_16_arg0, tmp_16_arg1->var, &o3_v);
    509 
    510 ---
    511         destructor(tmp_16_arg0);
    512         for (tmp_20 = 1; tmp_20 < tmp_20_max; tmp_20++) {
    513             destructor(jmi_array_ref_1(tmp_16_arg1, tmp_20));
     564        my_constructor3(tmp_2_arg0, tmp_2_arg1->var, &o3_v);
     565
     566---
     567        destructor(tmp_2_arg0);
     568        for (tmp_7 = 1; tmp_7 < tmp_7_max; tmp_7++) {
     569            destructor(jmi_array_ref_1(tmp_2_arg1, tmp_7));
    514570        }
    515571
     
    673729
    674730my_constructor2
     731#include \"extObjects2b.h\"
    675732#include \"extObjects2.h\"
     733Include2b
    676734Include
     735extObjects2b
    677736extObjects2
     737Library2b
    678738Library
    679739
    680740destructor
    681741#include \"extObjects.h\"
     742#include \"extObjects2b.h\"
    682743#include \"extObjects2.h\"
    683 #include \"extObjects2b.h\"
    684744#include \"extObjects3.h\"
    685745#include \"extObjects3b.h\"
     
    687747Include2b
    688748extObjects
     749extObjects2b
    689750extObjects2
    690 extObjects2b
    691751extObjects3
    692752extObjects3b
     
    696756my_constructor3
    697757#include \"extObjects.h\"
     758#include \"extObjects2b.h\"
    698759#include \"extObjects2.h\"
    699 #include \"extObjects2b.h\"
     760#include \"extObjects3b.h\"
    700761#include \"extObjects3.h\"
    701762Include
    702763Include2b
    703764extObjects
     765extObjects2b
    704766extObjects2
    705 extObjects2b
     767extObjects3b
    706768extObjects3
    707769Library
     
    710772use3
    711773#include \"extObjects.h\"
     774#include \"extObjects2b.h\"
    712775#include \"extObjects2.h\"
    713 #include \"extObjects2b.h\"
     776#include \"extObjects3b.h\"
    714777#include \"extObjects3.h\"
    715 #include \"extObjects3b.h\"
    716778#include \"extObjects4.h\"
    717779Include
    718780Include2b
    719781extObjects
     782extObjects2b
    720783extObjects2
    721 extObjects2b
     784extObjects3b
    722785extObjects3
    723 extObjects3b
    724786extObjects4
    725787Library
     
    752814      Integer jpvt[size(A, 2)]=zeros(ncol);
    753815    external"FORTRAN 77" dgelsx(
    754               nrow,
     816              size(A, 1),
    755817              ncol,
    756818              nrhs,
     
    801863",
    802864            generatedCode="
    803 
    804 
    805 
    806 ---
    807 
    808 ---
    809 
    810 ---
    811 
    812 ---
    813         JMI_DEF(INT, nrow_v)
     865---
     866
     867---
     868
     869---
     870
     871---
     872        JMI_DEF(INT, dgelsx_arg0)
    814873        JMI_DEF(INT, ncol_v)
    815874        JMI_DEF(INT, nrhs_v)
    816875        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, Awork_a, -1, 2)
     876        JMI_DEF(INT, nrow_v)
    817877        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, X_a, -1, 2)
    818878        JMI_DEF(INT, nx_v)
     
    823883        JMI_DEF(INT, lwork_v)
    824884        JMI_DEF(INT, info_v)
    825         JMI_DEF(INT_EXT, tmp_24)
    826         JMI_DEF(INT_EXT, tmp_25)
    827         JMI_DEF(INT_EXT, tmp_26)
    828         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_27, -1, 2)
    829         JMI_DEF(INT_EXT, tmp_28)
    830         JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_29, -1, 2)
    831         JMI_DEF(INT_EXT, tmp_30)
    832         JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_31, -1, 1)
    833         JMI_DEF(INT_EXT, tmp_32)
    834         JMI_DEF(INT_EXT, tmp_33)
    835         JMI_DEF(INT_EXT, tmp_34)
     885        JMI_DEF(INT_EXT, tmp_1)
     886        JMI_DEF(INT_EXT, tmp_2)
     887        JMI_DEF(INT_EXT, tmp_3)
     888        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_4, -1, 2)
     889        JMI_DEF(INT_EXT, tmp_5)
     890        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_6, -1, 2)
     891        JMI_DEF(INT_EXT, tmp_7)
     892        JMI_ARR(DYNA, jmi_int_t, jmi_int_array_t, tmp_8, -1, 1)
     893        JMI_DEF(INT_EXT, tmp_9)
     894        JMI_DEF(INT_EXT, tmp_10)
     895        JMI_DEF(INT_EXT, tmp_11)
    836896        extern void dgelsx_(int*, int*, int*, double*, int*, double*, int*, int*, double*, int*, double*, int*, int*);
    837897
    838898---
    839         JMCEVAL_parse(Integer, nrow_v);
     899        JMCEVAL_parse(Integer, dgelsx_arg0);
    840900        JMCEVAL_parse(Integer, ncol_v);
    841901        JMCEVAL_parse(Integer, nrhs_v);
     
    843903        JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, Awork_a, d[0]*d[1], 2, d[0], d[1])
    844904        JMCEVAL_parseArray(Real, Awork_a);
     905        JMCEVAL_parse(Integer, nrow_v);
    845906        JMCEVAL_parseArrayDims(2);
    846907        JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, X_a, d[0]*d[1], 2, d[0], d[1])
     
    859920
    860921---
    861             tmp_24 = (int)nrow_v;
    862             tmp_25 = (int)ncol_v;
    863             tmp_26 = (int)nrhs_v;
    864             JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, tmp_27, jmi_array_size(Awork_a, 0) * jmi_array_size(Awork_a, 1), 2, jmi_array_size(Awork_a, 0), jmi_array_size(Awork_a, 1))
    865             jmi_matrix_to_fortran_real(Awork_a, Awork_a->var, tmp_27->var);
    866             tmp_28 = (int)nrow_v;
    867             JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, tmp_29, jmi_array_size(X_a, 0) * jmi_array_size(X_a, 1), 2, jmi_array_size(X_a, 0), jmi_array_size(X_a, 1))
    868             jmi_matrix_to_fortran_real(X_a, X_a->var, tmp_29->var);
    869             tmp_30 = (int)nx_v;
    870             JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_31, jmi_array_size(jpvt_a, 0), 1, jmi_array_size(jpvt_a, 0))
    871             jmi_matrix_to_fortran_int(jpvt_a, jpvt_a->var, tmp_31->var);
    872             tmp_32 = (int)rank_v;
    873             tmp_33 = (int)lwork_v;
    874             tmp_34 = (int)info_v;
    875             dgelsx_(&tmp_24, &tmp_25, &tmp_26, tmp_27->var, &tmp_28, tmp_29->var, &tmp_30, tmp_31->var, &rcond_v, &tmp_32, work_a->var, &tmp_33, &tmp_34);
    876             jmi_matrix_from_fortran_real(X_a, tmp_29->var, X_a->var);
    877             rank_v = tmp_32;
    878             info_v = tmp_34;
     922            tmp_1 = (int)dgelsx_arg0;
     923            tmp_2 = (int)ncol_v;
     924            tmp_3 = (int)nrhs_v;
     925            JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, tmp_4, jmi_array_size(Awork_a, 0) * jmi_array_size(Awork_a, 1), 2, jmi_array_size(Awork_a, 0), jmi_array_size(Awork_a, 1))
     926            jmi_matrix_to_fortran_real(Awork_a, Awork_a->var, tmp_4->var);
     927            tmp_5 = (int)nrow_v;
     928            JMI_ARRAY_INIT_2(DYNA, jmi_real_t, jmi_array_t, tmp_6, jmi_array_size(X_a, 0) * jmi_array_size(X_a, 1), 2, jmi_array_size(X_a, 0), jmi_array_size(X_a, 1))
     929            jmi_matrix_to_fortran_real(X_a, X_a->var, tmp_6->var);
     930            tmp_7 = (int)nx_v;
     931            JMI_ARRAY_INIT_1(DYNA, jmi_int_t, jmi_int_array_t, tmp_8, jmi_array_size(jpvt_a, 0), 1, jmi_array_size(jpvt_a, 0))
     932            jmi_matrix_to_fortran_int(jpvt_a, jpvt_a->var, tmp_8->var);
     933            tmp_9 = (int)rank_v;
     934            tmp_10 = (int)lwork_v;
     935            tmp_11 = (int)info_v;
     936            dgelsx_(&tmp_1, &tmp_2, &tmp_3, tmp_4->var, &tmp_5, tmp_6->var, &tmp_7, tmp_8->var, &rcond_v, &tmp_9, work_a->var, &tmp_10, &tmp_11);
     937            jmi_matrix_from_fortran_real(X_a, tmp_6->var, X_a->var);
     938            rank_v = tmp_9;
     939            info_v = tmp_11;
    879940            JMCEVAL_check(\"DONE\");
    880941            JMCEVAL_printArray(Real, X_a);
     
    9781039---
    9791040        JMI_RECORD_STATIC(R_1_r, a_v)
    980         JMI_RECORD_STATIC(R2_0_r, tmp_35)
     1041        JMI_RECORD_STATIC(R2_0_r, tmp_1)
    9811042        JMI_RECORD_STATIC(R_1_r, b_v)
    982         JMI_RECORD_STATIC(R2_0_r, tmp_36)
    983         JMI_RECORD_STATIC(R_1_r_ext, tmp_37)
    984         JMI_RECORD_STATIC(R_1_r_ext, tmp_38)
     1043        JMI_RECORD_STATIC(R2_0_r, tmp_2)
     1044        JMI_RECORD_STATIC(R_1_r_ext, tmp_3)
     1045        JMI_RECORD_STATIC(R_1_r_ext, tmp_4)
    9851046        extern void f(R_1_r*, R_1_r**);
    9861047
     
    9911052        JMCEVAL_parse(String, a_v->a4);
    9921053        JMCEVAL_parse(Enum, a_v->a5);
    993         JMCEVAL_parse(Real, tmp_35->x);
    994         a_v->r2 = tmp_35;
     1054        JMCEVAL_parse(Real, tmp_1->x);
     1055        a_v->r2 = tmp_1;
    9951056        JMCEVAL_parse(Real, b_v->a1);
    9961057        JMCEVAL_parse(Integer, b_v->a2);
     
    9981059        JMCEVAL_parse(String, b_v->a4);
    9991060        JMCEVAL_parse(Enum, b_v->a5);
    1000         JMCEVAL_parse(Real, tmp_36->x);
    1001         b_v->r2 = tmp_36;
    1002 
    1003 ---
    1004             tmp_37->a1 = (double)a_v->a1;
    1005             tmp_37->a2 = (int)a_v->a2;
    1006             tmp_37->a3 = (int)a_v->a3;
    1007             JMI_ASG(STR, tmp_37->a4, a_v->a4)
    1008             tmp_37->a5 = (int)a_v->a5;
    1009             tmp_37->r2.x = (double)a_v->r2->x;
    1010             tmp_38->a1 = (double)b_v->a1;
    1011             tmp_38->a2 = (int)b_v->a2;
    1012             tmp_38->a3 = (int)b_v->a3;
    1013             JMI_ASG(STR, tmp_38->a4, b_v->a4)
    1014             tmp_38->a5 = (int)b_v->a5;
    1015             tmp_38->r2.x = (double)b_v->r2->x;
    1016             f(tmp_37, tmp_38);
    1017             b_v->a1 = tmp_38->a1;
    1018             b_v->a2 = tmp_38->a2;
    1019             b_v->a3 = tmp_38->a3;
    1020             JMI_ASG(STR, tmp_38->a4, b_v->a4)
    1021             b_v->a5 = tmp_38->a5;
    1022             b_v->r2->x = tmp_38->r2.x;
     1061        JMCEVAL_parse(Real, tmp_2->x);
     1062        b_v->r2 = tmp_2;
     1063
     1064---
     1065            tmp_3->a1 = (double)a_v->a1;
     1066            tmp_3->a2 = (int)a_v->a2;
     1067            tmp_3->a3 = (int)a_v->a3;
     1068            JMI_ASG(STR, tmp_3->a4, a_v->a4)
     1069            tmp_3->a5 = (int)a_v->a5;
     1070            tmp_3->r2.x = (double)a_v->r2->x;
     1071            tmp_4->a1 = (double)b_v->a1;
     1072            tmp_4->a2 = (int)b_v->a2;
     1073            tmp_4->a3 = (int)b_v->a3;
     1074            JMI_ASG(STR, tmp_4->a4, b_v->a4)
     1075            tmp_4->a5 = (int)b_v->a5;
     1076            tmp_4->r2.x = (double)b_v->r2->x;
     1077            f(tmp_3, tmp_4);
     1078            b_v->a1 = tmp_4->a1;
     1079            b_v->a2 = tmp_4->a2;
     1080            b_v->a3 = tmp_4->a3;
     1081            JMI_ASG(STR, tmp_4->a4, b_v->a4)
     1082            b_v->a5 = tmp_4->a5;
     1083            b_v->r2->x = tmp_4->r2.x;
    10231084            JMCEVAL_check(\"DONE\");
    10241085            JMCEVAL_print(Real, b_v->a1);
     
    10491110        function constructor
    10501111            input R1 r1;
    1051             output EO eo;
     1112            output EO eo_c;
    10521113            external;
    10531114        end constructor;
    10541115        function destructor
    1055             input EO eo;
     1116            input EO eo_d;
    10561117            external;
    10571118        end destructor;
     
    10591120   
    10601121    function f
    1061         input EO eo;
     1122        input EO eo_1_f;
     1123        input EO eo_2_f;
    10621124        output Real y;
    10631125        external;
    10641126    end f;
    10651127   
    1066     parameter EO eo = EO(R1(R2(3)));
    1067     Real y = f(eo);
     1128    parameter EO eo_m = EO(R1(R2(3)));
     1129    Real y = f(eo_m, eo_m);
    10681130   
    10691131    annotation(__JModelica(UnitTesting(tests={
     
    11161178
    11171179
    1118         JMI_DEF(EXO, eo_v)
    1119 
    1120 ---
    1121         JMI_RECORD_STATIC(R1_1_r_ext, tmp_39)
     1180        JMI_DEF(EXO, eo_1_f_v)
     1181        JMI_DEF(EXO, eo_2_f_v)
     1182
     1183---
     1184        JMI_RECORD_STATIC(R1_1_r_ext, tmp_2)
    11221185        extern void* constructor(R1_1_r*);
    1123         JMI_RECORD_STATIC(R1_1_r, tmp_40_arg0)
    1124         JMI_RECORD_STATIC(R2_0_r, tmp_41)
    1125 
    1126 ---
    1127         JMCEVAL_parse(Real, tmp_41->x);
    1128         tmp_40_arg0->r2 = tmp_41;
    1129         tmp_39->r2.x = (double)tmp_40_arg0->r2->x;
    1130         eo_v = constructor(tmp_39);
     1186        JMI_RECORD_STATIC(R1_1_r, tmp_3_arg1)
     1187        JMI_RECORD_STATIC(R2_0_r, tmp_4)
     1188        JMI_RECORD_STATIC(R1_1_r_ext, tmp_2)
     1189        extern void* constructor(R1_1_r*);
     1190        JMI_RECORD_STATIC(R1_1_r, tmp_6_arg1)
     1191        JMI_RECORD_STATIC(R2_0_r, tmp_7)
     1192
     1193---
     1194        JMCEVAL_parse(Real, tmp_4->x);
     1195        tmp_3_arg1->r2 = tmp_4;
     1196        tmp_2->r2.x = (double)tmp_3_arg1->r2->x;
     1197        eo_1_f_v = constructor(tmp_2);
     1198        JMCEVAL_parse(Real, tmp_7->x);
     1199        tmp_6_arg1->r2 = tmp_7;
     1200        tmp_2->r2.x = (double)tmp_6_arg1->r2->x;
     1201        eo_2_f_v = constructor(tmp_2);
    11311202
    11321203---
     
    11341205---
    11351206        JMI_DEF(REA, y_v)
    1136         extern double f(void*);
     1207        extern double f(void*, void*);
    11371208
    11381209---
     
    11401211
    11411212---
    1142             y_v = f(eo_v);
     1213            y_v = f(eo_1_f_v, eo_2_f_v);
    11431214            JMCEVAL_check(\"DONE\");
    11441215            JMCEVAL_print(Real, y_v);
     
    11481219
    11491220---
    1150         destructor(eo_v);
     1221        destructor(eo_1_f_v);
     1222        destructor(eo_2_f_v);
    11511223
    11521224")})));
    11531225end RecordExternalObject;
    11541226
     1227model PackageConstant1
     1228type E = enumeration(A,B);
     1229function f
     1230    input Real[:] a;
     1231    output Real[size(a,1)] b;
     1232    constant Real[:] c = {2};
     1233    external "C" f(a,b,c);
     1234end f;
     1235    Real[1] x1 = f({1});
     1236
     1237    annotation(__JModelica(UnitTesting(tests={
     1238        CCodeGenTestCase(
     1239            name="PackageConstant1",
     1240            description="",
     1241            variability_propagation=false,
     1242            inline_functions="none",
     1243            template="
     1244$ECE_external_includes$
     1245$ECE_record_definitions$
     1246$ECE_decl$
     1247---
     1248$ECE_setup_decl$
     1249---
     1250$ECE_setup_init$
     1251---
     1252$ECE_setup_free$
     1253---
     1254$ECE_calc_decl$
     1255---
     1256$ECE_calc_init$
     1257---
     1258$ECE_calc$
     1259---
     1260$ECE_calc_free$
     1261---
     1262$ECE_free$
     1263",
     1264            generatedCode="
     1265---
     1266
     1267---
     1268
     1269---
     1270
     1271---
     1272        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, a_a, -1, 1)
     1273        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, b_a, -1, 1)
     1274        JMI_ARR(DYNA, jmi_real_t, jmi_array_t, f_arg2, -1, 1)
     1275        extern void f(double*, double*, double*);
     1276
     1277---
     1278        JMCEVAL_parseArrayDims(1);
     1279        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, a_a, d[0], 1, d[0])
     1280        JMCEVAL_parseArray(Real, a_a);
     1281        JMCEVAL_parseArrayDims(1);
     1282        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, b_a, d[0], 1, d[0])
     1283        JMCEVAL_parseArray(Real, b_a);
     1284        JMCEVAL_parseArrayDims(1);
     1285        JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, f_arg2, d[0], 1, d[0])
     1286        JMCEVAL_parseArray(Real, f_arg2);
     1287
     1288---
     1289            f(a_a->var, b_a->var, f_arg2->var);
     1290            JMCEVAL_check(\"DONE\");
     1291            JMCEVAL_printArray(Real, b_a);
     1292
     1293
     1294---
     1295
     1296---
     1297")})));
     1298end PackageConstant1;
     1299
    11551300end CCodeGenExternalCevalTests;
  • branches/2.4.x/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalTests.mo

    r11417 r11573  
    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
     
    23702291    tmp_9 = (int)n_v;
    23712292    tmp_10 = (int)info_v;
    2372     dgeev_(tmp_1, tmp_2, &tmp_3, tmp_4->var, &tmp_5, eigenReal_a->var, eigenImag_a->var, tmp_6->var, &tmp_7, tmp_8->var, &tmp_9, work_a->var, &jmi_array_size(work_a, 0), &tmp_10);
     2293    dgeev_(tmp_1, tmp_2, &tmp_9, tmp_4->var, &tmp_9, eigenReal_a->var, eigenImag_a->var, tmp_6->var, &tmp_7, tmp_8->var, &tmp_9, work_a->var, &jmi_array_size(work_a, 0), &tmp_10);
    23732294    jmi_matrix_from_fortran_real(eigenVectors_a, tmp_8->var, eigenVectors_a->var);
    23742295    info_v = tmp_10;
  • branches/2.4.x/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenGlobalsTests.mo

    r11388 r11573  
    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
     1423jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     1424    JMI_DYNAMIC_INIT()
     1425    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 1, 1)
     1426    JMI_GLOBALS_INIT()
     1427    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 1, 1, 1)
     1428    jmi_array_val_1(tmp_1, 1) = 3;
     1429    JMI_GLOBALS_FREE()
     1430    JMI_DYNAMIC_FREE()
     1431    return tmp_1;
     1432}
     1433
     1434jmi_array_t* jmi_global_tmp_2(jmi_t* jmi) {
     1435    JMI_DYNAMIC_INIT()
     1436    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_2, 1, 1)
     1437    JMI_GLOBALS_INIT()
     1438    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_2, 1, 1, 1)
     1439    jmi_array_val_1(tmp_2, 1) = 3;
     1440    JMI_GLOBALS_FREE()
     1441    JMI_DYNAMIC_FREE()
     1442    return tmp_2;
     1443}
     1444
     1445int jmi_set_globals_start_0(jmi_t* jmi) {
     1446    int ef = 0;
     1447    JMI_DYNAMIC_INIT()
     1448    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c) = 3;
     1449    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d) = jmi_global_tmp_1(jmi);
     1450    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c) = 3;
     1451    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d) = jmi_global_tmp_2(jmi);
     1452    JMI_DYNAMIC_FREE()
     1453    return ef;
     1454}
     1455
     1456int jmi_set_globals_start_0(jmi_t* jmi);
     1457
     1458int jmi_set_globals_start(jmi_t* jmi) {
     1459    int ef = 0;
     1460    JMI_DYNAMIC_INIT()
     1461    ef |= jmi_set_globals_start_0(jmi);
     1462    JMI_DYNAMIC_FREE()
     1463    return ef;
     1464}
     1465
     1466void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o);
     1467jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_exp0(jmi_real_t x_v);
     1468void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o);
     1469jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_exp1(jmi_real_t x_v);
     1470
     1471void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(jmi_real_t x_v, jmi_real_t* y_o) {
     1472    JMI_DYNAMIC_INIT()
     1473    JMI_DEF(REA, y_v)
     1474    extern double f(double, double, double*);
     1475    y_v = f(x_v, JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c), JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d)->var);
     1476    JMI_RET(GEN, y_o, y_v)
     1477    JMI_DYNAMIC_FREE()
     1478    return;
     1479}
     1480
     1481jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_exp0(jmi_real_t x_v) {
     1482    JMI_DEF(REA, y_v)
     1483    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_def0(x_v, &y_v);
     1484    return y_v;
     1485}
     1486
     1487void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(jmi_real_t x_v, jmi_real_t* y_o) {
     1488    JMI_DYNAMIC_INIT()
     1489    JMI_DEF(REA, y_v)
     1490    extern double f2(double, double, double*, size_t);
     1491    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));
     1492    JMI_RET(GEN, y_o, y_v)
     1493    JMI_DYNAMIC_FREE()
     1494    return;
     1495}
     1496
     1497jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_exp1(jmi_real_t x_v) {
     1498    JMI_DEF(REA, y_v)
     1499    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_def1(x_v, &y_v);
     1500    return y_v;
     1501}
     1502")})));
     1503end GlobalConstantScalar1;
     1504
     1505model GlobalConstantArray1
     1506   
     1507    constant Real[:] c = {4,0,5};
     1508   
     1509    function f
     1510        input Real x;
     1511        input Integer i;
     1512        output Real y = x .+ c[i];
     1513    algorithm
     1514        annotation(Inline=false);
     1515    end f;
     1516
     1517    Real y = f(time, 2);
     1518
     1519annotation(__JModelica(UnitTesting(tests={
     1520    CCodeGenTestCase(
     1521        name="GlobalConstantArray1",
     1522        description="",
     1523        template="
     1524$C_global_temps$
     1525$C_set_globals_start$
     1526$C_functions$
     1527",
     1528        generatedCode="
     1529    jmi_array_t* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c;
     1530
     1531jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     1532    JMI_DYNAMIC_INIT()
     1533    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 3, 1)
     1534    JMI_GLOBALS_INIT()
     1535    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 3, 1, 3)
     1536    jmi_array_val_1(tmp_1, 1) = 4;
     1537    jmi_array_val_1(tmp_1, 3) = 5;
     1538    JMI_GLOBALS_FREE()
     1539    JMI_DYNAMIC_FREE()
     1540    return tmp_1;
     1541}
     1542
     1543int jmi_set_globals_start_0(jmi_t* jmi) {
     1544    int ef = 0;
     1545    JMI_DYNAMIC_INIT()
     1546    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c) = jmi_global_tmp_1(jmi);
     1547    JMI_DYNAMIC_FREE()
     1548    return ef;
     1549}
     1550
     1551int jmi_set_globals_start_0(jmi_t* jmi);
     1552
     1553int jmi_set_globals_start(jmi_t* jmi) {
     1554    int ef = 0;
     1555    JMI_DYNAMIC_INIT()
     1556    ef |= jmi_set_globals_start_0(jmi);
     1557    JMI_DYNAMIC_FREE()
     1558    return ef;
     1559}
     1560
     1561void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1562    JMI_DYNAMIC_INIT()
     1563    JMI_DEF(REA, y_v)
     1564    y_v = x_v + jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_c), i_v);
     1565    JMI_RET(GEN, y_o, y_v)
     1566    JMI_DYNAMIC_FREE()
     1567    return;
     1568}
     1569
     1570jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1571    JMI_DEF(REA, y_v)
     1572    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantArray1_f_def0(x_v, i_v, &y_v);
     1573    return y_v;
     1574}
     1575")})));
     1576end GlobalConstantArray1;
     1577
     1578model GlobalConstantRecordScalar1
     1579    record R1
     1580        Real[:] a;
     1581    end R1;
     1582   
     1583    record R2
     1584        R1 r1;
     1585    end R2;
     1586   
     1587    function f
     1588        input Real x;
     1589        input Integer i;
     1590        constant R2 r2 = R2(R1(1:2));
     1591        output Real y = x + r2.r1.a[i];
     1592    algorithm
     1593    annotation(Inline=false);
     1594    end f;
     1595   
     1596    Real y = f(time, 2);
     1597   
     1598annotation(__JModelica(UnitTesting(tests={
     1599    CCodeGenTestCase(
     1600        name="GlobalConstantRecordScalar1",
     1601        description="",
     1602        variability_propagation=false,
     1603        template="
     1604$C_records$
     1605$C_global_temps$
     1606$C_set_globals_start$
     1607$C_functions$
     1608",
     1609        generatedCode="
     1610typedef struct R1_0_r_ R1_0_r;
     1611struct R1_0_r_ {
     1612    jmi_array_t* a;
     1613};
     1614JMI_ARRAY_TYPE(R1_0_r, R1_0_ra)
     1615
     1616
     1617typedef struct R2_1_r_ R2_1_r;
     1618struct R2_1_r_ {
     1619    R1_0_r* r1;
     1620};
     1621JMI_ARRAY_TYPE(R2_1_r, R2_1_ra)
     1622
     1623
     1624
     1625    R2_1_r* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_r2;
     1626
     1627jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     1628    JMI_DYNAMIC_INIT()
     1629    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     1630    JMI_GLOBALS_INIT()
     1631    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     1632    jmi_array_val_1(tmp_1, 1) = AD_WRAP_LITERAL(1);
     1633    jmi_array_val_1(tmp_1, 2) = AD_WRAP_LITERAL(2);
     1634    JMI_GLOBALS_FREE()
     1635    JMI_DYNAMIC_FREE()
     1636    return tmp_1;
     1637}
     1638
     1639R1_0_r* jmi_global_tmp_2(jmi_t* jmi) {
     1640    JMI_DYNAMIC_INIT()
     1641    R1_0_r* tmp_2;
     1642    JMI_GLOBALS_INIT()
     1643    tmp_2 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R1_0_r), TRUE);
     1644    tmp_2->a = jmi_global_tmp_1(jmi);
     1645    JMI_GLOBALS_FREE()
     1646    JMI_DYNAMIC_FREE()
     1647    return tmp_2;
     1648}
     1649
     1650R2_1_r* jmi_global_tmp_3(jmi_t* jmi) {
     1651    JMI_DYNAMIC_INIT()
     1652    R2_1_r* tmp_3;
     1653    JMI_GLOBALS_INIT()
     1654    tmp_3 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R2_1_r), TRUE);
     1655    tmp_3->r1 = jmi_global_tmp_2(jmi);
     1656    JMI_GLOBALS_FREE()
     1657    JMI_DYNAMIC_FREE()
     1658    return tmp_3;
     1659}
     1660
     1661int jmi_set_globals_start_0(jmi_t* jmi) {
     1662    int ef = 0;
     1663    JMI_DYNAMIC_INIT()
     1664    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_r2) = jmi_global_tmp_3(jmi);
     1665    JMI_DYNAMIC_FREE()
     1666    return ef;
     1667}
     1668
     1669int jmi_set_globals_start_0(jmi_t* jmi);
     1670
     1671int jmi_set_globals_start(jmi_t* jmi) {
     1672    int ef = 0;
     1673    JMI_DYNAMIC_INIT()
     1674    ef |= jmi_set_globals_start_0(jmi);
     1675    JMI_DYNAMIC_FREE()
     1676    return ef;
     1677}
     1678
     1679void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1680    JMI_DYNAMIC_INIT()
     1681    JMI_DEF(REA, y_v)
     1682    y_v = x_v + jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_r2)->r1->a, i_v);
     1683    JMI_RET(GEN, y_o, y_v)
     1684    JMI_DYNAMIC_FREE()
     1685    return;
     1686}
     1687
     1688jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1689    JMI_DEF(REA, y_v)
     1690    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordScalar1_f_def0(x_v, i_v, &y_v);
     1691    return y_v;
     1692}
     1693")})));
     1694end GlobalConstantRecordScalar1;
     1695
     1696model GlobalConstantRecordArray1
     1697    record R
     1698        Real[:] a;
     1699    end R;
     1700   
     1701    function f
     1702        input Real x;
     1703        input Integer i;
     1704        constant R[:] c = {R(1.0:2.0), R(3.0:4.0)};
     1705        output Real y = c[i].a[i] + x;
     1706        algorithm
     1707    annotation(Inline=false);
     1708    end f;
     1709   
     1710    Real y = f(time, 2);
     1711   
     1712annotation(__JModelica(UnitTesting(tests={
     1713    CCodeGenTestCase(
     1714        name="GlobalConstantRecordArray1",
     1715        description="",
     1716        variability_propagation=false,
     1717        template="
     1718$C_global_temps$
     1719$C_set_globals_start$
     1720$C_functions$
     1721",
     1722        generatedCode="
     1723    R_0_ra* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c;
     1724
     1725jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     1726    JMI_DYNAMIC_INIT()
     1727    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     1728    JMI_GLOBALS_INIT()
     1729    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     1730    jmi_array_val_1(tmp_1, 1) = 1.0;
     1731    jmi_array_val_1(tmp_1, 2) = 2.0;
     1732    JMI_GLOBALS_FREE()
     1733    JMI_DYNAMIC_FREE()
     1734    return tmp_1;
     1735}
     1736
     1737jmi_array_t* jmi_global_tmp_2(jmi_t* jmi) {
     1738    JMI_DYNAMIC_INIT()
     1739    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_2, 2, 1)
     1740    JMI_GLOBALS_INIT()
     1741    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_2, 2, 1, 2)
     1742    jmi_array_val_1(tmp_2, 1) = 3.0;
     1743    jmi_array_val_1(tmp_2, 2) = 4.0;
     1744    JMI_GLOBALS_FREE()
     1745    JMI_DYNAMIC_FREE()
     1746    return tmp_2;
     1747}
     1748
     1749R_0_ra* jmi_global_tmp_3(jmi_t* jmi) {
     1750    JMI_DYNAMIC_INIT()
     1751    JMI_ARR(DYNA, R_0_r, R_0_ra, tmp_3, 2, 1)
     1752    JMI_GLOBALS_INIT()
     1753    JMI_ARRAY_INIT_1(DYNA, R_0_r, R_0_ra, tmp_3, 2, 1, 2)
     1754    jmi_array_rec_1(tmp_3, 1)->a = jmi_global_tmp_1(jmi);
     1755    jmi_array_rec_1(tmp_3, 2)->a = jmi_global_tmp_2(jmi);
     1756    JMI_GLOBALS_FREE()
     1757    JMI_DYNAMIC_FREE()
     1758    return tmp_3;
     1759}
     1760
     1761int jmi_set_globals_start_0(jmi_t* jmi) {
     1762    int ef = 0;
     1763    JMI_DYNAMIC_INIT()
     1764    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c) = jmi_global_tmp_3(jmi);
     1765    JMI_DYNAMIC_FREE()
     1766    return ef;
     1767}
     1768
     1769int jmi_set_globals_start_0(jmi_t* jmi);
     1770
     1771int jmi_set_globals_start(jmi_t* jmi) {
     1772    int ef = 0;
     1773    JMI_DYNAMIC_INIT()
     1774    ef |= jmi_set_globals_start_0(jmi);
     1775    JMI_DYNAMIC_FREE()
     1776    return ef;
     1777}
     1778
     1779void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1780    JMI_DYNAMIC_INIT()
     1781    JMI_DEF(REA, y_v)
     1782    y_v = jmi_array_val_1(jmi_array_rec_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_c), i_v)->a, i_v) + x_v;
     1783    JMI_RET(GEN, y_o, y_v)
     1784    JMI_DYNAMIC_FREE()
     1785    return;
     1786}
     1787
     1788jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1789    JMI_DEF(REA, y_v)
     1790    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray1_f_def0(x_v, i_v, &y_v);
     1791    return y_v;
     1792}")})));
     1793end GlobalConstantRecordArray1;
     1794
     1795model GlobalConstantRecordArray2
     1796    record R1
     1797        Real[:] a;
     1798    end R1;
     1799   
     1800    record R2
     1801        R1 r1;
     1802    end R2;
     1803   
     1804    record R3
     1805        R2 r2;
     1806    end R3;
     1807   
     1808    function f
     1809        input Real x;
     1810        input Integer i;
     1811        constant R3[:] c = {R3(R2(R1(1.0:2.0))),R3(R2(R1(3.0:4.0)))};
     1812        output Real y = c[i].r2.r1.a[i] + x;
     1813        algorithm
     1814    annotation(Inline=false);
     1815    end f;
     1816   
     1817    Real y = f(time, 2);
     1818   
     1819annotation(__JModelica(UnitTesting(tests={
     1820    CCodeGenTestCase(
     1821        name="GlobalConstantRecordArray2",
     1822        description="",
     1823        variability_propagation=false,
     1824        template="
     1825$C_global_temps$
     1826$C_set_globals_start$
     1827$C_functions$
     1828",
     1829        generatedCode="
     1830    R3_2_ra* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_c;
     1831
     1832jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     1833    JMI_DYNAMIC_INIT()
     1834    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     1835    JMI_GLOBALS_INIT()
     1836    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     1837    jmi_array_val_1(tmp_1, 1) = 1.0;
     1838    jmi_array_val_1(tmp_1, 2) = 2.0;
     1839    JMI_GLOBALS_FREE()
     1840    JMI_DYNAMIC_FREE()
     1841    return tmp_1;
     1842}
     1843
     1844R1_0_r* jmi_global_tmp_2(jmi_t* jmi) {
     1845    JMI_DYNAMIC_INIT()
     1846    R1_0_r* tmp_2;
     1847    JMI_GLOBALS_INIT()
     1848    tmp_2 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R1_0_r), TRUE);
     1849    tmp_2->a = jmi_global_tmp_1(jmi);
     1850    JMI_GLOBALS_FREE()
     1851    JMI_DYNAMIC_FREE()
     1852    return tmp_2;
     1853}
     1854
     1855R2_1_r* jmi_global_tmp_3(jmi_t* jmi) {
     1856    JMI_DYNAMIC_INIT()
     1857    R2_1_r* tmp_3;
     1858    JMI_GLOBALS_INIT()
     1859    tmp_3 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R2_1_r), TRUE);
     1860    tmp_3->r1 = jmi_global_tmp_2(jmi);
     1861    JMI_GLOBALS_FREE()
     1862    JMI_DYNAMIC_FREE()
     1863    return tmp_3;
     1864}
     1865
     1866jmi_array_t* jmi_global_tmp_4(jmi_t* jmi) {
     1867    JMI_DYNAMIC_INIT()
     1868    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_4, 2, 1)
     1869    JMI_GLOBALS_INIT()
     1870    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_4, 2, 1, 2)
     1871    jmi_array_val_1(tmp_4, 1) = 3.0;
     1872    jmi_array_val_1(tmp_4, 2) = 4.0;
     1873    JMI_GLOBALS_FREE()
     1874    JMI_DYNAMIC_FREE()
     1875    return tmp_4;
     1876}
     1877
     1878R1_0_r* jmi_global_tmp_5(jmi_t* jmi) {
     1879    JMI_DYNAMIC_INIT()
     1880    R1_0_r* tmp_5;
     1881    JMI_GLOBALS_INIT()
     1882    tmp_5 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R1_0_r), TRUE);
     1883    tmp_5->a = jmi_global_tmp_4(jmi);
     1884    JMI_GLOBALS_FREE()
     1885    JMI_DYNAMIC_FREE()
     1886    return tmp_5;
     1887}
     1888
     1889R2_1_r* jmi_global_tmp_6(jmi_t* jmi) {
     1890    JMI_DYNAMIC_INIT()
     1891    R2_1_r* tmp_6;
     1892    JMI_GLOBALS_INIT()
     1893    tmp_6 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R2_1_r), TRUE);
     1894    tmp_6->r1 = jmi_global_tmp_5(jmi);
     1895    JMI_GLOBALS_FREE()
     1896    JMI_DYNAMIC_FREE()
     1897    return tmp_6;
     1898}
     1899
     1900R3_2_ra* jmi_global_tmp_7(jmi_t* jmi) {
     1901    JMI_DYNAMIC_INIT()
     1902    JMI_ARR(DYNA, R3_2_r, R3_2_ra, tmp_7, 2, 1)
     1903    JMI_GLOBALS_INIT()
     1904    JMI_ARRAY_INIT_1(DYNA, R3_2_r, R3_2_ra, tmp_7, 2, 1, 2)
     1905    jmi_array_rec_1(tmp_7, 1)->r2 = jmi_global_tmp_3(jmi);
     1906    jmi_array_rec_1(tmp_7, 2)->r2 = jmi_global_tmp_6(jmi);
     1907    JMI_GLOBALS_FREE()
     1908    JMI_DYNAMIC_FREE()
     1909    return tmp_7;
     1910}
     1911
     1912int jmi_set_globals_start_0(jmi_t* jmi) {
     1913    int ef = 0;
     1914    JMI_DYNAMIC_INIT()
     1915    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_c) = jmi_global_tmp_7(jmi);
     1916    JMI_DYNAMIC_FREE()
     1917    return ef;
     1918}
     1919
     1920int jmi_set_globals_start_0(jmi_t* jmi);
     1921
     1922int jmi_set_globals_start(jmi_t* jmi) {
     1923    int ef = 0;
     1924    JMI_DYNAMIC_INIT()
     1925    ef |= jmi_set_globals_start_0(jmi);
     1926    JMI_DYNAMIC_FREE()
     1927    return ef;
     1928}
     1929
     1930void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     1931    JMI_DYNAMIC_INIT()
     1932    JMI_DEF(REA, y_v)
     1933    y_v = jmi_array_val_1(jmi_array_rec_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_c), i_v)->r2->r1->a, i_v) + x_v;
     1934    JMI_RET(GEN, y_o, y_v)
     1935    JMI_DYNAMIC_FREE()
     1936    return;
     1937}
     1938
     1939jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     1940    JMI_DEF(REA, y_v)
     1941    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRecordArray2_f_def0(x_v, i_v, &y_v);
     1942    return y_v;
     1943}
     1944")})));
     1945end GlobalConstantRecordArray2;
     1946
     1947
     1948model GlobalConstantForPowInt1
     1949    record R
     1950        Real[:] a;
     1951    end R;
     1952   
     1953    function f
     1954        input Real x;
     1955        constant Integer[:] c = 1:2;
     1956        output Real y = x;
     1957    algorithm
     1958        for i in 1:2 loop
     1959            y := y ^ c[i];
     1960        end for;
     1961    annotation(Inline=false);
     1962    end f;
     1963   
     1964    Real y = f(time);
     1965   
     1966annotation(__JModelica(UnitTesting(tests={
     1967    CCodeGenTestCase(
     1968        name="GlobalConstantForPowInt1",
     1969        description="",
     1970        variability_propagation=false,
     1971        template="
     1972$C_functions$
     1973",
     1974        generatedCode="
     1975void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantForPowInt1_f_def0(jmi_real_t x_v, jmi_real_t* y_o) {
     1976    JMI_DYNAMIC_INIT()
     1977    JMI_DEF(REA, y_v)
     1978    jmi_real_t i_0i;
     1979    jmi_real_t i_0ie;
     1980    y_v = x_v;
     1981    i_0ie = 2 + 1 / 2.0;
     1982    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]\");
     1984    }
     1985    JMI_RET(GEN, y_o, y_v)
     1986    JMI_DYNAMIC_FREE()
     1987    return;
     1988}
     1989
     1990jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantForPowInt1_f_exp0(jmi_real_t x_v) {
     1991    JMI_DEF(REA, y_v)
     1992    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantForPowInt1_f_def0(x_v, &y_v);
     1993    return y_v;
     1994}
     1995")})));
     1996end GlobalConstantForPowInt1;
     1997
     1998model GlobalConstantRef1
     1999   
     2000    record R1
     2001        Real[:] x;
     2002    end R1;
     2003   
     2004    record R2
     2005        extends R1;
     2006    end R2;
     2007   
     2008    record R3
     2009        extends R1;
     2010    end R3;
     2011   
     2012    package P
     2013        constant R1 r1 = R1(1:2);
     2014        constant R2 r2 = r1;
     2015    end P;
     2016   
     2017    function f
     2018        input Real x;
     2019        input Integer i;
     2020        output Real y = x + P.r2.x[i];
     2021    algorithm
     2022        annotation(Inline=false);
     2023    end f;
     2024
     2025    Real y = f(time, 2);
     2026
     2027annotation(__JModelica(UnitTesting(tests={
     2028    CCodeGenTestCase(
     2029        name="GlobalConstantRef1",
     2030        description="",
     2031        template="
     2032$C_global_temps$
     2033$C_set_globals_start$
     2034$C_functions$
     2035",
     2036        generatedCode="
     2037    R1_0_r* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_P_r2;
     2038
     2039jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     2040    JMI_DYNAMIC_INIT()
     2041    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     2042    JMI_GLOBALS_INIT()
     2043    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     2044    jmi_array_val_1(tmp_1, 1) = AD_WRAP_LITERAL(1);
     2045    jmi_array_val_1(tmp_1, 2) = AD_WRAP_LITERAL(2);
     2046    JMI_GLOBALS_FREE()
     2047    JMI_DYNAMIC_FREE()
     2048    return tmp_1;
     2049}
     2050
     2051R1_0_r* jmi_global_tmp_2(jmi_t* jmi) {
     2052    JMI_DYNAMIC_INIT()
     2053    R1_0_r* tmp_2;
     2054    JMI_GLOBALS_INIT()
     2055    tmp_2 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R1_0_r), TRUE);
     2056    tmp_2->x = jmi_global_tmp_1(jmi);
     2057    JMI_GLOBALS_FREE()
     2058    JMI_DYNAMIC_FREE()
     2059    return tmp_2;
     2060}
     2061
     2062int jmi_set_globals_start_0(jmi_t* jmi) {
     2063    int ef = 0;
     2064    JMI_DYNAMIC_INIT()
     2065    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_P_r2) = jmi_global_tmp_2(jmi);
     2066    JMI_DYNAMIC_FREE()
     2067    return ef;
     2068}
     2069
     2070int jmi_set_globals_start_0(jmi_t* jmi);
     2071
     2072int jmi_set_globals_start(jmi_t* jmi) {
     2073    int ef = 0;
     2074    JMI_DYNAMIC_INIT()
     2075    ef |= jmi_set_globals_start_0(jmi);
     2076    JMI_DYNAMIC_FREE()
     2077    return ef;
     2078}
     2079
     2080void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     2081    JMI_DYNAMIC_INIT()
     2082    JMI_DEF(REA, y_v)
     2083    y_v = x_v + jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_P_r2)->x, i_v);
     2084    JMI_RET(GEN, y_o, y_v)
     2085    JMI_DYNAMIC_FREE()
     2086    return;
     2087}
     2088
     2089jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     2090    JMI_DEF(REA, y_v)
     2091    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef1_f_def0(x_v, i_v, &y_v);
     2092    return y_v;
     2093}
     2094")})));
     2095end GlobalConstantRef1;
     2096
     2097model GlobalConstantRef2
     2098   
     2099    record R1
     2100        Real[:] x;
     2101    end R1;
     2102   
     2103    record R2
     2104        extends R1;
     2105    end R2;
     2106   
     2107    record R3
     2108        extends R1;
     2109    end R3;
     2110   
     2111    package P
     2112        constant R1 r1(x=1:2);
     2113        constant R2 r2 = r1;
     2114    end P;
     2115   
     2116    function f
     2117        input Real x;
     2118        input Integer i;
     2119        output Real y = x + P.r2.x[i];
     2120    algorithm
     2121        annotation(Inline=false);
     2122    end f;
     2123
     2124    Real y = f(time, 2);
     2125
     2126annotation(__JModelica(UnitTesting(tests={
     2127    CCodeGenTestCase(
     2128        name="GlobalConstantRef2",
     2129        description="",
     2130        template="
     2131$C_global_temps$
     2132$C_set_globals_start$
     2133$C_functions$
     2134",
     2135        generatedCode="
     2136    R1_0_r* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_P_r2;
     2137
     2138jmi_array_t* jmi_global_tmp_1(jmi_t* jmi) {
     2139    JMI_DYNAMIC_INIT()
     2140    JMI_ARR(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
     2141    JMI_GLOBALS_INIT()
     2142    JMI_ARRAY_INIT_1(DYNA, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
     2143    jmi_array_val_1(tmp_1, 1) = AD_WRAP_LITERAL(1);
     2144    jmi_array_val_1(tmp_1, 2) = AD_WRAP_LITERAL(2);
     2145    JMI_GLOBALS_FREE()
     2146    JMI_DYNAMIC_FREE()
     2147    return tmp_1;
     2148}
     2149
     2150R1_0_r* jmi_global_tmp_2(jmi_t* jmi) {
     2151    JMI_DYNAMIC_INIT()
     2152    R1_0_r* tmp_2;
     2153    JMI_GLOBALS_INIT()
     2154    tmp_2 = jmi_dynamic_function_pool_alloc(&dyn_mem, 1*sizeof(R1_0_r), TRUE);
     2155    tmp_2->x = jmi_global_tmp_1(jmi);
     2156    JMI_GLOBALS_FREE()
     2157    JMI_DYNAMIC_FREE()
     2158    return tmp_2;
     2159}
     2160
     2161int jmi_set_globals_start_0(jmi_t* jmi) {
     2162    int ef = 0;
     2163    JMI_DYNAMIC_INIT()
     2164    JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_P_r2) = jmi_global_tmp_2(jmi);
     2165    JMI_DYNAMIC_FREE()
     2166    return ef;
     2167}
     2168
     2169int jmi_set_globals_start_0(jmi_t* jmi);
     2170
     2171int jmi_set_globals_start(jmi_t* jmi) {
     2172    int ef = 0;
     2173    JMI_DYNAMIC_INIT()
     2174    ef |= jmi_set_globals_start_0(jmi);
     2175    JMI_DYNAMIC_FREE()
     2176    return ef;
     2177}
     2178
     2179void func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t* y_o) {
     2180    JMI_DYNAMIC_INIT()
     2181    JMI_DEF(REA, y_v)
     2182    y_v = x_v + jmi_array_val_1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_P_r2)->x, i_v);
     2183    JMI_RET(GEN, y_o, y_v)
     2184    JMI_DYNAMIC_FREE()
     2185    return;
     2186}
     2187
     2188jmi_real_t func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_f_exp0(jmi_real_t x_v, jmi_real_t i_v) {
     2189    JMI_DEF(REA, y_v)
     2190    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantRef2_f_def0(x_v, i_v, &y_v);
     2191    return y_v;
     2192}
     2193")})));
     2194end GlobalConstantRef2;
     2195
     2196end GlobalVariables;
     2197
    13862198end CCodeGenGlobalsTests;
  • branches/2.4.x/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenTests.mo

    r11471 r11573  
    53535353end CUnknownArray11;
    53545354
    5355 model CUnknownArray12
    5356     record R
    5357         Real[:] a;
    5358     end R;
    5359    
    5360     function f
    5361         input Integer i;
    5362         constant R[:] c = {R(1:2)};
    5363         output Real y = c[i].a[1];
    5364         algorithm
    5365     end f;
    5366    
    5367     Real x = f(1);
    5368    
    5369 annotation(__JModelica(UnitTesting(tests={
    5370     CCodeGenTestCase(
    5371         name="CUnknownArray12",
    5372         description="Sorted initialization",
    5373         variability_propagation=false,
    5374         inline_functions="none",
    5375         template="$C_functions$",
    5376         generatedCode="
    5377 void func_CCodeGenTests_CUnknownArray12_f_def0(jmi_real_t i_v, jmi_real_t* y_o) {
    5378     JMI_DYNAMIC_INIT()
    5379     JMI_ARR(STAT, R_0_r, R_0_ra, c_a, 1, 1)
    5380     JMI_ARR(STAT, jmi_real_t, jmi_array_t, tmp_1, 2, 1)
    5381     JMI_DEF(REA, y_v)
    5382     JMI_ARRAY_INIT_1(STAT, R_0_r, R_0_ra, c_a, 1, 1, 1)
    5383     JMI_ARRAY_INIT_1(STAT, jmi_real_t, jmi_array_t, tmp_1, 2, 1, 2)
    5384     jmi_array_rec_1(c_a, 1)->a = tmp_1;
    5385     jmi_array_ref_1(jmi_array_rec_1(c_a, 1)->a, 1) = 1;
    5386     jmi_array_ref_1(jmi_array_rec_1(c_a, 1)->a, 2) = 2;
    5387     y_v = jmi_array_val_1(jmi_array_rec_1(c_a, i_v)->a, 1);
    5388     JMI_RET(GEN, y_o, y_v)
    5389     JMI_DYNAMIC_FREE()
    5390     return;
    5391 }
    5392 
    5393 jmi_real_t func_CCodeGenTests_CUnknownArray12_f_exp0(jmi_real_t i_v) {
    5394     JMI_DEF(REA, y_v)
    5395     func_CCodeGenTests_CUnknownArray12_f_def0(i_v, &y_v);
    5396     return y_v;
    5397 }
    5398 
    5399 ")})));
    5400 end CUnknownArray12;
    5401 
    54025355model CUnknownArray13
    54035356    function f
  • branches/2.4.x/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r11425 r11573  
    12931293
    12941294    protected ExternCEvalGenerator createCGenerator(FExternalStmt ext) {
    1295         CodeGenContext cgc = new CodeGenContext();
     1295        CodeGenContext cgc = new CodeGenContext().createProxy();
    12961296        Map<String,String> tempMap = new HashMap<String,String>();
    12971297        return new ExternCEvalGenerator(ASTNode.prettyPrinter, '$', null, ext, cgc, tempMap);
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r11572 r11573  
    26142614                if (!bexp.type().isUnknown())
    26152615                    val = bexp.ceval(evaluator, i);
    2616             } else if (!func && !inRecordDecl()) {
     2616            } else if ((!func && !inRecordDecl()) || isRecord()) {
    26172617                val = cevalNoBExp(evaluator, i);
    26182618            }
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluationStatements.jrag

    r11572 r11573  
    134134
    135135    public void FAccessString.assignToInFuncEval(AlgorithmEvaluator evaluator, CValue right) {
    136         FFunctionVariable var = myFuncFV();
    137         var.setEvaluationValue(evaluator, right);
     136        myTopFV().setEvaluationValue(evaluator, right);
    138137    }
    139138
    140139    public void FAccessFull.assignToInFuncEval(AlgorithmEvaluator evaluator, CValue right) {
    141         FFunctionVariable var = myFuncFV();
     140        FAbstractVariable var = myTopFV();
    142141        FAccessPart firstPart = getFAccessPart(0);
    143142        CValue val = var.type().assignToPartInFuncEval(firstPart, var.evaluationValue(evaluator), right);
     
    304303    @Override
    305304    public int FExternalStmt.evaluate(AlgorithmEvaluator evaluator) {
    306         if (!canEvaluate(evaluator) || hasUnknownArguments(evaluator.getValues())) {
    307             throw new ConstantEvaluationException(null, "Could not evaluate external function");
    308         }
    309305        return evaluateExternal(evaluator);
    310306    }
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ExternalConstantEvaluation.jrag

    r10911 r11573  
    3434aspect ExternalConstantEvaluation {
    3535   
     36    public interface ExternalArgument {
     37        CValue ceval();
     38        FType type();
     39       
     40        String name_C();
     41        boolean isOutput();
     42    }
     43   
     44    public interface CommonVariableDecl extends ExternalArgument {}
     45    FExp implements ExternalArgument;
     46   
     47    syn boolean FExp.isOutput() = false;
     48   
    3649    class ModelicaCompiler {}
    3750   
    38     ModelicaCompiler   implements ExternalProcessMultiCache.Compiler<CommonVariableDecl, FExternalStmt>;
    39     FExternalStmt      implements ExternalProcessMultiCache.External<CommonVariableDecl>;
    40     CommonVariableDecl implements ExternalProcessMultiCache.Variable<CValue,FType>;
     51    ModelicaCompiler   implements ExternalProcessMultiCache.Compiler<ExternalArgument, FExternalStmt>;
     52    FExternalStmt      implements ExternalProcessMultiCache.External<ExternalArgument>;
     53    ExternalArgument   extends    ExternalProcessMultiCache.Variable<CValue,FType>;
    4154    CValue             implements ExternalProcessMultiCache.Value;
    4255    FType              implements ExternalProcessMultiCache.Type<CValue>;
    4356   
    44     public class ExternalFunctionCache extends ExternalProcessMultiCache<CommonVariableDecl, CValue, FType, FExternalStmt> {
     57    public class ExternalFunctionCache extends ExternalProcessMultiCache<ExternalArgument, CValue, FType, FExternalStmt> {
    4558        public ExternalFunctionCache(ModelicaCompiler mc) {
    4659            super(mc);
     
    4962   
    5063    /**
    51      * Check if this external function can be evaluated.
    52      */
    53     syn boolean FExternalStmt.canEvaluate(AlgorithmEvaluator evaluator) {
     64     * Check if this external function can be evaluated. Throw ConstantEvaluationException otherwise
     65     */
     66    public void FExternalStmt.checkCanEvaluate(AlgorithmEvaluator evaluator, Map<ExternalArgument, CValue> values) throws ConstantEvaluationException {
    5467        if (evaluator.externalEvaluation() == 0) {
    55             return false;
     68            throw new ConstantEvaluationException(null, "Could not evaluate external function, external evaluation disabled");
    5669        }
    5770        for (FExp arg : getArgs()) {
    5871            if (!arg.type().externalValid()) {
    59                 return false;
     72                throw new ConstantEvaluationException(null, "Could not evaluate external function, invalid argument type");
    6073            }
    6174        }
    6275        if (hasReturnVar() && !getReturnVar().type().externalValid()) {
    63             return false;
    64         }
    65         return true;
    66     }
    67 
    68     syn boolean FExternalStmt.hasUnknownArguments(Map<CommonVariableDecl, CValue> values) {
    69         for (CommonVariableDecl cvd : varsToSerialize()) {
    70             if (!cvd.isOutput()) {
    71                 CValue val = values.containsKey(cvd) ? values.get(cvd) : cvd.ceval();
    72                 if (val.isPartlyUnknown()) {
    73                     return true;
     76            throw new ConstantEvaluationException(null, "Could not evaluate external function, invalid return type");
     77        }
     78        Collection<ExternalArgument> outputs = varsToDeserialize();
     79        for (ExternalArgument arg : values.keySet()) {
     80            if (!outputs.contains(arg)) {
     81                if (values.get(arg).isPartlyUnknown()) {
     82                    throw new ConstantEvaluationException(null, "Could not evaluate external function, unknown values in arguments");
    7483                }
    7584            }
    7685        }
    77         return false;
    7886    }
    7987
     
    8997     * one scalar external object, return null.
    9098     */
    91     syn CommonVariableDecl FExternalStmt.cachedExternalObject() {
    92         CommonVariableDecl eo = null;
    93         for (CommonVariableDecl cvd : varsToSerialize()) {
     99    syn ExternalArgument FExternalStmt.cachedExternalObject() {
     100        ExternalArgument eo = null;
     101        for (ExternalArgument cvd : varsToSerialize()) {
    94102            if (cvd.type().isExternalObject() && cvd.type().isScalar()) {
    95103                if (eo != null) {
     
    158166     * this statement refers to.
    159167     */
    160     public ExternalFunction<CommonVariableDecl, CValue> FExternalStmt.myExternalFunction() {
     168    public ExternalFunction<ExternalArgument, CValue> FExternalStmt.myExternalFunction() {
    161169        ExternalFunctionCache efc = root().getUtilInterface().getExternalFunctionCache();
    162170        if (efc == null) {
     
    172180    public int FExternalStmt.evaluateExternal(AlgorithmEvaluator evaluator) {
    173181       
    174         Map<CommonVariableDecl, CValue> values = evaluator.getValues();
     182        Map<ExternalArgument, CValue> values = new LinkedHashMap<>();
     183        for (ExternalArgument arg : varsToSerialize()) {
     184            values.put(arg, arg.ceval());
     185        }
     186       
     187        checkCanEvaluate(evaluator, values);
    175188       
    176189        if (isConstructorStmt()) {
    177             return evaluateConstructor(values);
     190            return evaluateConstructor(evaluator.getValues());
    178191        }
    179192       
    180193        int res = 0;
    181194        int timeout = evaluator.externalEvaluation();
    182         ExternalFunction<CommonVariableDecl,CValue> ef = myExternalFunction();
     195        ExternalFunction<ExternalArgument,CValue> ef = myExternalFunction();
    183196        String error = null;
    184197        try {
     
    193206        if (error != null) {
    194207            throw new ConstantEvaluationException(null, ExternalProcessCacheImpl.failedEvalMsg(getName(), error));
     208        }
     209       
     210        for (ExternalArgument output : varsToDeserialize()) {
     211            evaluator.getValues().put((CommonVariableDecl)output, values.get(output));
    195212        }
    196213       
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/Constructors.jrag

    r11572 r11573  
    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(); }
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r11572 r11573  
    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     */
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/FlatNameBinding.jrag

    r11572 r11573  
    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(getFGlobalVariables());
    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();
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/FlatUtil.jrag

    r11572 r11573  
    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     
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r11572 r11573  
    10031003            }
    10041004        }
    1005 
     1005        if (getNumFGlobalVariable() > 0) {
     1006            str.println(indent, "package constant");
     1007            for (FVariable fv : getFGlobalVariables()) {
     1008                p.print(fv, str, nextInd);
     1009                str.println(";");
     1010            }
     1011        }
    10061012        if (getNumFInitialEquation() > 0) {
    10071013            str.println(indent, "initial equation");
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r11572 r11573  
    3030
    3131    syn lazy FType FAbstractVariable.type();
     32    eq FGlobalVariable.type()           = getFType();
    3233    eq FRealVariable.type()             = fRealType(size());
    3334    eq FIntegerVariable.type()          = fIntegerType(size());
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/Variability.jrag

    r11572 r11573  
    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()     = myFV()   .variability()                   .combine(indexVariability());
     550    eq FAccessFull.variability() = myTopFV().variabilityHierarchical(this, 1).combine(indexVariability());
     551
     552    syn TypePrefixVariability FAbstractVariable.variabilityHierarchical(FAccessFull name, int i) {
     553        TypePrefixVariability res = variability();
     554        if (i < name.getNumFAccessPart()) {
     555            FAccessPart part = name.getFAccessPart(i);
     556            res = res.combine().combineDown(myFRecordDecl().lookupFV(part.getName()).variabilityHierarchical(name, i + 1));
     557        }
     558        return res;
     559    }
     560    eq FFunctionVariable.variabilityHierarchical(FAccessFull name, int i) = variability();
    557561
    558562    syn TypePrefixVariability FSubscript.variability() = Variability.CONSTANT;
  • branches/2.4.x/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

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

    r11285 r11573  
    19671967  Could not evaluate binding expression for structural parameter 'n': 'f(a)'
    19681968    in function 'EvaluationTests.EvalNoBinding5.f'
    1969     Could not evaluate external function
     1969    Could not evaluate external function, unknown values in arguments
    19701970
    19711971Error at line 25, column 12, in file 'Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo':
  • branches/2.4.x/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r11572 r11573  
    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<FGlobalVariable>   globalVariables = new List<FGlobalVariable>();
     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<FGlobalVariable> getFGlobalVariables() {
     179            return globalVariables;
     180        }
     181       
    173182        public List<FVariable> getFVariables() {
    174183            return variables;
     
    191200        }
    192201       
    193         public List<FVariable> addFVariable(FVariable fvariable) {
    194             return variables.add(fvariable);
    195         }
    196        
    197         public List<FAbstractEquation> addNormalEquation(FAbstractEquation fae) {
    198             return normalEqns.add(fae);
    199         }
    200        
    201          public List<FAbstractEquation> addParameterEquation(FAbstractEquation fae) {
    202             return parameterEqns.add(fae);
    203         }
    204        
    205         public List<FFunctionDecl> addFFunctionDecl(FFunctionDecl ffd) {
     202        public void addGlobalVariable(FVariable fvariable) {
     203            addFlattened(fvariable.name());
     204            globalVariables.add((FGlobalVariable)fvariable);
     205        }
     206       
     207        public void addFVariable(FVariable fvariable) {
     208            variables.add(fvariable);
     209        }
     210       
     211        public void addNormalEquation(FAbstractEquation fae) {
     212            normalEqns.add(fae);
     213        }
     214       
     215         public void addParameterEquation(FAbstractEquation fae) {
     216            parameterEqns.add(fae);
     217        }
     218       
     219        public void addFFunctionDecl(FFunctionDecl ffd) {
    206220            addFlattened(ffd.name());
    207             return functionDecls.add(ffd);
    208         }
    209        
    210         public List<FRecordDecl> addFRecordDecl(FRecordDecl frd) {
     221            functionDecls.add(ffd);
     222        }
     223       
     224        public void addFRecordDecl(FRecordDecl frd) {
    211225            addFlattened(frd.name());
    212             return recordDecls.add(frd);
    213         }
    214        
    215         public List<FEnumDecl> addFEnumDecl(FEnumDecl fed) {
     226            recordDecls.add(frd);
     227        }
     228       
     229        public void addFEnumDecl(FEnumDecl fed) {
    216230            addFlattened(fed.name());
    217             return enumDecls.add(fed);
    218         }
    219        
    220         public List<FDerivedType> addFDerivedType(FDerivedType fdt) {
     231            enumDecls.add(fed);
     232        }
     233       
     234        public void addFDerivedType(FDerivedType fdt) {
    221235            addFlattened(fdt.name());
    222             return derivedTypes.add(fdt);
     236            derivedTypes.add(fdt);
    223237        }
    224238
     
    249263    // refined in OptimicaFlattening
    250264    public void FClass.update(Flattener f) {
     265        setFGlobalVariableList(f.getFGlobalVariables());
    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);
     
    15391495    public void InstLibNode.flattenEnum(Flattener f) {
    15401496        actualInstClass().flattenEnum(f);
     1497    }
     1498
     1499    public FVariable InstAssignable.createEmptyFGlobalVariable(Flattener f) {
     1500        FGlobalVariable res = new FGlobalVariable();
     1501        res.setFType(type().flatten(f, this, false));
     1502        return res;
    15411503    }
    15421504   
     
    16381600        }
    16391601        boolean flattenBinding = binding.shouldFlattenExp(this);
    1640         if (flattenBinding && declaredSizeCalc().isUnknownNoEval()) {
     1602        if (flattenBinding && !isConstant() && declaredSizeCalc().isUnknownNoEval()) {
    16411603            FInternalAttribute ia = (FInternalAttribute)findMatching(list, "size()");
    16421604            if (ia == null) {
     
    17011663
    17021664    public FVariable InstAssignable.createFVariable(Flattener f) {
    1703         return createFVariable(f, getFAccess(), FlattenBindingExp.ALL);
    1704     }
    1705 
    1706     public FVariable InstAssignable.createFVariable(Flattener f, FAccess name, FlattenBindingExp binding) {
    1707         FVariable fv = createEmptyFVariable();
     1665        return createFVariable(f, getFAccess(), FlattenBindingExp.ALL, false);
     1666    }
     1667
     1668    public FVariable InstAssignable.createFVariable(Flattener f, FAccess name, FlattenBindingExp binding, boolean global) {
     1669        FVariable fv = global ? createEmptyFGlobalVariable(f) : createEmptyFVariable();
    17081670        fv.setVisibilityType(createVisibilityType());
    17091671        fv.setTypePrefixVariability(variability());
     
    18111773            if (variability().knownParameterOrLess()) {
    18121774                CValue cval = ceval();
     1775                FExp t = dynamicFExp(cval.buildInstLiteral());
     1776                t.flattenUsedFuncsAndEnums(f);
    18131777                if (cval.hasBuildLiteral()) {
    18141778                    return cval.buildLiteral();
  • branches/2.4.x/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningAccess.jrag

    r11572 r11573  
    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;
  • branches/2.4.x/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ProcessCommunicator.java

    r10911 r11573  
    7171     */
    7272    public void put(V val, T type) throws IOException {
    73         // mc.log().debug("ProcessCommunicator WRITE: " + val.toString() + " of type:
    74         // "+type.toString());
     73//        mc.log().debug("ProcessCommunicator WRITE: " + val.toString() + " of type:" + type.toString());
    7574        val.serialize(out);
    7675        out.flush();
     
    8281    public V get(T type) throws IOException {
    8382        V val = type.deserialize(this);
    84         // mc.log().debug("ProcessCommunicator READ: " + val.toString());
     83//        mc.log().debug("ProcessCommunicator READ: " + val.toString());
    8584        return val;
    8685    }
  • branches/2.4.x/Compiler/ModelicaFrontEnd/test/modelica/ArrayTests.mo

    r11460 r11573  
    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")})));
  • branches/2.4.x/Compiler/ModelicaFrontEnd/test/modelica/FunctionTests.mo

    r11461 r11573  
    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;
  • branches/2.4.x/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo

    r11427 r11573  
    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
  • branches/2.4.x/Compiler/ModelicaFrontEnd/test/modelica/RecordTests.mo

    r11460 r11573  
    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
  • branches/2.4.x/Compiler/ModelicaFrontEnd/test/modelica/VariabilityTests.mo

    r11477 r11573  
    11421142end BindingExpVariability1;
    11431143
     1144model RecordVariabilityScalarization1
     1145        record R1
     1146            Real x;
     1147            constant Real y = 2;
     1148        end R1;
     1149       
     1150        record R2
     1151            Real x;
     1152            constant Real z = 2;
     1153        end R2;
     1154       
     1155        parameter R1 r1(x=time);
     1156        parameter R2 r2(x=time);
     1157        parameter Real[:] x = {r1.x, r2.x};
     1158
     1159    annotation(__JModelica(UnitTesting(tests={
     1160        TransformCanonicalTestCase(
     1161            name="RecordVariabilityScalarization1",
     1162            description="",
     1163            flatModel="
     1164fclass VariabilityTests.RecordVariabilityScalarization1
     1165 parameter Real r1.x;
     1166 constant Real r1.y = 2;
     1167 parameter Real r2.x;
     1168 parameter Real x[1];
     1169 parameter Real x[2];
     1170parameter equation
     1171 r1.x = time;
     1172 r2.x = time;
     1173 x[1] = r1.x;
     1174 x[2] = r2.x;
     1175end VariabilityTests.RecordVariabilityScalarization1;
     1176")})));
     1177end RecordVariabilityScalarization1;
     1178
    11441179end VariabilityTests;
  • branches/2.4.x/Compiler/ModelicaMiddleEnd/src/jastadd/TransformCanonical.jrag

    r11572 r11573  
    8888
    8989    public void FClass.transformCanonicalCleanup() {
    90         removeUnusedFunctionsAndRecords();
     90        removeUnusedGlobals();
    9191        root().flushAllRecursive();
    92         for (FRecordDecl rec : getFRecordDecls())
    93             rec.clearBindingEquations();
    9492    }
    9593   
     
    11251123     */
    11261124    abstract public FVariable FVariable.createPreVariable();
    1127    
     1125
     1126    public FVariable FGlobalVariable.createPreVariable() {
     1127        throw new UnsupportedOperationException();
     1128    }
     1129
    11281130    public FVariable FRealVariable.createPreVariable() {
    11291131        return new FPreRealVariable(this);
     
    29322934   
    29332935}
    2934 
    2935 aspect FunctionAndRecordCleanup {
    2936     /**
    2937      * Remove unused function and record declarations from the flat model.
    2938      */
    2939     public void FClass.removeUnusedFunctionsAndRecords() {
    2940         beginStep("removeUnusedFunctionsAndRecords()");
    2941         for (FFunctionDecl decl : getFFunctionDecls())
    2942             decl.resetUsedIndicator();
    2943         for (FRecordDecl decl : getFRecordDecls())
    2944             decl.resetUsedIndicator();
    2945         getFVariables().markUsedFunctionsAndRecords();
    2946         getFInitialEquations().markUsedFunctionsAndRecords();
    2947         getParameterEquations().markUsedFunctionsAndRecords();
    2948         getFAbstractEquations().markUsedFunctionsAndRecords();
    2949         getDynamicStateManager().markUsedFunctionsAndRecords();
    2950         List<FFunctionDecl> funcs = new List<FFunctionDecl>();
    2951         for (FFunctionDecl func : getFFunctionDecls())
    2952             if (func.functionIsUsed())
    2953                 funcs.add(func);
    2954         setFFunctionDeclList(funcs);
    2955         List<FRecordDecl> records = new List<FRecordDecl>();
    2956         for (FRecordDecl decl : getFRecordDecls())
    2957             if (decl.isRecordUsed())
    2958                 records.add(decl);
    2959         setFRecordDeclList(records);
    2960         endStep("removeUnusedFunctionsAndRecords()");
    2961     }
    2962    
    2963     public class FFunctionDecl {
    2964         public enum UseType{
    2965             NONE(false, false),
    2966             ALIAS_ATTRIBUTE_USE(false, false),
    2967             ANNOTATION_DERIVATIVE(true, false),
    2968             DIRECT(true, true);
    2969            
    2970             private final boolean normalUse;
    2971             private final boolean derivativeUse;
    2972             UseType(boolean normalUse, boolean derivativeUse) {
    2973                 this.normalUse = normalUse;
    2974                 this.derivativeUse = derivativeUse;
    2975             }
    2976             public boolean normalUse() {
    2977                 return normalUse;
    2978             }
    2979             public boolean derivativeUse() {
    2980                 return derivativeUse;
    2981             }
    2982            
    2983             public UseType combine(UseType other) {
    2984                 return compareTo(other) > 0 ? this : other;
    2985             }
    2986         }
    2987     }
    2988    
    2989     private UseType FFunctionDecl.functionUsed = UseType.NONE;
    2990    
    2991     public void FFunctionDecl.resetUsedIndicator() {
    2992         functionUsed = UseType.NONE;
    2993     }
    2994    
    2995     /**
    2996      * Has this function been marked as used?
    2997      */
    2998     syn boolean FFunctionDecl.functionIsUsed() = functionUsed != UseType.NONE;
    2999    
    3000     /**
    3001      * Has this function been marked as used?
    3002      */
    3003     syn boolean FFunctionDecl.functionIsUsedAsDerivative() = functionUsed.derivativeUse();
    3004    
    3005     private boolean FRecordDecl.recordUsed = false;
    3006    
    3007     public void FRecordDecl.resetUsedIndicator() {
    3008         recordUsed = false;
    3009     }
    3010    
    3011     syn boolean FRecordDecl.isRecordUsed() = recordUsed;
    3012    
    3013     /**
    3014      * Mark all called functions as used.
    3015      */
    3016     public final void ASTNode.markUsedFunctionsAndRecords() {
    3017         markUsedFunctionsAndRecords(FFunctionDecl.UseType.DIRECT);
    3018     }
    3019     public void ASTNode.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3020         for (ASTNode node : this)
    3021             node.markUsedFunctionsAndRecords(type);
    3022     }
    3023    
    3024     @Override
    3025     public void FVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3026         AliasManager.AliasSet set = aliasSet();
    3027         if (type != FFunctionDecl.UseType.ALIAS_ATTRIBUTE_USE && set != null)
    3028             for (AliasManager.AliasVariable alias : set)
    3029                 if (alias.getFVariable() != this)
    3030                     alias.getFVariable().markUsedFunctionsAndRecords(FFunctionDecl.UseType.ALIAS_ATTRIBUTE_USE);
    3031         super.markUsedFunctionsAndRecords(type);
    3032     }
    3033    
    3034     public void FExternalObjectVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3035         super.markUsedFunctionsAndRecords(type);
    3036         getDestructorCall().markUsedFunctionsAndRecords(type);
    3037     }
    3038    
    3039     @Override
    3040     public void FFunctionCall.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3041         myFCallable().markUsedFunctionsAndRecords(type);
    3042         super.markUsedFunctionsAndRecords(type);
    3043     }
    3044    
    3045     public interface FCallable {
    3046         public void markUsedFunctionsAndRecords(FFunctionDecl.UseType type);
    3047     }
    3048    
    3049     @Override
    3050     public void FFunctionDecl.markUsedFunctionsAndRecords(UseType type) {
    3051         UseType oldType = functionUsed;
    3052         functionUsed = functionUsed.combine(type);
    3053         if (functionUsed != oldType) {
    3054             markUsedFunctionsAndRecordsExtra(type);
    3055             super.markUsedFunctionsAndRecords(functionUsed);
    3056         }
    3057     }
    3058    
    3059     public void FFunctionDecl.markUsedFunctionsAndRecordsExtra(UseType type) {
    3060         // Hook to facilitate extensions
    3061     }
    3062    
    3063     @Override
    3064     public void FFunctionVariable.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3065         super.markUsedFunctionsAndRecords(type);
    3066         if (type().isFunction()) {
    3067             myFCallable().markUsedFunctionsAndRecords(type);
    3068         }
    3069     }
    3070    
    3071     @Override
    3072     public void FType.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3073         super.markUsedFunctionsAndRecords(type);
    3074         getSize().markUsedFunctionsAndRecords(type);
    3075     }
    3076    
    3077     public void Size.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3078        
    3079     }
    3080    
    3081     @Override
    3082     public void MutableSize.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3083         for (FExp e : exps)
    3084             if (e != null)
    3085                 e.markUsedFunctionsAndRecords(type);
    3086     }
    3087    
    3088     @Override
    3089     public void FRecordType.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3090         super.markUsedFunctionsAndRecords(type);
    3091         myFRecordDecl().markUsedFunctionsAndRecords(type);
    3092     }
    3093    
    3094     @Override
    3095     public void FRecordConstructor.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3096         super.markUsedFunctionsAndRecords(type);
    3097         getRecord().myFRecordDecl().markUsedFunctionsAndRecords(type);
    3098     }
    3099    
    3100     @Override
    3101     public void FRecordDecl.markUsedFunctionsAndRecords(FFunctionDecl.UseType type) {
    3102         if (!recordUsed) {
    3103             recordUsed = true;
    3104             super.markUsedFunctionsAndRecords(type);
    3105         }
    3106     }
    3107    
    3108 }
  • branches/2.4.x/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/InlineFunctions.jrag

    r11572 r11573  
    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()) {
  • branches/2.4.x/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/Scalarization.jrag

    r11572 r11573  
    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);
  • branches/2.4.x/Compiler/ModelicaMiddleEnd/test/modelica/FunctionInlining.mo

    r11409 r11573  
    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;
     5022equation
     5023 x = 2.0;
     5024end FunctionInlining.GlobalConst1;
     5025")})));
     5026end GlobalConst1;
     5027
     5028model GlobalConst2
     5029    record R1
     5030        parameter Real x;
     5031    end R1;
     5032    record R2
     5033        parameter R1[2] r1;
     5034    end R2;
     5035    function f
     5036        input Integer i;
     5037        constant R2 a = R2({R1(2),R1(3)});
     5038        output R1 y = a.r1[i];
     5039    algorithm
     5040    end f;
     5041   
     5042    R1 y = f(integer(time));
     5043
     5044    annotation(__JModelica(UnitTesting(tests={
     5045        TransformCanonicalTestCase(
     5046            name="GlobalConst2",
     5047            description="Inlining global constant",
     5048            variability_propagation=false,
     5049            flatModel="
     5050fclass FunctionInlining.GlobalConst2
     5051 parameter Integer temp_2;
     5052 parameter Real y.x;
     5053parameter equation
     5054 temp_2 = integer(time);
     5055 y.x = ({2, 3})[temp_2];
     5056end FunctionInlining.GlobalConst2;
     5057")})));
     5058end GlobalConst2;
     5059
    50005060end FunctionInlining;
  • branches/2.4.x/Python/src/tests_jmodelica/files/Modelica/ExtFunctionTests.mo

    r11417 r11573  
    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 
     
    9951009end ExternalObjectTests3;
    9961010
     1011model MultiUse1
     1012    function f1
     1013        input Real x;
     1014        output Real y;
     1015        external "C" y = add(x,1) annotation(Library="addNumbers",
     1016                                           Include="#include \"addNumbers.h\"");
     1017    end f1;
     1018    function f2
     1019        input Real x;
     1020        output Real y;
     1021        external "C" y = add(x,2) annotation(Library="addNumbers",
     1022                                           Include="#include \"addNumbers.h\"");
     1023    end f2;
     1024   
     1025    Real y = f1(1) + f2(1);
     1026end MultiUse1;
     1027
    9971028end ExtFunctionTests;
  • branches/2.4.x/Python/src/tests_jmodelica/files/Modelica/FunctionTests.mo

    r10446 r11573  
    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;
  • branches/2.4.x/Python/src/tests_jmodelica/general/test_extfunctions.py

    r11417 r11573  
    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    '''
     
    737745        fmu_name = compile_fmu(cpath, self.fpath)
    738746       
     747class TestMultiUse:
     748    @classmethod
     749    def setUpClass(self):
     750        self.fpath = path(path_to_mofiles, "ExtFunctionTests.mo")
     751   
     752    @testattr(stddist_full = True)
     753    def testMultiUse1(self):
     754        cpath = "ExtFunctionTests.MultiUse1"
     755        fmu_name = compile_fmu(cpath, self.fpath)
     756        model = load_fmu(fmu_name)
     757        res = model.simulate()
     758        nose.tools.assert_equals(res.final('y'), 5.0)
  • branches/2.4.x/Python/src/tests_jmodelica/general/test_functions.py

    r10320 r11573  
    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)
  • branches/2.4.x/RuntimeLibrary/src

  • branches/2.4.x/RuntimeLibrary/src/jmi/jmi.c

    r11379 r11573  
    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);
  • branches/2.4.x/RuntimeLibrary/src/jmi/jmi.h

    r10866 r11573  
    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 */
  • branches/2.4.x/RuntimeLibrary/src/jmi/jmi_dyn_mem.h

    r10639 r11573  
    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/**
  • branches/2.4.x/RuntimeLibrary/src/jmi/jmi_me.c

    r11379 r11573  
    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.