Changeset 13896


Ignore:
Timestamp:
Oct 29, 2019 1:08:00 PM (2 weeks ago)
Author:
Jesper Mattsson
Message:

Catch-up merge from trunk. (#5835)

Location:
branches/dev-mj-5835
Files:
94 edited
14 copied

Legend:

Unmodified
Added
Removed
  • branches/dev-mj-5835

  • branches/dev-mj-5835/.project

    r5080 r13896  
    77    <buildSpec>
    88        <buildCommand>
    9             <name>org.python.pydev.PyDevBuilder</name>
    10             <arguments>
    11             </arguments>
    12         </buildCommand>
    13         <buildCommand>
    149            <name>org.eclipse.jdt.core.javabuilder</name>
    1510            <arguments>
     
    1914    <natures>
    2015        <nature>org.eclipse.jdt.core.javanature</nature>
    21         <nature>org.python.pydev.pythonNature</nature>
    2216    </natures>
    2317</projectDescription>
  • branches/dev-mj-5835/CHANGELOG.txt

    r13702 r13896  
    11================= Unreleased ==================
     2# Fixed ; Minor ; Compiler; #5864
     3Fixed bug where partial variability propagation lead to unbalanced equation systems.
     4
     5# Fixed ; Minor ; Compiler ; #5862
     6Fixed bug where empty array subscripts added during scalarization lead to c-compilation error.
     7
     8# Feature ; Minor ; Compiler; #5837
     9Added a pre-compiled evaluator used for evaluating external functions
     10during the compilation (for performance). Activated by the option
     11"external_constant_evaluation_dynamic"
     12
     13# Fixed ; Minor ; Compiler ; #5855
     14Nominal are now always positive in the FMI model description.
     15
     16# Fixed ; Minor ; Compiler; #5844
     17Improved attribute evaluation robustness for some cases. Parametric
     18attributes are now only generated in model description for inputs
     19and states.
     20
    221# Fixed ; Minor ; Compiler; #5835
    322Format string argument to the String function is now respected during constant evaluations.
  • branches/dev-mj-5835/Compiler/FmiXMLCodeGen/test/modelica/FmiXMLTests.mo

    r12934 r13896  
    25002500end Start5;
    25012501
     2502model ParametricAttributes1
     2503    parameter Real p = 1;
     2504    input Real x1(min=p, max=p, nominal=p);
     2505    Real x2(min=p, max=p, nominal=p);
     2506    output Real x3(min=p, max=p, nominal=p);
     2507equation
     2508    der(x2) = x1;
     2509    x3 = x2;
     2510
     2511    annotation(__JModelica(UnitTesting(tests={
     2512        FmiXMLCodeGenTestCase(
     2513            name="ParametricAttributes1",
     2514            description="",
     2515            fmi_version="2.0",
     2516            template="
     2517$modelVariables$
     2518",
     2519            generatedCode="
     2520<ModelVariables>
     2521    <!-- Variable with index #1 -->
     2522    <ScalarVariable name=\"p\" valueReference=\"0\" causality=\"parameter\" variability=\"fixed\" initial=\"exact\">
     2523        <Real relativeQuantity=\"false\" start=\"1.0\" />
     2524    </ScalarVariable>
     2525    <!-- Variable with index #2 -->
     2526    <ScalarVariable name=\"x1\" valueReference=\"3\" causality=\"input\" variability=\"continuous\">
     2527        <Real relativeQuantity=\"false\" min=\"1.0\" max=\"1.0\" nominal=\"1.0\" start=\"0.0\" />
     2528    </ScalarVariable>
     2529    <!-- Variable with index #3 -->
     2530    <ScalarVariable name=\"x2\" valueReference=\"2\" causality=\"local\" variability=\"continuous\" initial=\"calculated\">
     2531        <Real relativeQuantity=\"false\" min=\"1.0\" max=\"1.0\" nominal=\"1.0\" />
     2532    </ScalarVariable>
     2533    <!-- Variable with index #4 -->
     2534    <ScalarVariable name=\"der(x2)\" valueReference=\"1\" causality=\"local\" variability=\"continuous\" initial=\"calculated\">
     2535        <Real relativeQuantity=\"false\" derivative=\"3\" />
     2536    </ScalarVariable>
     2537    <!-- Variable with index #5 -->
     2538    <ScalarVariable name=\"x3\" valueReference=\"4\" causality=\"output\" variability=\"continuous\" initial=\"calculated\">
     2539        <Real relativeQuantity=\"false\" />
     2540    </ScalarVariable>
     2541</ModelVariables>
     2542")})));
     2543end ParametricAttributes1;
     2544
     2545
     2546model NegativeNominal1
     2547    Real x1(nominal=-1);   // Negative integer nominal
     2548    Real x2(nominal=-1.0); // Negative real nominal
     2549equation
     2550    x1 = time;
     2551    x2 = time;
     2552annotation(__JModelica(UnitTesting(tests={
     2553    FmiXMLCodeGenTestCase(
     2554        description="Nominals are always non-negative in FMI",
     2555        fmi_version="2.0",
     2556        template="
     2557$modelVariables$
     2558",      generatedCode="
     2559<ModelVariables>
     2560    <!-- Variable with index #1 -->
     2561    <ScalarVariable name=\"x1\" valueReference=\"0\" causality=\"local\" variability=\"continuous\" initial=\"calculated\">
     2562        <Real relativeQuantity=\"false\" nominal=\"1\" />
     2563    </ScalarVariable>
     2564    <!-- Variable with index #2 -->
     2565    <ScalarVariable name=\"x2\" valueReference=\"0\" causality=\"local\" variability=\"continuous\" initial=\"calculated\">
     2566        <Real relativeQuantity=\"false\" nominal=\"1.0\" />
     2567    </ScalarVariable>
     2568</ModelVariables>
     2569")})));
     2570end NegativeNominal1;
     2571
    25022572end FmiXMLTests;
  • branches/dev-mj-5835/Compiler/GenericCodeGen/src/jastadd/GenericXMLGenerator.jrag

    r11966 r13896  
    213213    protected void generateAttributeIfSet(String name, FVariable variable, CodeStream printer) {
    214214        if (variable.attributeSet(name)) {
    215             String value = variable.attributeCValue(name).xmlValue();
    216             generateAttribute(name, value, printer);
     215            FExp attributeExp = variable.attributeExp(name);
     216            if (attributeExp.variability().constantVariability() ||
     217                    variable.isInput() || variable.isDifferentiatedVariable()) {
     218                try {
     219                    CValue cvalue = attributeExp.ceval();
     220                    if (name.equals("nominal")) {
     221                        cvalue = cvalue.absoluteValue();
     222                    }
     223                    String value = cvalue.xmlValue();
     224                    generateAttribute(name, value, printer);
     225                } catch (ConstantEvaluationException e) {
     226                    throw new InternalCompilerError("Exception when generating xml attribute '" +
     227                        name + "' for variable '" + variable.name() + "'.", e);
     228                }
     229            }
    217230        }
    218231    }
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r13871 r13896  
    13901390    }
    13911391   
    1392     /**
    1393      * Generate the initialization of delay blocks.
    1394      */
    1395     public void FDelayExp.genInit_C(CodePrinter p, CodeStream str, String indent) {
    1396         FExp maxDelayExp = myMaxDelayExp();
     1392    private void FClass.genDelayInitVarDecls_C(CodePrinter p, CodeStream str, String indent) { // Hook to facilitate extensions
     1393        for (FDelayExp d : myDelayExps()) {
     1394            d.genInitVarDecls_C(p, str, indent);
     1395        }
     1396        for (FSpatialDistExp d : mySpatialDistExps()) {
     1397            d.genInitVarDecls_C(p, str, indent);
     1398        }
     1399    }
     1400
     1401    private void FClass.genDelayInitAssignments_C(CodePrinter p, CodeStream str, String indent) { // Hook to facilitate extensions
     1402        for (FDelayExp d : myDelayExps()) {
     1403            d.genInit_C(p, str, indent);
     1404        }
     1405        for (FSpatialDistExp d : mySpatialDistExps()) {
     1406            d.genInit_C(p, str, indent);
     1407        }
     1408    }
     1409   
     1410    public void FClass.genDelayInit_C(CodeStream genPrinter) {
     1411        CodePrinter p = ASTNode.printer_C;
     1412        String indent = p.indent("");
     1413        genDelayInitVarDecls_C(p, genPrinter, indent);
     1414        genDelayInitAssignments_C(p, genPrinter, indent);
     1415    }
     1416
     1417    private void FDelayExp.prepareInit_C(CodePrinter p, CodeStream str, String indent, int delayIndex) {
     1418        FExp maxDelayExp = myMaxDelayExp();
    13971419        boolean fixed = isTimeEventGenerating();
    1398         p.printPreSteps(getFExp(), str, indent);
     1420        p.printPreSteps(getFExp(), str, indent);
    13991421        p.printPreSteps(maxDelayExp, str, indent);
    1400        
    1401         str.format("%sjmi_delay_init(jmi, %d, ", indent, myDelayIndex());
     1422        str.format("%sjmi_delay_init(jmi, %d, ", indent, delayIndex);
    14021423        str.print(boolValue_C(fixed)); // jmi_boolean fixed
    14031424        str.print(", ");
     
    14051426        str.print(", ");
    14061427        p.print(fixed ? getDelay() : maxDelayExp, str, indent); // jmi_real_t max_delay
    1407         str.print(", ");
    1408         p.print(getFExp(), str, indent); // jmi_real_t y0
    1409         str.println(");");
    1410        
     1428        str.print(", ");
     1429
     1430    }
     1431
     1432    private void FDelayExp.finalizeInit_C(CodePrinter p, CodeStream str, String indent) {
     1433        str.println(");");
    14111434        p.printPostSteps(getFExp(), str, indent);
    1412         p.printPostSteps(maxDelayExp, str, indent);
     1435        p.printPostSteps(myMaxDelayExp(), str, indent);
     1436    }
     1437   
     1438    /**
     1439     * Generate the initialization of delay blocks.
     1440     */
     1441    public void FDelayExp.genInit_C(CodePrinter p, CodeStream str, String indent) {
     1442        prepareInit_C(p, str, indent, myDelayIndex());
     1443        p.print(getFExp(), str, indent); // jmi_real_t y0
     1444        finalizeInit_C(p, str, indent);
    14131445    }
    14141446    syn FExp FDelayExp.myMaxDelayExp() = hasMax() ? getMax() : getDelay();
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternalCeval.jrag

    r12306 r13896  
    248248        Collection<ExternalArgument> res = new LinkedHashSet<>();
    249249        if (hasReturnVar()) {
    250             res.add(getReturnVar().externalArgument());
    251         }
     250            res.add(returnVarToSerialize());
     251        }
     252        res.addAll(argVarsToSerialize());
     253        return res;
     254    }
     255   
     256    syn ExternalArgument FExternalStmt.returnVarToSerialize() = getReturnVar().externalArgument();
     257    syn Collection<ExternalArgument> FExternalStmt.argVarsToSerialize() {
     258        Collection<ExternalArgument> res = new LinkedHashSet<>();
    252259        for (FExp e : getArgs()) {
    253260            res.add(e.externalArgument());
     
    288295        }
    289296        return functionArgs;
     297    }
     298   
     299
     300    syn String FType.cMappedTypeString() = cMappedTypeStringScalar() + (isArray() ? "v" : "");
     301
     302    syn String FType.cMappedTypeStringScalar() {
     303        throw new InternalCompilerError("cMappedTypeStringScalar() is not supported for class type " + getClass().getSimpleName());
     304    }
     305    eq FArrayType.cMappedTypeStringScalar() = getFPrimitiveType().cMappedTypeStringScalar();
     306    eq FIntegerType.cMappedTypeStringScalar() = "i";
     307    eq FEnumType.cMappedTypeStringScalar() = "i";
     308    eq FBooleanType.cMappedTypeStringScalar() = "i";
     309    eq FRealType.cMappedTypeStringScalar() = "d";
     310    eq FStringType.cMappedTypeStringScalar() = "s";
     311    eq FRecordType.cMappedTypeStringScalar() {
     312        String o = "R[";
     313        for (FRecordComponentType rType: getComponents()) {
     314                o = o.concat(rType.getFType().cMappedTypeStringScalar());
     315                o = o.concat(",");
     316        }
     317        return o.concat("]");
     318    }
     319   
     320    syn String FExternalStmt.functionReturnArgSerialized() {
     321        if (hasReturnVar()) {
     322            return returnVarToSerialize().type().cMappedTypeString();
     323        } else {
     324            return "void";
     325        }
     326    }
     327   
     328    syn String FExternalStmt.functionArgsSerialized() {
     329        String input = "";
     330        for (ExternalArgument var : argVarsToSerialize()) {
     331            if (var.isOutput()) {
     332               input = input.concat("*");
     333            }
     334            input += var.type().cMappedTypeString() + ",";
     335        }
     336        return input;
    290337    }
    291338   
     
    347394            }
    348395        }
     396    }
     397   
     398    public String FClass.externalCTypes() {
     399        StringBuilder sb = new StringBuilder();
     400        for (FExternalStmt stmt : myExternals()) {
     401            if (stmt.dynamicEvaluatorEnabled()) {
     402                sb.append(stmt.getName());
     403                sb.append("\n");
     404                sb.append(stmt.functionReturnArgSerialized());
     405                sb.append("\n");
     406                sb.append(stmt.functionArgsSerialized());
     407                sb.append("\n");
     408            }
     409        }
     410        return sb.toString();
    349411    }
    350412
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenFunctionIO.jrag

    r11676 r13896  
    1616
    1717aspect CCodeGenFunctionIO {
    18    
    19     public class CPrettyPrinter {
    20         @Override
    21         public void printIODecl(FExp n, CodeStream str, String indent) {
    22             n.genTempInputDecl_C(this, str, indent);
    23         }
    24         @Override
    25         public void printIOPre(FExp n, CodeStream str, String indent) {
    26             n.genTempInputAssigns_C(this, str, indent);
    27         }
    28         @Override
    29         public void printIOExec(FExp n, CodeStream str, String indent) {
    30             n.genArgument(ExecStep, str, indent);
    31         }
    32     }
    3318   
    3419    syn boolean FAccessExp.alsoInRHS() {
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CGenerator.jrag

    r12423 r13896  
    2121
    2222import java.io.*;
     23
     24aspect CGenerator {
    2325
    2426public class CGenerator extends GenericGenerator {
     
    12461248       
    12471249        public void generate(CodeStream genPrinter) {
    1248             genPrinter.print(fclass.myDelayExps().size());
     1250            genPrinter.print(fclass.numberOfDelaysInCCode());
    12491251        }
    12501252    }
     
    13041306       
    13051307        public void generate(CodeStream genPrinter) {
    1306             CodePrinter p = ASTNode.printer_C;
    1307             String indent = p.indent("");
    1308             for (FDelayExp d : fclass.myDelayExps()) {
    1309                 d.genInitVarDecls_C(p, genPrinter, indent);
    1310             }
    1311             for (FSpatialDistExp d : fclass.mySpatialDistExps()) {
    1312                 d.genInitVarDecls_C(p, genPrinter, indent);
    1313             }
    1314             for (FDelayExp d : fclass.myDelayExps()) {
    1315                 d.genInit_C(p, genPrinter, indent);
    1316             }
    1317             for (FSpatialDistExp d : fclass.mySpatialDistExps()) {
    1318                 d.genInit_C(p, genPrinter, indent);
    1319             }
     1308            fclass.genDelayInit_C(genPrinter);
    13201309        }
    13211310    }
     
    15781567    }
    15791568}
     1569
     1570    syn int FClass.numberOfDelaysInCCode() = myDelayExps().size(); // Hook to facilitate extensions
     1571}
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/src/jastadd/CodeGen/StepPrinter.jrag

    r12024 r13896  
    140140   
    141141    public abstract class CodePrinter {
    142         public abstract void printIODecl(FExp n, CodeStream str, String indent);
    143         public abstract void printIOPre(FExp n, CodeStream str, String indent);
    144         public abstract void printIOExec(FExp n, CodeStream str, String indent);
     142        public void printIODecl(FExp n, CodeStream str, String indent) {
     143            n.genTempInputDecl_C(this, str, indent);
     144        }
     145        public void printIOPre(FExp n, CodeStream str, String indent) {
     146            n.genTempInputAssigns_C(this, str, indent);
     147        }
     148        public void printIOExec(FExp n, CodeStream str, String indent) {
     149            n.genArgument(ExecStep, str, indent);
     150        }
    145151    }
    146152   
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/templates/ceval_external_template.c

    r11746 r13896  
    1414*/
    1515
    16 #include <stdio.h>
    17 #include <stdlib.h>
    18 #include <string.h>
    19 #include "jmi.h"
    20 #include "jmi_dyn_mem.h"
    21 #include "ModelicaUtilities.h"
    22 #include <fcntl.h>
     16#include "jmi_evaluator_util.h"
     17
     18/* Must be defined here in order to override the methods from jmi_global.c */
     19void jmi_global_log(int warning, const char* name, const char* fmt, const char* value) {
     20    _jmi_global_log(warning, name, fmt, value);
     21}
     22void jmi_throw() {
     23    _jmi_throw();
     24}
     25void* jmi_global_calloc(size_t n, size_t s) {
     26    return _jmi_global_calloc(n,s);
     27}
    2328
    2429$ECE_external_includes$
    2530 
    26 /* Manual debugging */
    27 #define JMCEVAL_DEBUG 0
    28 #define JMCEVAL_DBGP(x) if (JMCEVAL_DEBUG) { printf(x); fflush(stdout);}
    29 
    30 /* Format specifier when printing jmi_real_t */
    31 #define JMCEVAL_realFormat "%.16f"
    32 
    3331/* Used record definitions */
    3432$ECE_record_definitions$
    35 
    36 /* Parses ND dimensions into dimension buffer d*/
    37 #define JMCEVAL_parseArrayDims(ND) \
    38     for (di = 0; di < ND; di++) { scanf("%d",&d[di]); }
    39 
    40 /* Parse/print basic types */
    41 double JMCEVAL_parseReal() {
    42     /* Char buffer when reading jmi_real_t. This is necessary
    43        since "%lf" is not allowed in c89. */
    44     char buff[32];
    45     JMCEVAL_DBGP("Parse number: ");
    46     scanf("%s",buff);
    47     return strtod(buff, 0);
    48 }
    49 
    50 void JMCEVAL_printReal(double x) {
    51     printf(JMCEVAL_realFormat, x); \
    52     printf("\n"); \
    53     fflush(stdout); \
    54 }
    55 
    56 char* JMCEVAL_parseString() {
    57     int d[1];
    58     char* str;
    59     size_t si,di;
    60     JMCEVAL_parseArrayDims(1);
    61     getchar();
    62     str = ModelicaAllocateString(d[0]);
    63     JMCEVAL_DBGP("Parse string: ");
    64     for (si = 0; si < d[0]; si++) str[si] = getchar();
    65     str[d[0]] = '\0';
    66     return str;
    67 }
    68 
    69 void JMCEVAL_printString(const char* str) {
    70     printf("%u\n%s\n", (unsigned)strlen(str), str);
    71     fflush(stdout);
    72 }
    73 
    74 #define JMCEVAL_parseInteger()  JMCEVAL_parseReal()
    75 #define JMCEVAL_parseBoolean()  JMCEVAL_parseInteger()
    76 #define JMCEVAL_parseEnum()     JMCEVAL_parseInteger()
    77 #define JMCEVAL_printInteger(X) JMCEVAL_printReal(X)
    78 #define JMCEVAL_printBoolean(X) JMCEVAL_printInteger(X)
    79 #define JMCEVAL_printEnum(X)    JMCEVAL_printInteger(X)
    80 #define JMCEVAL_parse(TYPE, X)  X = JMCEVAL_parse##TYPE()
    81 #define JMCEVAL_print(TYPE, X)  JMCEVAL_print##TYPE(X)
    82 
    83 /* Parse/print arrays */
    84 #define JMCEVAL_parseArray(TYPE,ARR) for (vi = 1; vi <= ARR->num_elems; vi++) { JMCEVAL_parse(TYPE, jmi_array_ref_1(ARR,vi)); }
    85 #define JMCEVAL_printArray(TYPE,ARR) for (vi = 1; vi <= ARR->num_elems; vi++) { JMCEVAL_print(TYPE, jmi_array_val_1(ARR,vi)); }
    86 
    87 /* Used by ModelicaUtilities */
    88 void jmi_global_log(int warning, const char* name, const char* fmt, const char* value)
    89 {
    90     printf("LOG\n");
    91     JMCEVAL_printInteger((double)warning);
    92     JMCEVAL_printString(name);
    93     JMCEVAL_printString(fmt);
    94     JMCEVAL_printString(value);
    95 }
    96 
    97 jmp_buf jmceval_try_location;
    98 
    99 #define JMCEVAL_try() (setjmp(jmceval_try_location) == 0)
    100 
    101 void jmi_throw()
    102 {
    103     longjmp(jmceval_try_location, 1);
    104 }
    105 
    106 jmi_dynamic_function_memory_t* dyn_fcn_mem = NULL;
    107 
    108 jmi_dynamic_function_memory_t* jmi_dynamic_function_memory() {
    109     if (dyn_fcn_mem == NULL) { dyn_fcn_mem = jmi_dynamic_function_pool_create(1024*1024); }
    110     return dyn_fcn_mem;
    111 }
    112 
    113 void* jmi_global_calloc(size_t n, size_t s)
    114 {
    115     return jmi_dynamic_function_pool_direct_alloc(dyn_fcn_mem, n*s, 1);
    116 }
    117 
    118 void JMCEVAL_setup() {
    119 #ifdef _WIN32
    120     /* Prevent win from translating \n to \r\n */
    121     _setmode(fileno(stdout), _O_BINARY);
    122 #endif
    123 }
    124 
    125 int JMCEVAL_cont(const char* word) {
    126     char l[10];
    127     char* s = fgets(l, 10, stdin);
    128     if (strlen(s) == 1) {
    129         s = fgets(l, 10, stdin); /* Extra call to fix stray newline */
    130     }
    131     if (s == NULL) {
    132         exit(2);
    133     }
    134     if (strlen(s) == strlen(word)) {
    135         return strncmp(l, word, strlen(word)) == 0;
    136     }
    137     return 0;
    138 }
    139 
    140 void JMCEVAL_check(const char* str) {
    141     printf("%s\n",str);
    142     fflush(stdout);
    143 }
    144 
    145 void JMCEVAL_failed() {
    146     JMCEVAL_check("ABORT");
    147 }
    14833
    14934/* Main */
     
    19580        JMCEVAL_failed();
    19681    }
    197     jmi_dynamic_function_pool_destroy(dyn_fcn_mem);
     82    _jmi_dynamic_function_pool_destroy();
    19883    JMCEVAL_check("END");
    19984    return 0;
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenArrayTests.mo

    r12857 r13896  
    941941end RecordArray13;
    942942
     943model RecordArray14
     944    record R
     945        Real x = 1;
     946    end R;
     947   
     948    function f
     949        input Integer n;
     950        Real[n] xs;
     951        R[n] rs;
     952        output Real y;
     953    algorithm
     954        xs := rs.x;
     955        y := sum(xs);
     956        annotation(Inline=false);
     957    end f;
     958
     959    Real y = f(integer(time));
     960   
     961annotation(__JModelica(UnitTesting(tests={
     962    CCodeGenTestCase(
     963        name="RecordArray14",
     964        description="Test for bug in #5862",
     965        template="$C_functions$",
     966        generatedCode="
     967void func_CCodeGenArrayTests_RecordArray14_f_def0(jmi_real_t n_v, jmi_real_t* y_o) {
     968    JMI_DYNAMIC_INIT()
     969    JMI_ARR(HEAP, jmi_real_t, jmi_array_t, xs_a, -1, 1)
     970    JMI_ARR(HEAP, R_0_r, R_0_ra, rs_a, -1, 1)
     971    JMI_DEF(REA, tmp_1)
     972    JMI_DEF(REA, tmp_1_max)
     973    JMI_DEF(REA, y_v)
     974    JMI_DEF(REA, temp_1_v)
     975    jmi_real_t i1_0i;
     976    jmi_int_t i1_0ie;
     977    jmi_int_t i1_0in;
     978    jmi_real_t i1_1i;
     979    jmi_int_t i1_1ie;
     980    jmi_int_t i1_1in;
     981    jmi_real_t i1_2i;
     982    jmi_int_t i1_2ie;
     983    jmi_int_t i1_2in;
     984    JMI_ARRAY_INIT_1(HEAP, jmi_real_t, jmi_array_t, xs_a, n_v, 1, n_v)
     985    JMI_ARRAY_INIT_1(HEAP, R_0_r, R_0_ra, rs_a, n_v, 1, n_v)
     986    tmp_1_max = n_v + 1;
     987    for (tmp_1 = 1; tmp_1 < tmp_1_max; tmp_1++) {
     988    }
     989    i1_0in = 0;
     990    i1_0ie = floor((n_v) - (1));
     991    for (i1_0i = 1; i1_0in <= i1_0ie; i1_0i = 1 + (++i1_0in)) {
     992        jmi_array_rec_1(rs_a, i1_0i)->x = 1;
     993    }
     994    i1_1in = 0;
     995    i1_1ie = floor((n_v) - (1));
     996    for (i1_1i = 1; i1_1in <= i1_1ie; i1_1i = 1 + (++i1_1in)) {
     997        jmi_array_ref_1(xs_a, i1_1i) = jmi_array_rec_1(rs_a, i1_1i)->x;
     998    }
     999    temp_1_v = 0.0;
     1000    i1_2in = 0;
     1001    i1_2ie = floor((n_v) - (1));
     1002    for (i1_2i = 1; i1_2in <= i1_2ie; i1_2i = 1 + (++i1_2in)) {
     1003        temp_1_v = temp_1_v + jmi_array_val_1(xs_a, i1_2i);
     1004    }
     1005    y_v = temp_1_v;
     1006    JMI_RET(GEN, y_o, y_v)
     1007    JMI_DYNAMIC_FREE()
     1008    return;
     1009}
     1010
     1011jmi_real_t func_CCodeGenArrayTests_RecordArray14_f_exp0(jmi_real_t n_v) {
     1012    JMI_DEF(REA, y_v)
     1013    func_CCodeGenArrayTests_RecordArray14_f_def0(n_v, &y_v);
     1014    return y_v;
     1015}
     1016")})));
     1017end RecordArray14;
     1018
    9431019end CCodeGenArrayTests;
  • branches/dev-mj-5835/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalCevalTests.mo

    r13491 r13896  
    1717
    1818package CCodeGenExternalCevalTests
     19
     20model ExtDynFcn1
     21        type E = enumeration(A,B);
     22    function f
     23        input Real a1;
     24        input Integer a2;
     25        input Boolean a3;
     26        input String a4;
     27        input E a5;
     28        output Real b1;
     29        output Integer b2;
     30        output Boolean b3;
     31        output String b4;
     32        output E b5;
     33        external;
     34    end f;
     35   
     36    Real x1;
     37    Integer x2;
     38    Boolean x3;
     39    String x4;
     40    E x5;
     41equation
     42    (x1,x2,x3,x4,x5) = f(1,2,true,"s",E.A);
     43
     44    annotation(__JModelica(UnitTesting(tests={
     45        FClassMethodTestCase(
     46            name="ExtDynFcn1",
     47            methodName="externalCTypes",
     48            description="Test that the different primitive types generates the correct C mapping",
     49            external_constant_evaluation_dynamic=true,
     50            methodResult="
     51f
     52void
     53d,i,i,s,i,*d,*i,*i,*s,*i,
     54")})));
     55end ExtDynFcn1;
     56
     57model ExtDynFcn2
     58type E = enumeration(A,B);
     59function f
     60    input Real[:] a1;
     61    input Integer[:] a2;
     62    input Boolean[:] a3;
     63    input String[:] a4;
     64    input E[:] a5;
     65    output Real[size(a1,1)] b1;
     66    output Integer[size(a2,1)] b2;
     67    output Boolean[size(a3,1)] b3;
     68    output String[size(a4,1)] b4;
     69    output E[size(a5,1)] b5;
     70    external;
     71end f;
     72    Real[1] x1;
     73    Integer[1] x2;
     74    Boolean[1] x3;
     75    String[1] x4;
     76    E[1] x5;
     77equation
     78    (x1,x2,x3,x4,x5) = f({1},{2},{true},{"s"},{E.A});
     79
     80    annotation(__JModelica(UnitTesting(tests={
     81        FClassMethodTestCase(
     82            name="ExtDynFcn2",
     83            methodName="externalCTypes",
     84            description="Test that the different primitive types (arrays of) generates the correct C mapping",
     85            external_constant_evaluation_dynamic=true,
     86            methodResult="
     87f
     88void
     89dv,i,iv,i,iv,i,sv,i,iv,i,*dv,i,*iv,i,*iv,i,*sv,i,*iv,i,
     90")})));
     91end ExtDynFcn2;
     92
     93model ExtDynFcn3
     94    type E = enumeration(A,B);
     95    record R
     96        Real a1;
     97        Integer a2;
     98        Boolean a3;
     99        String a4;
     100        E a5;
     101        R2 r2;
     102    end R;
     103    record R2
     104        Real x;
     105    end R2;
     106   
     107    function f
     108        input R a;
     109        output R b;
     110        external f(a,b);
     111    end f;
     112   
     113    R r = f(R(1,2,true,"s",E.A, R2(3)));
     114
     115    annotation(__JModelica(UnitTesting(tests={
     116        FClassMethodTestCase(
     117            name="ExtDynFcn3",
     118            methodName="externalCTypes",
     119            description="Test that records generates the correct C mapping",
     120            external_constant_evaluation_dynamic=true,
     121            methodResult="
     122f
     123void
     124R[d,i,i,s,i,R[d,],],*R[d,i,i,s,i,R[d,],],
     125")})));
     126end ExtDynFcn3;
     127
    19128
    20129model Scalar
     
    789898end ExtObj5;
    790899
     900model ExtDynObj1
     901    function use1
     902        input  Os.Obj1 o1;
     903        output Real x;
     904        external annotation(Library="extObjectsUse", Include="#include \"extObjectsUse.h\"",
     905            LibraryDirectory="modelica://Library2", IncludeDirectory="Include2");
     906    end use1;
     907
     908    Os.Obj1 o1 = Os.Obj1(3.13, 3, true, "A message");
     909    Real x = use1(o1);
     910
     911    annotation(__JModelica(UnitTesting(tests={
     912        FClassMethodTestCase(
     913            name="ExtDynObj1",
     914            methodName="externalCTypes",
     915            description="Verifies that external objects are not handled by the dynamic evaluator",
     916            methodResult="
     917")})));
     918end ExtDynObj1;
     919
     920
    791921model Dgelsx
    792922    function dgelsx
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/module.options

    r12895 r13896  
    136136external objects during compilation.If less than 1, no processes will be kept
    137137alive, i.e. this feature is turned off."
     138
     139********************************************************************************
     140BOOLEAN external_constant_evaluation_dynamic compiler experimental false
     141
     142"If enabled, calls to external functions will be evaluated during compilation
     143using a pre-compiled program (instead of generating and compiling one), if
     144possible."
    138145
    139146********************************************************************************
     
    458465
    459466********************************************************************************
    460 
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/runtime.options

    r11347 r13896  
    221221"Compares the analytic block jacobians with the finite difference block
    222222jacobians during block evaluation. An error is given if the relative error is
    223 to big."
     223too big."
    224224
    225225********************************************************************************
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/src/jastadd/DebugCompiler.jrag

    r11966 r13896  
    130130                mc.setLogger(out);
    131131                ModelicaCompiler.TargetObject targ = (ModelicaCompiler.TargetObject) target.getSelectedItem();
    132                 mc.compileModel(new String[] { file.getAbsolutePath() }, name, targ, null, null);
     132                mc.compileModel(new String[] { file.getAbsolutePath() }, name, targ, null);
    133133            } catch (Exception ex) {
    134134                out.writeException(ex);
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r13396 r13896  
    348348            hooks.packFmu(this, fc, dir);
    349349        }
    350         fc.root().getUtilInterface().packFmu(fc);
     350        fc.root().getUtilInterface().packFmu(fc, dir.toPath());
    351351    }
    352352   
     
    358358            hooks.fmuPacked(this, fc, path);
    359359        }
    360         fc.root().getUtilInterface().fmuPacked(fc, path);
     360        fc.root().getUtilInterface().fmuPacked(fc, path.toPath());
    361361    }
    362362   
     
    811811             * Compile mo-file and generate code for all templates that are not null.
    812812             */
    813             String flatName = null;
    814             if (!Files.isDirectory(compileTo)) {
    815                 flatName = compileTo.getFileName().toString();
    816                 int i = flatName.lastIndexOf('.');
    817                 if (i > 0) {
    818                     flatName = flatName.substring(0, i);
    819                 }
    820             }
    821             FClass fc = compileModel(fileName, className, target, flatName, compileTo);
     813            FClass fc = compileModel(fileName, className, target, compileTo);
    822814
    823815            if (!target.getCodeGenFlag()) {
     
    832824             */
    833825            hookCheckAbort();
    834             doCompileCCode(target, fc, className, flatName);
     826            doCompileCCode(target, fc);
    835827
    836828            /*
     
    838830             */
    839831            ASTNode.beginStep("packUnit()");
    840             File unitPath = packUnit(className, target, fc);
     832            Path unitPath = packUnit(className, target, fc);
    841833            unit = log.logCompiledUnit(unitPath, warnings, fc.numberOfComponents());
    842834            ASTNode.endStep("packUnit()");
     
    12661258        /* Temporary fix to problems with long compilation times due to later evaluations */
    12671259        getExternalFunctionCache().tearDown();
    1268         options.setIntegerOption("external_constant_evaluation", 0);
     1260        options.external_constant_evaluation.setValue(0);
    12691261       
    12701262        hookModelTransformed(fc);
     
    13691361        ASTNode.beginStep("generateCode()");
    13701362        log.info("Generating code...");
     1363       
    13711364        String name = fc.nameUnderscore();
    1372        
    13731365        Templates templates = target.getTemplates(getOptions());
    1374    
    1375         templates.generateCFiles(this, fc, createCGenerator(fc), sourceDir, name);
    1376         templates.generateXMLFiles(this, fc, target.getXMLGenerator(fc), outDir, "modelDescription");
     1366       
     1367        generateAllFiles(fc, target, templates, name);
    13771368        hookCodeGenerated(fc, outDir);
    13781369       
     
    19601951     * @param target
    19611952     *            The target object for the compiler.
    1962      * @param flatName
    1963      *            Name of the unit/flat model supplied by the user, if any.
    19641953     *
    19651954     * @return A flat representation of the class specified by <code>cl</code>.
     
    19831972     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
    19841973     */
    1985     public FClass ModelicaCompiler.compileModel(String files[], String cl, TargetObject target, String flatName, String compileTo)
     1974    public FClass ModelicaCompiler.compileModel(String files[], String cl, TargetObject target, String compileTo)
    19861975          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    1987         return compileModel(stringsToPaths(files), cl, target, flatName, compileTo == null ? null : Paths.get(compileTo));
     1976        return compileModel(stringsToPaths(files), cl, target, compileTo == null ? null : Paths.get(compileTo));
    19881977    }
    19891978   
     
    19991988     * @param target
    20001989     *            The target object for the compiler.
    2001      * @param flatName
    2002      *            Name of the unit/flat model supplied by the user, if any.
    20031990     *
    20041991     * @return A flat representation of the class specified by <code>cl</code>.
     
    20222009     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
    20232010     */
    2024      public FClass ModelicaCompiler.compileModel(Path files[], String cl, TargetObject target, String flatName, Path compileTo)
     2011     public FClass ModelicaCompiler.compileModel(Path files[], String cl, TargetObject target, Path compileTo)
    20252012          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    20262013        boolean doTearDown = true;
    20272014        try {
    20282015            doTearDown = trySetUp();
    2029             return doCompileModel(files, cl, target, flatName, compileTo);
     2016            return doCompileModel(files, cl, target, compileTo);
    20302017        } finally {
    20312018            tryTearDown(doTearDown);
     
    20332020    }
    20342021   
    2035     public FClass ModelicaCompiler.doCompileModel(String name[], String cl, TargetObject target, String flatName, String compileTo)
    2036           throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    2037         return doCompileModel(stringsToPaths(name), cl, target, flatName, compileTo == null ? null : Paths.get(compileTo));
    2038     }
    2039    
    2040    
    2041     public FClass ModelicaCompiler.doCompileModel(Path name[], String cl, TargetObject target, String flatName, Path compileTo)
     2022   
     2023    public FClass ModelicaCompiler.doCompileModel(Path name[], String cl, TargetObject target, Path compileTo)
    20422024          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    20432025        if (target.equals(TargetObject.PARSE)) {
     
    20622044            // compute instance tree
    20632045            InstClassDecl icl = instantiateModel(name, cl, target);
    2064            
     2046            UtilInterface util = icl.root().getUtilInterface();
     2047            String flatName = null;
    20652048            if (compileTo != null) {
    2066                 File unitFile = makePackagingDirs(cl, compileTo.toFile(), target);
    2067                 icl.root().getUtilInterface().setCompilationOutputPath(unitFile);
     2049                Path unitFile = makePackagingDirs(cl, compileTo, target);
     2050                util.setCompilationOutputPath(unitFile);
     2051                flatName = computeFlatName(compileTo, util);
    20682052            }
    20692053           
     
    22072191     * Packs an FMU (helper function for {@link #compileUnit()}).
    22082192     */
    2209     protected File ModelicaCompiler.packUnit(String className,
     2193    protected Path ModelicaCompiler.packUnit(String className,
    22102194            TargetObject target, FClass fClass) throws PackingFailedException {
    2211 
    2212         File unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
    2213 
     2195        Path unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
     2196       
    22142197        hookPackFmu(fClass, outDir);
     2198        hookCheckAbort();
     2199        packUnit(className, target, fClass, unitFile);
     2200        hookFmuPacked(fClass, unitFile.toAbsolutePath().toFile());
     2201       
     2202        return unitFile;
     2203    }
     2204   
     2205    private void ModelicaCompiler.packUnit(String className, TargetObject target, FClass fClass, Path unitFile) {
    22152206        try {
    2216             hookCheckAbort();
    22172207            copySourceFiles(fClass, sourceDir, outDir);
    2218 
    2219             OutputStream dest = new BufferedOutputStream(new FileOutputStream(unitFile));
    2220             ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest));
    2221             out.setMethod(ZipOutputStream.DEFLATED);
    2222 
    2223             zipDir(outDir, out);
    2224             out.close();
    2225         } catch (CompilationAbortedException e) {
    2226             throw e;
     2208            try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(unitFile)))) {
     2209                out.setMethod(ZipOutputStream.DEFLATED);
     2210                zipDir(outDir, out);
     2211            }
    22272212        } catch (Exception e) {
    22282213            throw new PackingFailedException(String.format("Could not write to '%s'.", unitFile), e);
    22292214        }
    2230 
    2231         hookFmuPacked(fClass, unitFile.getAbsoluteFile());
    2232         return unitFile;
    22332215    }
    22342216
     
    22482230    }
    22492231
    2250     private void ModelicaCompiler.doCompileCCode(TargetObject target,  FClass fc, String className, String flatName) {
     2232    private void ModelicaCompiler.doCompileCCode(TargetObject target,  FClass fc) {
    22512233        if (target.getMakeFileFlag() != null) {
    22522234                ASTNode.beginStep("compileCCode()");
    2253                 String cFileName = (flatName != null) ? flatName : FClass.convertClassNameToUnderscore(className);
     2235                String cFileName = fc.nameUnderscore();
    22542236                CCompilerDelegator ccompiler = getCCompiler();
    22552237                CCompilerArguments ccArgs = new CCompilerArguments(cFileName, fc.myOptions(), target, fc.externalLibraries(), fc.externalLibraryDirectories(),
     
    22642246    /**
    22652247     * Calculates the destination directory for a packaged unit. If the specified destination is a file its directory
    2266      * is chosen as destination. If the destination does not exist, it is created (using {@link File#mkdirs()}).
     2248     * is chosen as destination. If the destination does not exist, it is created (using {@link Filed#createDirectories()}).
    22672249     *
    22682250     * @param className
     
    22732255     *          A {@link TargetObject} containing information about the target.
    22742256     * @return
    2275      *          the path to the destination directory of the packaged unit.
     2257     *          the path to the destination file of the packaged unit.
    22762258     */
    2277     private File ModelicaCompiler.makePackagingDirs(String className, File destination, TargetObject target) {
    2278         File dest = new File(destination.getAbsolutePath());
    2279         if (dest.isDirectory()) {
     2259    private Path ModelicaCompiler.makePackagingDirs(String className, Path destination, TargetObject target)
     2260            throws IOException {
     2261        Path dest = destination.toAbsolutePath();
     2262        if (Files.isDirectory(dest)) {
    22802263            String mangledName = FClass.convertClassNameToUnderscore(className);
    2281             dest = new File(dest, mangledName + "." + target.getUnitSuffix());
     2264            dest = dest.resolve(mangledName + "." + target.getUnitSuffix());
    22822265        } else {
    2283             File destDir = dest.getParentFile();
    2284             if (destDir != null && !destDir.isDirectory()) {
    2285                 dest.getParentFile().mkdirs();
     2266            Path destDir = dest.getParent();
     2267            if (destDir != null && !Files.isDirectory(destDir)) {
     2268                Files.createDirectories(dest.getParent());
    22862269            }
    22872270        }
    22882271        return dest;
     2272    }
     2273   
     2274    private void ModelicaCompiler.generateAllFiles(FClass fc, TargetObject target, Templates templates, String name)
     2275            throws FileNotFoundException {
     2276        templates.generateCFiles(this, fc, createCGenerator(fc), sourceDir, name);
     2277        templates.generateXMLFiles(this, fc, target.getXMLGenerator(fc), outDir, "modelDescription");
     2278    }
     2279   
     2280    private String ModelicaCompiler.computeFlatName(Path compileTo, UtilInterface util) {
     2281        String flatName = null;
     2282        if (!Files.isDirectory(compileTo)) {
     2283            flatName = compileTo.getFileName().toString();
     2284            int i = flatName.lastIndexOf('.');
     2285            if (i > 0) {
     2286                flatName = flatName.substring(0, i);
     2287            }
     2288        }
     2289        return flatName;
    22892290    }
    22902291
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag

    r13396 r13896  
    4141             * Called after code has been compiled.
    4242             */
    43             public void packFmu(FClass fc) {}
     43            public void packFmu(FClass fc, Path outDir) {}
    4444           
    4545            /**
    4646             * Called after code has been compiled.
    4747             */
    48             public void fmuPacked(FClass fc, File path) {}
     48            public void fmuPacked(FClass fc, Path outDir) {}
    4949           
    5050            /**
     
    7272        private ExternalFunctionCache efc;
    7373        private GUIDManager guidManager;
    74         private File compilationOutputPath;
     74        private Path compilationOutputPath;
    7575       
    76         protected UtilInterface(ModelicaCompiler mc, OptionRegistry options, IErrorHandler eh, ExternalFunctionCache efc, File compilationOutputPath) {
     76        protected UtilInterface(ModelicaCompiler mc, OptionRegistry options, IErrorHandler eh, ExternalFunctionCache efc, Path compilationOutputPath) {
    7777            this.mc = mc;
    7878            this.options = options;
     
    110110        }
    111111       
    112         public File getCompilationOutputPath() {
     112        public Path getCompilationOutputPath() {
    113113            return compilationOutputPath;
    114114        }
    115115       
    116         public void setCompilationOutputPath(File compilationOutputPath) {
     116        public void setCompilationOutputPath(Path compilationOutputPath) {
    117117            this.compilationOutputPath = compilationOutputPath;
    118118        }
     
    146146    }
    147147   
    148     public void UtilInterface.packFmu(FClass fc) {
     148    public void UtilInterface.packFmu(FClass fc, Path outDir) {
    149149        for (Interfacer interfacer : interfacers) {
    150             interfacer.packFmu(fc);
     150            interfacer.packFmu(fc, outDir);
    151151        }
    152152    }
    153153   
    154     public void UtilInterface.fmuPacked(FClass fc, File path) {
     154    public void UtilInterface.fmuPacked(FClass fc, Path outDir) {
    155155        for (Interfacer interfacer : interfacers) {
    156             interfacer.fmuPacked(fc, path);
     156            interfacer.fmuPacked(fc, outDir);
    157157        }
    158158    }
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/src/java/org/jmodelica/util/ccompiler/CCompilerDelegator.java

    r13274 r13896  
    351351        };
    352352    }
     353
     354    public abstract Set<String> expandCompilerSpecificLibraryPaths(ModelicaLogger log, AbstractOptionRegistry options,
     355            Set<String> extLibDirs, String platform);
    353356}
    354357
  • branches/dev-mj-5835/Compiler/ModelicaCompiler/src/java/org/jmodelica/util/ccompiler/GccCompilerDelegator.java

    r13300 r13896  
    2626import java.util.Set;
    2727
     28import org.jmodelica.common.options.AbstractOptionRegistry;
    2829import org.jmodelica.util.EnvironmentUtils;
    2930import org.jmodelica.util.exceptions.CcodeCompilationException;
     
    106107            vars.put("AR", new File(mingw_bin, "ar").getPath());
    107108        }
     109    }
     110   
     111    @Override
     112    public Set<String> expandCompilerSpecificLibraryPaths(ModelicaLogger log, AbstractOptionRegistry options, Set<String> extLibDirs, String platform) {
     113        Set<String> expandedLibDirs = expandLibraries(extLibDirs, platform, "gcc" + compilerVersionNumber());
     114        return expandedLibDirs;
    108115    }
    109116   
  • branches/dev-mj-5835/Compiler/ModelicaCompilerCasADi/src/jastadd/FExpToCasADi.jrag

    r12770 r13896  
    3131            target.setDefaultOptions(options);
    3232            try {
    33                 return compileModel(name, cl, target, null, null);
     33                return compileModel(name, cl, target, null);
    3434            } finally {
    3535                options.copyAllOptions(tempOptions);
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/Arrays.jrag

    r13017 r13896  
    43144314            for (CommonForIndex fi : forIndices) {
    43154315                indexMap.put(fi.name(), new FIntegerLitExp(ii[j]));
    4316                 fi.setEvaluationValue(new CValueInteger(ii[j]));
     4316                fi.setEvaluationValue(CValueInteger.valueOf(ii[j]));
    43174317                j++;
    43184318            }
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13702 r13896  
    8282         * Copy this constant value.
    8383         */
     84        @Override
    8485        public CValue clone() {
    8586            try {
     
    119120         */
    120121        public CValue convertInteger() {
    121             return new CValueInteger(intValue());
     122            return CValueInteger.valueOf(intValue());
    122123        }
    123124
     
    126127         */
    127128        public CValue convertReal() {
    128             return new CValueReal(realValue());
     129            return CValueReal.valueOf(realValue());
    129130        }
    130131
     
    133134         */
    134135        public CValue convertBoolean() {
    135             return new CValueBoolean(booleanValue());
     136            return CValueBoolean.valueOf(booleanValue());
    136137        }
    137138
     
    301302     */
    302303    public class CValueInteger extends CValue {
    303         private int value;
    304        
    305         /**
    306          * Constructor.
    307          *
    308          * @param i Integer value.
    309          */
    310         public CValueInteger(int i) {
     304        private final int value;
     305       
     306        private CValueInteger(int i) {
    311307            this.value = i;
     308        }
     309       
     310        private static final CValueInteger ZERO = new CValueInteger(0);
     311       
     312        public static CValueInteger valueOf(int i) {
     313            if (i == 0) {
     314                return ZERO;
     315            }
     316            return new CValueInteger(i);
    312317        }
    313318
     
    422427            return true;
    423428        }
     429       
     430        @Override
     431        public CValueInteger clone() {
     432            return this;
     433        }       
    424434    }
    425435   
     
    428438     */     
    429439    public class CValueReal extends CValue {
    430         private double value;
     440        private final double value;
    431441       
    432442        /**
     
    435445         * @param d Double value.
    436446         */
    437         public CValueReal(double d) {
     447        private CValueReal(double d) {
    438448            this.value = d;
     449        }
     450       
     451        private static final CValueReal ZERO = new CValueReal(0.0);
     452       
     453        public static CValueReal valueOf(double d) {
     454            if (d == 0.0 && (Double.doubleToLongBits(d) & 0x8000000000000000L) == 0L) {
     455                return ZERO;
     456            }
     457            return new CValueReal(d);
    439458        }
    440459
     
    550569            return true;
    551570        }
     571       
     572        @Override
     573        public CValueReal clone() {
     574            return this;
     575        }       
     576       
    552577    }
    553578   
     
    562587        public static final CValueBoolean TRUE  = new CValueBoolean(true);
    563588       
    564         private boolean value;
     589        private final boolean value;
    565590
    566591        /**
     
    569594         * @param b Boolean value.
    570595         */
    571         public CValueBoolean(boolean b) {
    572             this.value = b;
     596        private CValueBoolean(boolean b) {
     597            this.value = b;
     598        }
     599       
     600        public static CValueBoolean valueOf(boolean b) {
     601            return b ? TRUE : FALSE;
    573602        }
    574603
     
    652681            return true;
    653682        }
     683       
     684        @Override
     685        public CValueBoolean clone() {
     686            return this;
     687        }
    654688    }
    655689
     
    658692     */
    659693    public class CValueString extends CValue {
    660         private String value;
     694        private final String value;
    661695       
    662696        /**
     
    718752            return true;
    719753        }
     754       
     755        @Override
     756        public CValueString clone() {
     757            return this;
     758        }       
     759       
    720760      }
    721761   
     
    16161656    public class CValueEnum extends CValue {
    16171657
    1618         private FEnumType type;
    1619         private String value;
    1620         private int index;
     1658        private final FEnumType type;
     1659        private final String value;
     1660        private final int index;
    16211661
    16221662        /**
     
    16291669            this.type = (FEnumType) type;
    16301670            this.value = value;
    1631             index = 0;
     1671            int temp_index = 0;
    16321672            int n = this.type.getNumFEnumLiteralType();
    1633             for (int i = 0; i < n && index == 0; i++)
    1634                 if (this.type.getFEnumLiteralType(i).getName().equals(value))
    1635                     index = i + 1;
     1673            for (int i = 0; i < n && temp_index == 0; i++) {
     1674                if (this.type.getFEnumLiteralType(i).getName().equals(value)) {
     1675                    temp_index = i + 1;
     1676                }
     1677            }
     1678            index = temp_index;
    16361679        }
    16371680
     
    17071750         *  @return an CommonAccessExp pointing to the literal in the FEnumDecl.
    17081751         */
     1752        @Override
    17091753        public FExp buildLiteral() {
    17101754            return type.createLiteral(index);
     
    17211765        }
    17221766
     1767        @Override
    17231768        public CValue constrainWithin(CValue min, CValue max) {
    17241769            if (!min.isUnknown() && min.intValue() > index)
     
    17281773            return this;
    17291774        }
     1775       
     1776       @Override
     1777       public CValueEnum clone() {
     1778           return this;
     1779       }
    17301780
    17311781    }
     
    17481798    public CValue FType.zeroCValueScalar()        { return CValue.UNKNOWN; }
    17491799    public CValue FArrayType.zeroCValueScalar()   { return getFPrimitiveType().zeroCValueScalar(); }
    1750     public CValue FRealType.zeroCValueScalar()    { return new CValueReal(0.0); }
    1751     public CValue FIntegerType.zeroCValueScalar() { return new CValueInteger(0); }
     1800    public CValue FRealType.zeroCValueScalar()    { return CValueReal.valueOf(0.0); }
     1801    public CValue FIntegerType.zeroCValueScalar() { return CValueInteger.valueOf(0); }
    17521802    public CValue FEnumType.zeroCValueScalar()    { return new CValueEnum(this, 1); }
    17531803    public CValue FStringType.zeroCValueScalar()  { return new CValueString(""); }
    1754     public CValue FBooleanType.zeroCValueScalar() { return new CValueBoolean(false); }
     1804    public CValue FBooleanType.zeroCValueScalar() { return CValueBoolean.FALSE; }
    17551805   
    17561806    public CValue FType.createCValue(int v) {
     
    17651815    }
    17661816   
    1767     public CValue FType.createCValueScalar(int v)     { return new CValueInteger(v); }
    1768     public CValue FRealType.createCValueScalar(int v) { return new CValueReal(v); }
     1817    public CValue FType.createCValueScalar(int v)     { return CValueInteger.valueOf(v); }
     1818    public CValue FRealType.createCValueScalar(int v) { return CValueReal.valueOf(v); }
    17691819
    17701820    public CValue FType.convert(CValue v)        { return v; }
     
    17751825
    17761826    public CValue FType.limitCValueScalar(boolean high)        { return CValue.UNSUPPORTED; }
    1777     public CValue FRealType.limitCValueScalar(boolean high)    { return new CValueReal(      high ? Double.MAX_VALUE  : -Double.MAX_VALUE); }
    1778     public CValue FIntegerType.limitCValueScalar(boolean high) { return new CValueInteger(   high ? Integer.MAX_VALUE : Integer.MIN_VALUE); }
    1779     public CValue FBooleanType.limitCValueScalar(boolean high) { return new CValueBoolean(   high ? true : false); }
     1827    public CValue FRealType.limitCValueScalar(boolean high)    { return CValueReal.valueOf(      high ? Double.MAX_VALUE  : -Double.MAX_VALUE); }
     1828    public CValue FIntegerType.limitCValueScalar(boolean high) { return CValueInteger.valueOf(   high ? Integer.MAX_VALUE : Integer.MIN_VALUE); }
     1829    public CValue FBooleanType.limitCValueScalar(boolean high) { return CValueBoolean.valueOf(high); }
    17801830    public CValue FEnumType.limitCValueScalar(boolean high)    { return new CValueEnum(this, high ? getNumFEnumLiteralType() : 1); }
    17811831
     
    23892439       
    23902440        FType t = type();
    2391         CValue sum = new CValueInteger(0);
     2441        CValue sum = CValueInteger.valueOf(0);
    23922442        CValueArray l = getLeft().ceval(evaluator).array();
    23932443        CValueArray r = getRight().ceval(evaluator).array();
     
    24832533   
    24842534    eq FEndExp.cevalCalc(VariableEvaluator evaluator) = mySize().ceval(evaluator, 0);
    2485     eq FNdimsExp.cevalCalc(VariableEvaluator evaluator) = new CValueInteger(getFExp().ndims());
     2535    eq FNdimsExp.cevalCalc(VariableEvaluator evaluator) = CValueInteger.valueOf(getFExp().ndims());
    24862536   
    24872537    eq FSubscriptedExp.cevalCalc(VariableEvaluator evaluator) {
     
    24922542    eq FCardinality.cevalCalc(VariableEvaluator evaluator) {
    24932543        final int v = getFExp().cardinalityValue();
    2494         return (v <= 0) ? CValue.UNKNOWN : new CValueInteger(v);
     2544        return (v <= 0) ? CValue.UNKNOWN : CValueInteger.valueOf(v);
    24952545    }
    24962546
     
    25022552    eq FConnBoolOp.cevalCalc(VariableEvaluator evaluator) {
    25032553        if (connectionGraph != null && connectionGraph.builtTreesDone())
    2504           return new CValueBoolean(cevalFromGraph());
     2554          return CValueBoolean.valueOf(cevalFromGraph());
    25052555        else
    25062556          throw new ConstantEvaluationNotReadyException();
     
    25492599    public CValue Size.ceval(VariableEvaluator evaluator, int d) {
    25502600        int s = get(d);
    2551         return (s == Size.UNKNOWN) ? CValue.UNKNOWN : new CValueInteger(s);
     2601        return (s == Size.UNKNOWN) ? CValue.UNKNOWN : CValueInteger.valueOf(s);
    25522602    }
    25532603
     
    26162666    /** Set the value for initial() to evaluate to. */
    26172667    public static void FInitialExp.setIsInitial(boolean value) {
    2618           evaluationValue = new CValueBoolean(value);
     2668          evaluationValue = CValueBoolean.valueOf(value);
    26192669    }
    26202670
     
    26312681    eq FMaxExp.selectLesser() = false;
    26322682
    2633     eq FRealLitExp.cevalCalc(VariableEvaluator evaluator)         = new CValueReal(getValue());
    2634     eq FIntegerLitExp.cevalCalc(VariableEvaluator evaluator)      = new CValueInteger(getValue());
    2635     eq FBooleanLitExpTrue.cevalCalc(VariableEvaluator evaluator)  = new CValueBoolean(true);
    2636     eq FBooleanLitExpFalse.cevalCalc(VariableEvaluator evaluator) = new CValueBoolean(false);
     2683    eq FRealLitExp.cevalCalc(VariableEvaluator evaluator)         = CValueReal.valueOf(getValue());
     2684    eq FIntegerLitExp.cevalCalc(VariableEvaluator evaluator)      = CValueInteger.valueOf(getValue());
     2685    eq FBooleanLitExpTrue.cevalCalc(VariableEvaluator evaluator)  = CValueBoolean.TRUE;
     2686    eq FBooleanLitExpFalse.cevalCalc(VariableEvaluator evaluator) = CValueBoolean.FALSE;
    26372687    eq FStringLitExp.cevalCalc(VariableEvaluator evaluator)       = new CValueString(unEscape());
    26382688    eq FEnumLitExp.cevalCalc(VariableEvaluator evaluator)         = new CValueEnum(type(), getValue());
     
    26912741    eq FAbstractDerExp.cevalUse(VariableEvaluator evaluator) {
    26922742        if (getFAccess().variability().discreteOrLess())
    2693             return new CValueInteger(0);
     2743            return CValueInteger.valueOf(0);
    26942744        FAbstractVariable decl = myFV();
    26952745        return decl == null ? CValue.UNKNOWN : evaluator.ceval(decl);
     
    27082758    eq InstGlobalAccess.ceval(VariableEvaluator evaluator, Index i)   = getInstAccess().ceval(evaluator, i);
    27092759    eq InstNamedAccess.ceval(VariableEvaluator evaluator, Index i) {
    2710         CValue res = unknownCValue();
     2760        CValue res;
    27112761        if (myInstComponentDecl().isAssignable()) {
    27122762          Index iHere = Index.NULL;
     
    27302780              res = res.getCell(iHere);
    27312781        } else if (myInstClassDecl().isEnum()) {
    2732             res = new CValueInteger(myInstClassDecl().enumLiterals().size());
     2782            res = CValueInteger.valueOf(myInstClassDecl().enumLiterals().size());
    27332783        } else if (myInstClassDecl().isBoolean()) {
    2734             res = new CValueInteger(2);
     2784            res = CValueInteger.valueOf(2);
     2785        } else {
     2786            res = unknownCValue();
    27352787        }
    27362788        return res;
     
    27882840    eq FAbsExp.cevalCalc(VariableEvaluator evaluator)  = type().abs(getFExp().ceval(evaluator));
    27892841    eq FSignExp.cevalCalc(VariableEvaluator evaluator) = type().sign(getFExp().ceval(evaluator));
    2790     eq FSqrtExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.sqrt(getFExp().ceval(evaluator).realValue()));
     2842    eq FSqrtExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.sqrt(getFExp().ceval(evaluator).realValue()));
    27912843    eq FEnumIntegerExp.cevalCalc(VariableEvaluator evaluator) = getFExp().ceval(evaluator).convertInteger();
    27922844    eq FStringExp.cevalCalc(VariableEvaluator evaluator) {
     
    28752927    eq FIntegerFuncExp.cevalCalc(VariableEvaluator evaluator)     = getX().ceval(evaluator).convertInteger();
    28762928
    2877     eq FSinExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.sin(getFExp().ceval(evaluator).realValue()));
    2878     eq FCosExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.cos(getFExp().ceval(evaluator).realValue()));
    2879     eq FTanExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.tan(getFExp().ceval(evaluator).realValue()));
    2880     eq FAsinExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.asin(getFExp().ceval(evaluator).realValue()));
    2881     eq FAcosExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.acos(getFExp().ceval(evaluator).realValue()));
    2882     eq FAtanExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.atan(getFExp().ceval(evaluator).realValue()));
    2883     eq FAtan2Exp.cevalCalc(VariableEvaluator evaluator) = new CValueReal(StrictMath.atan2(getFExp().ceval(evaluator).realValue(),
     2929    eq FSinExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.sin(getFExp().ceval(evaluator).realValue()));
     2930    eq FCosExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.cos(getFExp().ceval(evaluator).realValue()));
     2931    eq FTanExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.tan(getFExp().ceval(evaluator).realValue()));
     2932    eq FAsinExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.asin(getFExp().ceval(evaluator).realValue()));
     2933    eq FAcosExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.acos(getFExp().ceval(evaluator).realValue()));
     2934    eq FAtanExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.atan(getFExp().ceval(evaluator).realValue()));
     2935    eq FAtan2Exp.cevalCalc(VariableEvaluator evaluator) = CValueReal.valueOf(StrictMath.atan2(getFExp().ceval(evaluator).realValue(),
    28842936                                                               getY().ceval(evaluator).realValue()));
    2885     eq FSinhExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.sinh(getFExp().ceval(evaluator).realValue()));
    2886     eq FCoshExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.cosh(getFExp().ceval(evaluator).realValue()));
    2887     eq FTanhExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.tanh(getFExp().ceval(evaluator).realValue()));
    2888     eq FExpExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.exp(getFExp().ceval(evaluator).realValue()));
    2889     eq FLogExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.log(getFExp().ceval(evaluator).realValue()));
    2890     eq FLog10Exp.cevalCalc(VariableEvaluator evaluator) = new CValueReal(StrictMath.log10(getFExp().ceval(evaluator).realValue()));
     2937    eq FSinhExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.sinh(getFExp().ceval(evaluator).realValue()));
     2938    eq FCoshExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.cosh(getFExp().ceval(evaluator).realValue()));
     2939    eq FTanhExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.tanh(getFExp().ceval(evaluator).realValue()));
     2940    eq FExpExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.exp(getFExp().ceval(evaluator).realValue()));
     2941    eq FLogExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.log(getFExp().ceval(evaluator).realValue()));
     2942    eq FLog10Exp.cevalCalc(VariableEvaluator evaluator) = CValueReal.valueOf(StrictMath.log10(getFExp().ceval(evaluator).realValue()));
    28912943
    28922944    eq FExInStream.cevalCalc(VariableEvaluator evaluator) {
     
    29172969                div += flow;
    29182970            }
    2919             return new CValueReal(sum / div);
     2971            return CValueReal.valueOf(sum / div);
    29202972        }
    29212973    }
     
    29262978    syn CValue FSubscript.ceval(VariableEvaluator evaluator) = CValue.UNSUPPORTED;
    29272979    eq FExpSubscript.ceval(VariableEvaluator evaluator)      = getFExp().ceval(evaluator);
    2928     eq FIntegerSubscript.ceval(VariableEvaluator evaluator)  = new CValueInteger(getValue());
     2980    eq FIntegerSubscript.ceval(VariableEvaluator evaluator)  = CValueInteger.valueOf(getValue());
    29292981   
    29302982    syn int FSubscript.value()   = ceval(defaultVariableEvaluator()).intValue();
     
    31633215    eq InstPrimitive.attributeCValueDefault(String name) {
    31643216        if (name.equals(FAttribute.FIXED))
    3165             return new CValueBoolean(isConstant() || isParameter() || isString());
     3217            return CValueBoolean.valueOf(isConstant() || isParameter() || isString());
    31663218        CValue res = attributeCValueDefaultMap().get(name);
    31673219        return (res == null) ? CValue.UNKNOWN : res;
     
    31893241            real.put(FAttribute.UNIT, emptyStr);
    31903242            real.put(FAttribute.DISPLAY_UNIT, emptyStr);
    3191             real.put(FAttribute.START, new CValueReal(0.0));
     3243            real.put(FAttribute.START, CValueReal.valueOf(0.0));
    31923244            // TODO: add stateSelect, but how to get type?
    31933245            REAL_DEFAULT_ATTRIBUTES = real;
    31943246            Map<String,CValue> integer = new HashMap<String,CValue>();
    31953247            integer.put(FAttribute.QUANTITY, emptyStr);
    3196             integer.put(FAttribute.START, new CValueInteger(0));
     3248            integer.put(FAttribute.START, CValueInteger.valueOf(0));
    31973249            INTEGER_DEFAULT_ATTRIBUTES = integer;
    31983250            Map<String,CValue> bool = new HashMap<String,CValue>();
     
    42174269            return CValue.UNKNOWN;
    42184270        }
    4219         return new CValueReal(v1.realValue() + v2.realValue());
     4271        return CValueReal.valueOf(v1.realValue() + v2.realValue());
    42204272    }
    42214273
     
    42244276            return CValue.UNKNOWN;
    42254277        }
    4226         return new CValueInteger(v1.intValue() + v2.intValue());
     4278        return CValueInteger.valueOf(v1.intValue() + v2.intValue());
    42274279    }
    42284280
     
    42474299            return CValue.UNKNOWN;
    42484300        }
    4249         return new CValueReal(v1.realValue() - v2.realValue());
     4301        return CValueReal.valueOf(v1.realValue() - v2.realValue());
    42504302    }
    42514303
     
    42544306            return CValue.UNKNOWN;
    42554307        }
    4256         return new CValueInteger(v1.intValue() - v2.intValue());
     4308        return CValueInteger.valueOf(v1.intValue() - v2.intValue());
    42574309    }
    42584310
     
    42704322            return CValue.UNKNOWN;
    42714323        }
    4272         return new CValueReal(v1.realValue() * v2.realValue());
     4324        return CValueReal.valueOf(v1.realValue() * v2.realValue());
    42734325    }
    42744326
     
    42774329            return CValue.UNKNOWN;
    42784330        }
    4279         return new CValueInteger(v1.intValue() * v2.intValue());
     4331        return CValueInteger.valueOf(v1.intValue() * v2.intValue());
    42804332    }
    42814333
     
    42934345            return CValue.UNKNOWN;
    42944346        }
    4295         return new CValueReal(v1.realValue() / v2.realValue());
     4347        return CValueReal.valueOf(v1.realValue() / v2.realValue());
    42964348    }
    42974349
     
    43004352            return CValue.UNKNOWN;
    43014353        }
    4302         return new CValueReal(v1.realValue() / v2.realValue());
     4354        return CValueReal.valueOf(v1.realValue() / v2.realValue());
    43034355    }
    43044356
     
    43164368            return CValue.UNKNOWN;
    43174369        }
    4318         return new CValueReal(java.lang.StrictMath.pow(v1.realValue(), v2.realValue()));
     4370        return CValueReal.valueOf(java.lang.StrictMath.pow(v1.realValue(), v2.realValue()));
    43194371    }
    43204372
     
    43264378     */
    43274379    syn CValue FType.neg(CValue v) = CValue.UNKNOWN;
    4328     eq FRealType.neg(CValue v) = v.hasRealValue() ? new CValueReal(-v.realValue()) : CValue.UNKNOWN;
    4329     eq FIntegerType.neg(CValue v) = v.hasIntValue() ? new CValueInteger(-v.intValue()) : CValue.UNKNOWN;
     4380    eq FRealType.neg(CValue v) = v.hasRealValue() ? CValueReal.valueOf(-v.realValue()) : CValue.UNKNOWN;
     4381    eq FIntegerType.neg(CValue v) = v.hasIntValue() ? CValueInteger.valueOf(-v.intValue()) : CValue.UNKNOWN;
    43304382
    43314383    /**
     
    43364388     */
    43374389    syn CValue FType.abs(CValue v) = CValue.UNKNOWN;
    4338     eq FRealType.abs(CValue v) = v.hasRealValue() ? new CValueReal(StrictMath.abs(v.realValue())) : CValue.UNKNOWN;
     4390    eq FRealType.abs(CValue v) = v.hasRealValue() ? CValueReal.valueOf(StrictMath.abs(v.realValue())) : CValue.UNKNOWN;
    43394391    eq FIntegerType.abs(CValue v) =
    4340             v.hasIntValue() ? new CValueInteger(StrictMath.abs(v.intValue())) : CValue.UNKNOWN;
     4392            v.hasIntValue() ? CValueInteger.valueOf(StrictMath.abs(v.intValue())) : CValue.UNKNOWN;
    43414393
    43424394    /**
     
    43494401
    43504402    eq FIntegerType.sign(CValue v) =
    4351             v.hasIntValue() ? new CValueInteger((int) StrictMath.signum(v.realValue())) : CValue.UNKNOWN;
     4403            v.hasIntValue() ? CValueInteger.valueOf((int) StrictMath.signum(v.realValue())) : CValue.UNKNOWN;
    43524404
    43534405    /**
     
    43594411    syn CValue FType.ceil(CValue v) = CValue.UNKNOWN;
    43604412
    4361     eq FRealType.ceil(CValue v) = v.hasRealValue() ? new CValueReal(StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
     4413    eq FRealType.ceil(CValue v) = v.hasRealValue() ? CValueReal.valueOf(StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
    43624414
    43634415    eq FIntegerType.ceil(CValue v) =
    4364             v.hasIntValue() ? new CValueInteger((int) StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
     4416            v.hasIntValue() ? CValueInteger.valueOf((int) StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
    43654417
    43664418    /**
     
    43994451            return CValue.UNKNOWN;
    44004452        }
    4401         return new CValueBoolean(v1.booleanValue() && v2.booleanValue());
     4453        return CValueBoolean.valueOf(v1.booleanValue() && v2.booleanValue());
    44024454    }
    44034455
     
    44154467            return CValue.UNKNOWN;
    44164468        }
    4417         return new CValueBoolean(v1.booleanValue() || v2.booleanValue());
     4469        return CValueBoolean.valueOf(v1.booleanValue() || v2.booleanValue());
    44184470    }
    44194471
     
    44254477     */
    44264478    syn CValue FType.not(CValue v) = CValue.UNKNOWN;
    4427     eq FBooleanType.not(CValue v) = v.isBoolean() ? new CValueBoolean(!v.booleanValue()) : CValue.UNKNOWN;
     4479    eq FBooleanType.not(CValue v) = v.isBoolean() ? CValueBoolean.valueOf(!v.booleanValue()) : CValue.UNKNOWN;
    44284480
    44294481    /* Machine epsilon */
     
    44504502            return CValue.UNKNOWN;
    44514503        }
    4452         return new CValueBoolean(v1.intValue() == v2.intValue());
     4504        return CValueBoolean.valueOf(v1.intValue() == v2.intValue());
    44534505    }
    44544506
     
    44574509            return CValue.UNKNOWN;
    44584510        }
    4459         return new CValueBoolean(almostZero(v1.realValue() - v2.realValue()));
     4511        return CValueBoolean.valueOf(almostZero(v1.realValue() - v2.realValue()));
    44604512    }
    44614513
     
    44644516            return CValue.UNKNOWN;
    44654517        }
    4466         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) == 0);
     4518        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) == 0);
    44674519    }
    44684520
     
    44804532            return CValue.UNKNOWN;
    44814533        }
    4482         return new CValueBoolean(v1.intValue() != v2.intValue());
     4534        return CValueBoolean.valueOf(v1.intValue() != v2.intValue());
    44834535    }
    44844536
     
    44874539            return CValue.UNKNOWN;
    44884540        }
    4489         return new CValueBoolean(v1.realValue() != v2.realValue());
     4541        return CValueBoolean.valueOf(v1.realValue() != v2.realValue());
    44904542    }
    44914543
     
    44944546            return CValue.UNKNOWN;
    44954547        }
    4496         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) != 0);
     4548        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) != 0);
    44974549    }
    44984550
     
    45104562            return CValue.UNKNOWN;
    45114563        }
    4512         return new CValueBoolean(v1.intValue() >= v2.intValue());
     4564        return CValueBoolean.valueOf(v1.intValue() >= v2.intValue());
    45134565    }
    45144566
     
    45174569            return CValue.UNKNOWN;
    45184570        }
    4519         return new CValueBoolean(almostGtZero(v1.realValue() - v2.realValue()));
     4571        return CValueBoolean.valueOf(almostGtZero(v1.realValue() - v2.realValue()));
    45204572    }
    45214573
     
    45244576            return CValue.UNKNOWN;
    45254577        }
    4526         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) >= 0);
     4578        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) >= 0);
    45274579    }
    45284580
     
    45404592            return CValue.UNKNOWN;
    45414593        }
    4542         return new CValueBoolean(v1.intValue() > v2.intValue());
     4594        return CValueBoolean.valueOf(v1.intValue() > v2.intValue());
    45434595    }
    45444596
     
    45474599            return CValue.UNKNOWN;
    45484600        }
    4549         return new CValueBoolean(v1.realValue() > v2.realValue());
     4601        return CValueBoolean.valueOf(v1.realValue() > v2.realValue());
    45504602    }
    45514603
     
    45544606            return CValue.UNKNOWN;
    45554607        }
    4556         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) > 0);
     4608        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) > 0);
    45574609    }
    45584610
     
    45704622            return CValue.UNKNOWN;
    45714623        }
    4572         return new CValueBoolean(v1.intValue() <= v2.intValue());
     4624        return CValueBoolean.valueOf(v1.intValue() <= v2.intValue());
    45734625    }
    45744626
     
    45774629            return CValue.UNKNOWN;
    45784630        }
    4579         return new CValueBoolean(almostLtZero(v1.realValue() - v2.realValue()));
     4631        return CValueBoolean.valueOf(almostLtZero(v1.realValue() - v2.realValue()));
    45804632    }
    45814633
     
    45844636            return CValue.UNKNOWN;
    45854637        }
    4586         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) <= 0);
     4638        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) <= 0);
    45874639    }
    45884640
     
    46004652            return CValue.UNKNOWN;
    46014653        }
    4602         return new CValueBoolean(v1.intValue() < v2.intValue());
     4654        return CValueBoolean.valueOf(v1.intValue() < v2.intValue());
    46034655    }
    46044656
     
    46074659            return CValue.UNKNOWN;
    46084660        }
    4609         return new CValueBoolean(v1.realValue() < v2.realValue());
     4661        return CValueBoolean.valueOf(v1.realValue() < v2.realValue());
    46104662    }
    46114663
     
    46144666            return CValue.UNKNOWN;
    46154667        }
    4616         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) < 0);
     4668        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) < 0);
    46174669    }
    46184670
    46194671    eq CValueUnknown.lt(CValue v1, CValue v2) = CValue.UNKNOWN;
    46204672
     4673   
     4674    public CValue CValue.absoluteValue() {
     4675        return this;
     4676    }
     4677    @Override
     4678    public CValue CValueReal.absoluteValue() {
     4679        return new CValueReal(Math.abs(realValue()));
     4680    }
     4681    @Override
     4682    public CValue CValueInteger.absoluteValue() {
     4683        return new CValueInteger(Math.abs(intValue()));
     4684    }
     4685   
    46214686}
    46224687
     
    48774942    eq SrcBooleanLitExpTrue.ceval()  = CValueBoolean.TRUE;
    48784943    eq SrcBooleanLitExpFalse.ceval() = CValueBoolean.FALSE;
    4879     eq SrcIntegerLitExp.ceval()      = new CValueInteger(Integer.parseInt(getUNSIGNED_INTEGER()));
    4880     eq SrcRealLitExp.ceval()         = new CValueReal(Double.parseDouble(getUNSIGNED_NUMBER()));
     4944    eq SrcIntegerLitExp.ceval()      = CValueInteger.valueOf(Integer.parseInt(getUNSIGNED_INTEGER()));
     4945    eq SrcRealLitExp.ceval()         = CValueReal.valueOf(Double.parseDouble(getUNSIGNED_NUMBER()));
    48814946    eq SrcArrayConstructor.ceval()   = cevalArray();
    48824947    eq SrcMatrix.ceval()             = cevalArray();
     
    48844949        CValue value = getSrcExp().ceval();
    48854950        if (value.isInteger())
    4886             return new CValueInteger(-value.intValue());
     4951            return CValueInteger.valueOf(-value.intValue());
    48874952        else if (value.isReal())
    4888             return new CValueReal(-value.realValue());
     4953            return CValueReal.valueOf(-value.realValue());
    48894954        else
    48904955            return CValue.UNKNOWN;
     
    49755040    public class VariableEvaluator {
    49765041        public static final VariableEvaluator instance = new VariableEvaluator(true);
    4977         private boolean externalEvaluationEnabled;
     5042        private final boolean externalEvaluationEnabled;
    49785043       
    49795044        public VariableEvaluator(boolean externalEvaluationEnabled) {
     
    50005065        }
    50015066       
    5002         public AlgorithmEvaluator createAlgorithmEvaluator(AbstractOptionRegistry options, Map<CommonVariableDecl, CValue> values) {
     5067        public AlgorithmEvaluator createAlgorithmEvaluator(OptionRegistry options, Map<CommonVariableDecl, CValue> values) {
    50035068            return new AlgorithmEvaluator(externalEvaluationEnabled, options, values);
    50045069        }
    50055070       
    5006         public AlgorithmEvaluator createEmptyAlgorithmEvaluator(AbstractOptionRegistry options) {
     5071        public AlgorithmEvaluator createEmptyAlgorithmEvaluator(OptionRegistry options) {
    50075072            return new AlgorithmEvaluator(true, options, Collections.<CommonVariableDecl, CValue>emptyMap());
    50085073        }
     
    50705135       
    50715136        @Override
    5072         public AlgorithmEvaluator createAlgorithmEvaluator(AbstractOptionRegistry options, Map<CommonVariableDecl, CValue> values) {
     5137        public AlgorithmEvaluator createAlgorithmEvaluator(OptionRegistry options, Map<CommonVariableDecl, CValue> values) {
    50735138            return new PartialAlgorithmEvaluator(externalEvaluationEnabled(), options, values, this);
    50745139        }
     
    51045169       
    51055170        @Override
    5106         public AlgorithmEvaluator createAlgorithmEvaluator(AbstractOptionRegistry options, Map<CommonVariableDecl, CValue> values) {
     5171        public AlgorithmEvaluator createAlgorithmEvaluator(OptionRegistry options, Map<CommonVariableDecl, CValue> values) {
    51075172            if (this.values == null) {
    51085173                this.values = values;
     
    51985263    public class AlgorithmEvaluator extends VariableEvaluator {
    51995264       
    5200         protected Map<CommonVariableDecl, CValue> values;
    5201         private AbstractOptionRegistry options;
    5202        
    5203         public AlgorithmEvaluator(boolean evaluateExternalEnabled, AbstractOptionRegistry options, Map<CommonVariableDecl, CValue> values) {
     5265        protected final Map<CommonVariableDecl, CValue> values;
     5266        private final OptionRegistry options;
     5267       
     5268        public AlgorithmEvaluator(boolean evaluateExternalEnabled, OptionRegistry options, Map<CommonVariableDecl, CValue> values) {
    52045269            super(evaluateExternalEnabled);
    52055270            this.values  = values;
     
    52085273       
    52095274        public int externalEvaluation() {
    5210             return externalEvaluationEnabled() ? options.getIntegerOption("external_constant_evaluation") : 0;
     5275            return externalEvaluationEnabled() ? options.external_constant_evaluation.getValue() : 0;
    52115276        }
    52125277       
     
    52725337        protected ArrayList<IfEvaluation> ifStack;
    52735338       
    5274         public PartialAlgorithmEvaluator(boolean evaluateExternalEnabled, AbstractOptionRegistry options,
     5339        public PartialAlgorithmEvaluator(boolean evaluateExternalEnabled, OptionRegistry options,
    52755340                Map<CommonVariableDecl, CValue> values, PartialVariableEvaluator variableEvaluator) {
    52765341            super(evaluateExternalEnabled, options, values);
     
    52895354       
    52905355        @Override
    5291         public AlgorithmEvaluator createAlgorithmEvaluator(AbstractOptionRegistry options, Map<CommonVariableDecl, CValue> values) {
     5356        public AlgorithmEvaluator createAlgorithmEvaluator(OptionRegistry options, Map<CommonVariableDecl, CValue> values) {
    52925357            return variableEvaluator.createAlgorithmEvaluator(options, values);
    52935358        }
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ExternalConstantEvaluation.jrag

    r11541 r13896  
    2626import java.util.TimerTask;
    2727
     28import org.jmodelica.common.evaluation.ExternalFunctionCompiler;
    2829import org.jmodelica.common.evaluation.ExternalFunction;
    2930import org.jmodelica.common.evaluation.ExternalProcessCache;
    3031import org.jmodelica.common.evaluation.ExternalProcessCacheImpl;
    3132import org.jmodelica.common.evaluation.ExternalProcessMultiCache;
     33import org.jmodelica.common.evaluation.FailedExternalFunction;
    3234import org.jmodelica.common.evaluation.ProcessCommunicator;
    3335
     
    4951    class ModelicaCompiler {}
    5052   
    51     ModelicaCompiler   implements ExternalProcessMultiCache.Compiler<ExternalArgument, FExternalStmt>;
     53    ModelicaCompiler   implements ExternalFunctionCompiler<ExternalArgument, FExternalStmt>;
    5254    FExternalStmt      implements ExternalProcessMultiCache.External<ExternalArgument>;
    5355    ExternalArgument   extends    ExternalProcessMultiCache.Variable<CValue,FType>;
     
    8991     * Check if this external function should be cached as a live process.
    9092     */
    91     syn boolean FExternalStmt.shouldCacheProcess() {
    92         return myOptions().getIntegerOption("external_constant_evaluation_max_proc") > 0;
    93     }
     93    syn int FExternalStmt.processLimit() =
     94            myOptions().external_constant_evaluation_max_proc.getValue();
     95   
     96    syn boolean FExternalStmt.dynamicEvaluatorEnabled() =
     97            myOptions().external_constant_evaluation_dynamic.getValue()
     98            && !externalObjectsToSerialize().iterator().hasNext();
    9499   
    95100    /**
     
    169174        ExternalFunctionCache efc = root().getUtilInterface().getExternalFunctionCache();
    170175        if (efc == null) {
    171             return new ExternalProcessCacheImpl<>(root().getUtilInterface().getModelicaCompiler())
    172                 .failedEval(this, "external function cache unavailable", false);
     176            return FailedExternalFunction.<ExternalArgument, CValue, FType, FExternalStmt>failedEval(
     177                    root().getUtilInterface().getModelicaCompiler(),
     178                    this, "external function cache unavailable", false);
    173179        }
    174180        return efc.getExternalProcessCache(getLibTopPackagePath()).getExternalFunction(this);
     
    205211       
    206212        if (error != null) {
    207             throw new ConstantEvaluationException(null, ExternalProcessCacheImpl.failedEvalMsg(getName(), error));
     213            throw new ConstantEvaluationException(null, FailedExternalFunction.failedEvalMsg(getName(), error));
    208214        }
    209215       
     
    330336    }
    331337    public CValue FRealType.deserializeScalar(ProcessCommunicator com) throws IOException {
    332         return new CValueReal(com.deserializeReal());
     338        return CValueReal.valueOf(com.deserializeReal());
    333339    }
    334340    public CValue FIntegerType.deserializeScalar(ProcessCommunicator com) throws IOException {
    335         return new CValueInteger((int) com.deserializeReal());
     341        return CValueInteger.valueOf((int) com.deserializeReal());
    336342    }
    337343    public CValue FBooleanType.deserializeScalar(ProcessCommunicator com) throws IOException {
    338         return new CValueBoolean(com.deserializeReal() != 0);
     344        return CValueBoolean.valueOf(com.deserializeReal() != 0);
    339345    }
    340346    public CValue FStringType.deserializeScalar(ProcessCommunicator com) throws IOException {
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r13871 r13896  
    23682368    inh FClass FFunctionDecl.myFClass();
    23692369    inh FClass FRecordDecl.myFClass();
     2370    inh FClass FDerivedType.myFClass();
     2371    inh FClass FEnumDecl.myFClass();
    23702372    inh FClass FAlgorithm.myFClass();
    23712373    inh FClass FAbstractEquation.myFClass();
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPIAttributes.jrag

    r11676 r13896  
    109109    syn CValue FVariable.attributeCValueBoolean(String name, boolean def) {
    110110        FAttribute a = findAttribute(name);
    111         return (attributeSet(a) ? attributeExp(a).ceval() : new CValueBoolean(def)).expandArray(size());
     111        return (attributeSet(a) ? attributeExp(a).ceval() : CValueBoolean.valueOf(def)).expandArray(size());
    112112    }
    113113    syn CValue FVariable.attributeCValueReal(String name, double def) {
    114114        FAttribute a = findAttribute(name);
    115         return (attributeSet(a) ? attributeExp(a).ceval() : new CValueReal(def)).expandArray(size());
     115        return (attributeSet(a) ? attributeExp(a).ceval() : CValueReal.valueOf(def)).expandArray(size());
    116116    }
    117117    syn CValue FVariable.attributeCValueInteger(String name, int def) {
    118118        FAttribute a = findAttribute(name);
    119         return (attributeSet(a) ? attributeExp(a).ceval() : new CValueInteger(def)).expandArray(size());
     119        return (attributeSet(a) ? attributeExp(a).ceval() : CValueInteger.valueOf(def)).expandArray(size());
    120120    }
    121121    syn CValue FVariable.attributeCValueEnum(String name, FType type, int def) {
     
    200200    syn CValue FVariable.startAttributeCValue()   = CValue.UNKNOWN;
    201201    eq FRealVariable.startAttributeCValue()       = attributeCValueReal(FAttribute.START, 0.0);
    202     eq FDerivativeVariable.startAttributeCValue() = new CValueReal(0.0);
     202    eq FDerivativeVariable.startAttributeCValue() = CValueReal.valueOf(0.0);
    203203    eq FIntegerVariable.startAttributeCValue()    = attributeCValueInteger(FAttribute.START, 0);
    204204    eq FBooleanVariable.startAttributeCValue()    = attributeCValueBoolean(FAttribute.START, false);
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/FlatUtil.jrag

    r13456 r13896  
    16891689     
    16901690
    1691     public String FClass.nextTempFuncName() {
    1692         String name;
    1693         do {
    1694             name = "temp_" + nextTempFuncIndex++;
    1695         } while (lookupFunc(name) != null);
    1696         return name;
    1697     }
    1698     private int FClass.nextTempFuncIndex = 1;
    1699 
    1700 
    17011691    /**
    17021692     * Creates new temporary variables with the given name.
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r13702 r13896  
    11391139        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
    11401140   
     1141        prettyPrintEquations(p, str, indent);
     1142       
     1143        if (getNumFFunctionDecl() > 0 || getNumFRecordDecl() > 0 ||
     1144                getNumFEnumDecl() > 0 || getNumFDerivedType() > 0) {
     1145            str.println();
     1146            str.formatln("%spublic", indent);
     1147            p.print(getFFunctionDecls(), str, nextInd);
     1148            p.print(getFRecordDecls(), str, nextInd);
     1149            p.print(getFEnumDecls(), str, nextInd);
     1150            p.print(getFDerivedTypes(), str, nextInd);
     1151        }
     1152       
     1153        getFAttributeList().prettyPrintFAnnotationAttributeList(str, p, indent, ";" + str.getLineEnder());
     1154
     1155        str.println(indent, "end ", name(), ";");
     1156    }
     1157   
     1158    public void FClass.prettyPrintEquations(Printer p, CodeStream str, String indent) {
    11411159        boolean wroteEquation = false;
    1142         for (FAbstractEquation e : getFAbstractEquations()) {
     1160        String nextInd = p.indent(indent);
     1161        for (FAbstractEquation e : equationsForPrinting()) {
    11431162            if (e instanceof FAlgorithm) {
    11441163                p.print(e, str, indent);
     
    11551174            }
    11561175        }
    1157        
    1158         if (getNumFFunctionDecl() > 0 || getNumFRecordDecl() > 0 ||
    1159                 getNumFEnumDecl() > 0 || getNumFDerivedType() > 0) {
    1160             str.println();
    1161             str.formatln("%spublic", indent);
    1162             p.print(getFFunctionDecls(), str, nextInd);
    1163             p.print(getFRecordDecls(), str, nextInd);
    1164             p.print(getFEnumDecls(), str, nextInd);
    1165             p.print(getFDerivedTypes(), str, nextInd);
    1166         }
    1167        
    1168         getFAttributeList().prettyPrintFAnnotationAttributeList(str, p, indent, ";" + str.getLineEnder());
    1169 
    1170         str.println(indent, "end ", name(), ";");
     1176    }
     1177   
     1178    public Iterable<FAbstractEquation> FClass.equationsForPrinting() {
     1179        return getFAbstractEquations();
    11711180    }
    11721181
     
    13181327
    13191328    public void FDerivedType.prettyPrint(Printer p, CodeStream str, String indent) {
     1329        prettyPrintWithName(p, str, indent, getName());
     1330    }
     1331   
     1332    private void FDerivedType.prettyPrintWithName(Printer p, CodeStream str, String indent, String name) {
    13201333        if (!getBaseType().isEnum()) {
    1321             str.print(indent, "type ", getName(), " = ", getBaseType());
     1334            str.print(indent, "type ", name, " = ", getBaseType());
    13221335            getFAttributeList().prettyPrintFAttributeList(str, p);
    13231336            str.println(";");
     
    13931406   
    13941407    public void FArraySubscripts.prettyPrint(Printer p, CodeStream str, String indent) {
    1395         if (numSubscript()>0) {
    1396             str.print("[");
    1397             for (int i=0;i<numSubscript();i++) {
    1398                 subscript(i).prettyPrint(p, str, indent);
    1399                 if (i<numSubscript()-1)
    1400                     str.print(",");
    1401             }
    1402             str.print("]");
    1403         }
     1408        str.print("[");
     1409        for (int i = 0; i < numSubscript(); i++) {
     1410            subscript(i).prettyPrint(p, str, indent);
     1411            if (i < numSubscript() - 1) {
     1412                str.print(",");
     1413            }
     1414        }
     1415        str.print("]");
    14041416    }
    14051417
     
    22142226        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
    22152227    */
    2216         boolean wroteEquation = false;
    2217         for (FAbstractEquation e : getFAbstractEquations()) {
    2218             if (e instanceof FAlgorithm) {
    2219                 p.print(e, str, indent);
    2220                 wroteEquation = false;
    2221             } else {
    2222                 if (!e.isIgnored()) {
    2223                     if (!wroteEquation) {
    2224                         str.println(indent, "equation");
    2225                         wroteEquation = true;
    2226                     }
    2227                     p.print(e, str, nextInd);
    2228                     str.println(";");
    2229                 }
    2230             }
    2231         }
     2228        prettyPrintEquations(p, str, indent);
    22322229               
    22332230        str.println(indent, "end ", nameUnderscore(), ";");
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/Variability.jrag

    r12811 r13896  
    243243    FTimeExp contributes this to FAbstractEquation.timeExps() for myFEquation();
    244244   
    245     syn boolean FAbstractEquation.isConstant()   = variability().constantVariability();
    246     syn boolean FAbstractEquation.isParameter()  = variability().parameterVariability();
    247     syn boolean FAbstractEquation.isDiscrete()   = variability().discreteVariability();
    248245    syn boolean FAbstractEquation.isContinuous() = variability().continuousVariability();
    249246
     
    258255    eq FVariable.isContinuous() = variability().continuousVariability();
    259256
     257    eq FRecordVariable.isConstant()   = variability().combine().constantVariability();
     258    eq FRecordVariable.isParameter()  = variability().combine().parameterVariability();
     259    eq FRecordVariable.isDiscrete()   = variability().combine().discreteVariability();
     260    eq FRecordVariable.isContinuous() = variability().combine().continuousVariability();
    260261
    261262    syn TypePrefixVariability FType.funcOutputVariability() = Variability.DISCRETE;
  • branches/dev-mj-5835/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r13702 r13896  
    699699 * LibTopPackagePath is the file path of the package file of the library that this external statement originated from.
    700700 */
    701 FExternalStmt : FStatement ::= FExternalLanguage [ReturnVar:CommonAccessExp] <Name> Arg:FExp* <LibTopPackagePath>;
     701FExternalStmt : FStatement ::= FExternalLanguage [ReturnVar:CommonAccessExp] <Name> Arg:FExp* <LibTopPackagePath> FAttribute*;
    702702
    703703/**
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r13491 r13896  
    776776        stmt.setLibTopPackagePath(scd == null ? "" : scd.myLibRootPath().toAbsolutePath().toString()); // scd is null for builtins
    777777        stmt.setFExternalLanguage(hasFExternalLanguage() ?
    778                 (FExternalLanguage) getFExternalLanguage().fullCopy() :
     778                getFExternalLanguage().treeCopy() :
    779779                new FCExternalLanguage());
    780780        stmt.extractLibrary(this);
     
    830830                new Opt<CommonAccessExp>();
    831831               
    832         FExternalStmt stmt = new FExternalStmt(getFExternalLanguage().treeCopy(), ret, getName(), args, getLibTopPackagePath());
     832        FExternalStmt stmt = new FExternalStmt(getFExternalLanguage().treeCopy(), ret, getName(), args, getLibTopPackagePath(), new List<FAttribute>());
    833833        stmt.extractLibrary(this);
    834834        sl.add(stmt);
     
    21582158            List<FAttribute> attrs, AttributeExpRetriever aer, boolean cls) {}
    21592159
    2160     syn boolean InstComponentDecl.isBuiltIn() = false;
    2161     eq InstBuiltIn.isBuiltIn()                = true;
    2162     syn boolean InstBuiltInClassDecl.isBuiltIn()                = true;
    2163     syn boolean SrcBuiltInClassDecl.isBuiltIn()       = true;
    2164     syn boolean SrcClassDecl.isBuiltIn() = ((SourceRoot) root()).getProgram().getBuiltInTypes().hasChild(this)
    2165             || ((SourceRoot) root()).getProgram().getBuiltInFunctions().hasChild(this);
    2166    
    2167     public boolean List.hasChild(ASTNode node) {
    2168         for(ASTNode child : children) {
    2169             if(child == node) {
    2170                 return true;
    2171             }
    2172         }
    2173         return false;
    2174     }
    2175    
    2176 
     2160    syn boolean InstComponentDecl.isBuiltIn()    = false;
     2161    eq InstBuiltIn.isBuiltIn()                   = true;
     2162    syn boolean InstBuiltInClassDecl.isBuiltIn() = true;
     2163    syn boolean SrcBuiltInClassDecl.isBuiltIn()  = true;
     2164    inh boolean SrcClassDecl.isBuiltIn();
     2165    eq Root.getChild().isBuiltIn() = false;
     2166    eq Program.getBuiltInType().isBuiltIn() = true;
     2167    eq Program.getBuiltInFunction().isBuiltIn() = true;
     2168   
     2169    syn SourceRoot Root.asSourceRoot() {
     2170        throw new UnsupportedOperationException("Method not implemented for class " + getClass().getSimpleName() + "!");
     2171    }
     2172    eq SourceRoot.asSourceRoot() = this;
     2173   
    21772174    public void InstComponentModification.collectAttributes(Flattener f,
    21782175            List<FAttribute> attrs, AttributeExpRetriever aer, boolean cls) {
     
    24622459        int i = 0;
    24632460        for (CommonForIndex fi : forIndices) {
    2464             fi.setEvaluationValue(new CValueInteger(index[i++]));
     2461            fi.setEvaluationValue(CValueInteger.valueOf(index[i++]));
    24652462        }
    24662463    }
     
    34023399    /**
    34033400     * Class used during instantiation of equations and flattening of variables
    3404      * to delecate to different contributors. This class is subtyped for each
    3405      * contributor!
     3401     * to delegate to different contributors. This class is subtyped for each
     3402     * contributor.
    34063403     */
    34073404    public abstract class AttributeContributor {
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/flattening/connections/Connections.jrag

    r13456 r13896  
    13921392            int[] ii = indices.translate(i).index();
    13931393            for (InstForIndex fi : getInstForIndexs()) {
    1394                 fi.getInstPrimitive().setLocalCachedEvaluationValue(new CValueInteger(ii[j]));
     1394                fi.getInstPrimitive().setLocalCachedEvaluationValue(CValueInteger.valueOf(ii[j]));
    13951395                j++;
    13961396            }
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/flattening/connections/ExpandableConnectors.jrag

    r13224 r13896  
    10591059        CValue val = ceval();
    10601060        if (ndims() > 0)
    1061             val = val.reduce(INT_MAX_OP, new CValueInteger(1));
     1061            val = val.reduce(INT_MAX_OP, CValueInteger.valueOf(1));
    10621062        s.set(i, val.intValue());
    10631063        return ndims() == 0 || size().get(0) == len;
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupClasses.jrag

    r13317 r13896  
    258258
    259259    syn lazy HashMap<String,SrcLibNode> InstProgramRoot.libraryMap() {
    260         Program prog = ((SourceRoot) root()).getProgram();
     260        Program prog = root().asSourceRoot().getProgram();
    261261        HashMap<String,SrcLibNode> map = new HashMap<String,SrcLibNode>(prog.getNumSrcLibNode() * 4 / 3 + 1);
    262262        for (SrcLibNode ln : prog.getSrcLibNodes()) {
    263             if (!map.containsKey(ln.name())) {
    264                 map.put(ln.name(), ln);
     263            String name = ln.name().toLowerCase();
     264            if (!map.containsKey(name)) {
     265                map.put(name, ln);
    265266            }
    266267        }
     
    269270
    270271    syn lazy InstLookupResult<InstClassDecl> InstProgramRoot.lookupLibrary(String name) {
    271         SrcLibNode ln = libraryMap().get(name);
     272        SrcLibNode ln = libraryMap().get(name.toLowerCase());
    272273        if (ln != null) {
    273274            InstClassDecl icd = createInstClassDecl(ln);
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupComponents.jrag

    r13476 r13896  
    2727         */
    2828        public static <T extends Item> InstLookupResult<T> InstLookupResult.notFound() {
    29             return (InstLookupResult<T>) NOT_FOUND;
     29            return NOT_FOUND;
    3030        }
    3131
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r13491 r13896  
    18071807    }
    18081808    public List<InstComponentDecl> InstLibNode.getInstComponentDeclList() {
    1809         throw new UnsupportedOperationException();
     1809        return resolveLib().getInstComponentDeclList();
    18101810    }
    18111811
     
    18141814    }
    18151815    public List<InstClassDecl> InstLibNode.getInstClassDeclList() {
    1816         throw new UnsupportedOperationException();
     1816        return resolveLib().getInstClassDeclList();
    18171817    }
    18181818
     
    18211821    }
    18221822    public List<InstExtends> InstLibNode.getInstExtendsList() {
    1823         throw new UnsupportedOperationException();
     1823        return resolveLib().getInstExtendsList();
    18241824    }
    18251825
     
    18281828    }
    18291829    public List<InstImport> InstLibNode.getInstImportList() {
    1830         throw new UnsupportedOperationException();
     1830        return resolveLib().getInstImportList();
    18311831    }
    18321832
     
    18351835    }
    18361836    public List<InstClassDecl> InstLibNode.getRedeclaredInstClassDeclList() {
    1837         throw new UnsupportedOperationException();
     1837        return actualInstClass().getRedeclaredInstClassDeclList();
    18381838    }
    18391839
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/instance/Types.jrag

    r13476 r13896  
    6868   
    6969    syn boolean SrcBaseNode.isPrimitiveType() = false;
    70     eq SrcClassDecl.isPrimitiveType() = isPrimitive();
     70    eq SrcClassDecl.isPrimitiveType()         = isPrimitive();
    7171
    7272    public static String InstNode.subTypeMessage(String name, String message) {
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/source/Library.jrag

    r13354 r13896  
    475475        // We should figure out if using a non-file name is really needed as load description,
    476476        // and if not - get rid of otherDesc.
    477         private Path path;
     477        private final Path path;
    478478        private final String otherDesc;
    479479
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/source/PredefinedTypes.jrag

    r12975 r13896  
    4141     * Some differences apply however. The types of predefined types must
    4242     * be looked up only amongst the built-in types. Also, there are no
    43      * component accesses that needs to be looked up predefined types.
     43     * component accesses that need to be looked up for predefined types.
    4444     * The predefined types are defined in the (list) non terminal attribute
    4545     * PredefinedType.
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/source/SimpleLookup.jrag

    r13396 r13896  
    8787     * Lookup the class referenced by the QualifiedName.
    8888     * Lookup is both uncached and only among the class members and imported.
    89      * This method is intended as a entry point
     89     * This method is intended as an entry point
    9090     */
    9191     public SrcClassDecl SrcClassDecl.LookupMyMembers(QualifiedName qName) {
     
    105105     * Lookup the class referenced by the QualifiedName. The QualifiedName
    106106     * determines if the lookup is in relative or global scope.
    107      * This method is intended as a entry point
     107     * This method is intended as an entry point
    108108     *
    109109     */
     
    161161    public abstract class ResolvedAccess {
    162162
    163         private SrcClassDecl classDecl;
    164         private SrcComponentDecl componentDecl;
    165         private String context;
    166         private boolean isProtected;
     163        private final SrcClassDecl classDecl;
     164        private final SrcComponentDecl componentDecl;
     165        private final String context;
     166        private final boolean isProtected;
    167167       
    168168        public ResolvedAccess(SrcClassDecl classDecl, SrcComponentDecl componentDecl, String context, boolean isProtected) {
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/source/SourceTraversal.jrag

    r13294 r13896  
    9090    syn Iterable<SrcComponentDecl> SrcEnumClassDecl.componentsIterable() = super.components();
    9191    syn SrcEnumClassDecl SrcEnumClassDecl.enumBase() =
    92         ((SourceRoot) root()).getProgram().getEnumBaseDecl();
     92        root().asSourceRoot().getProgram().getEnumBaseDecl();
    9393   
    9494    syn Iterable<SrcModificationOrRedeclareElement> SrcClassDecl.elementModifications();
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/util/Annotations.jrag

    r13294 r13896  
    9191    public class FClass            implements FAttributeListAnnotationNode.FAttributeList {}
    9292    public class FAttribute        implements FAttributeListAnnotationNode.FAttributeList {}
     93    public class FExternalStmt     implements FAttributeListAnnotationNode.FAttributeList {}
    9394   
    9495    eq FFunctionDecl.annotation(InstContext instContext)     = new FAttributeListAnnotationNode(this, instContext);
     
    9697    eq FAbstractEquation.annotation(InstContext instContext) = new FAttributeListAnnotationNode(this, instContext);
    9798    eq FClass.annotation(InstContext instContext)            = new FAttributeListAnnotationNode(this, instContext);
     99    eq FExternalStmt.annotation(InstContext instContext)     = new FAttributeListAnnotationNode(this, instContext);
    98100
    99101    eq InstExternal.annotation() = annotation(annotationExpEvaluator());
     
    236238        myTargetInstClassDecl().addAnnotationToEvaluator(list, this);
    237239        return list;
     240    }
     241    eq InstLibNode.annotations() {
     242        return resolveLib().annotations();
    238243    }
    239244
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/jastadd/util/Util.jrag

    r13476 r13896  
    15841584
    15851585    syn boolean SrcBaseNode.isLibNode() = false;
    1586     eq SrcLibNode.isLibNode()            = true;
     1586    eq SrcLibNode.isLibNode()           = true;
     1587    syn SrcLibNode SrcBaseNode.asSrcLibNode() {
     1588        throw new UnsupportedOperationException();
     1589    }
     1590    syn SrcLibNode SrcLibNode.asSrcLibNode() = this;
    15871591}
    15881592
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/GUIDManager.java

    r13396 r13896  
    22
    33import java.io.BufferedReader;
    4 import java.io.BufferedWriter;
     4import java.io.ByteArrayInputStream;
    55import java.io.ByteArrayOutputStream;
    66import java.io.File;
    7 import java.io.FileNotFoundException;
    8 import java.io.FileReader;
    9 import java.io.FileWriter;
    107import java.io.IOException;
    11 import java.io.OutputStreamWriter;
    12 import java.io.Reader;
    13 import java.io.StringReader;
    14 import java.io.Writer;
     8import java.io.InputStream;
     9import java.io.InputStreamReader;
     10import java.io.OutputStream;
     11import java.io.PrintWriter;
    1512import java.math.BigInteger;
    1613import java.nio.charset.Charset;
     14import java.nio.file.Files;
     15import java.nio.file.Path;
    1716import java.security.MessageDigest;
    1817import java.security.NoSuchAlgorithmException;
     
    6564
    6665    public void setSourceFile(File source) {
     66        this.source = new FileOpenable(source.toPath());
     67    }
     68
     69    public void setSourceFile(Path source) {
    6770        this.source = new FileOpenable(source);
    6871    }
     
    7376
    7477    public void addDependentFile(File dependentFile) {
     78        dependentFiles.add(new FileOpenable(dependentFile.toPath()));
     79    }
     80
     81    public void addDependentFile(Path dependentFile) {
    7582        dependentFiles.add(new FileOpenable(dependentFile));
    7683    }
    7784
    78     public void addDependentString(String input, StringBuilder output) {
     85    public void addDependentString(String input, ByteArrayOutputStream output) {
    7986        dependentFiles.add(new StringOpenable(input, output));
    8087    }
     
    8592            final MessageDigest md5 = MessageDigest.getInstance("MD5");
    8693
    87             try (final BufferedReader reader = new BufferedReader(source.openInput())) {
     94            try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source.openInput()))) {
    8895                String line = reader.readLine();
    8996                while (line != null) {
     
    118125        for (final Openable openable : dependentFiles) {
    119126            try {
    120                 ByteArrayOutputStream os = new ByteArrayOutputStream();
    121                 try (final Writer tmp = new OutputStreamWriter(os)) {
    122                     processFiles(openable.openInput(), tmp);
    123                 }
    124 
    125                 try (BufferedWriter writer = new BufferedWriter(openable.openOutput())) {
    126                     writer.append(os.toString());
     127                try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
     128                    processFiles(openable.openInput(), os);
     129                    try (PrintWriter writer = new PrintWriter(openable.openOutput())) {
     130                        writer.append(os.toString());
     131                    }
    127132                }
    128133            } catch (IOException e) {
     
    132137    }
    133138
    134     private void processFiles(Reader source, Writer destination) throws IOException {
    135         try (final BufferedReader reader = new BufferedReader(source);
    136                 final BufferedWriter writer = new BufferedWriter(destination)) {
     139    private void processFiles(InputStream source, OutputStream destination) throws IOException {
     140        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source));
     141             final PrintWriter writer = new PrintWriter(destination)) {
    137142
    138143            String line =  reader.readLine();
     
    200205
    201206    private static interface Openable {
    202         public Reader openInput();
    203         public Writer openOutput();
     207        public InputStream openInput();
     208        public OutputStream openOutput();
    204209    }
    205210   
    206     private static class FileOpenable implements Openable{
    207         private File file;
    208        
    209         public FileOpenable(File file) {
    210             this.file = file;
    211         }
    212        
    213         @Override
    214         public Reader openInput() {
     211    private static class FileOpenable implements Openable {
     212        private Path path;
     213       
     214        public FileOpenable(Path file) {
     215            this.path = file;
     216        }
     217       
     218        @Override
     219        public InputStream openInput() {
    215220            try {
    216                 return new FileReader(file);
    217             } catch (FileNotFoundException e) {
    218                 throw new RuntimeException(e);
    219             }
    220         }
    221        
    222         @Override
    223         public Writer openOutput() {
    224             try {
    225                 return new FileWriter(file);
     221                return Files.newInputStream(path);
    226222            } catch (IOException e) {
    227223                throw new RuntimeException(e);
     
    230226       
    231227        @Override
     228        public OutputStream openOutput() {
     229            try {
     230                return Files.newOutputStream(path);
     231            } catch (IOException e) {
     232                throw new RuntimeException(e);
     233            }
     234        }
     235       
     236        @Override
    232237        public String toString() {
    233             return file.toString();
     238            return path.toString();
    234239        }
    235240    }
     
    238243       
    239244        private String input;
    240         private StringBuilder output;
    241        
    242         public StringOpenable(String input, StringBuilder output) {
     245        private ByteArrayOutputStream output;
     246       
     247        public StringOpenable(String input, ByteArrayOutputStream output) {
    243248            this.input = input;
    244249            this.output = output;
     
    246251       
    247252        @Override
    248         public Reader openInput() {
    249             return new StringReader(input);
    250         }
    251        
    252         @Override
    253         public Writer openOutput() {
    254             return new Writer() {
    255                
    256                 @Override
    257                 public void write(char[] cbuf, int off, int len) throws IOException {
    258                     output.append(cbuf, off, len);
    259                 }
    260                
    261                 @Override
    262                 public void flush() throws IOException {
    263                     // Do nothing
    264                 }
    265                
    266                 @Override
    267                 public void close() throws IOException {
    268                     // Do nothing
    269                 }
    270             };
     253        public InputStream openInput() {
     254            return new ByteArrayInputStream(input.getBytes());
     255        }
     256       
     257        @Override
     258        public OutputStream openOutput() {
     259            return output;
    271260        }
    272261    }
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessCache.java

    r10910 r13896  
    2424
    2525    protected abstract void tearDown();
    26 
    27     public abstract ExternalFunction<K, V> failedEval(External<?> ext, String msg, boolean log);
    2826   
    2927
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessCacheImpl.java

    r12940 r13896  
    33import java.io.File;
    44import java.io.FileNotFoundException;
    5 import java.io.IOException;
    65import java.io.PrintStream;
    76import java.util.ArrayList;
     7import java.util.Arrays;
     8import java.util.Collection;
    89import java.util.HashMap;
     10import java.util.HashSet;
    911import java.util.LinkedHashSet;
    1012import java.util.Map;
    11 
    12 import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Compiler;
     13import java.util.Set;
     14
    1315import org.jmodelica.common.evaluation.ExternalProcessMultiCache.External;
    1416import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Type;
     
    1618import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Variable;
    1719import org.jmodelica.util.EnvironmentUtils;
     20import org.jmodelica.util.SystemUtil;
    1821import org.jmodelica.util.ccompiler.CCompilerDelegator;
    1922import org.jmodelica.util.exceptions.CcodeCompilationException;
    2023import org.jmodelica.util.logging.ModelicaLogger;
    21 import org.jmodelica.util.values.ConstantEvaluationException;
    2224
    2325public class ExternalProcessCacheImpl<K extends Variable<V, T>, V extends Value, T extends Type<V>, E extends External<K>> extends ExternalProcessCache<K, V, T, E> {
     
    2628     * Maps external functions names to compiled executables.
    2729     */
    28     private Map<String, ExternalFunction<K, V>> cachedExternals = new HashMap<String, ExternalFunction<K, V>>();
     30    private final Map<String, ExternalFunction<K, V>> cachedExternals = new HashMap<String, ExternalFunction<K, V>>();
    2931
    3032    /**
    3133     * Keeps track of all living processes, least recently used first.
    3234     */
    33     private LinkedHashSet<ExternalFunction<K, V>> livingCachedExternals = new LinkedHashSet<ExternalFunction<K, V>>();
    34 
    35     private Compiler<K, E> mc;
    36 
    37     public ExternalProcessCacheImpl(Compiler<K, E> mc) {
     35    private final LinkedHashSet<ExternalFunction<K, V>> livingCachedExternals = new LinkedHashSet<ExternalFunction<K, V>>();
     36
     37    private final ExternalFunctionCompiler<K, E> mc;
     38
     39    public ExternalProcessCacheImpl(ExternalFunctionCompiler<K, E> mc) {
    3840        this.mc = mc;
    3941    }
     
    4244        return mc.log();
    4345    }
    44 
     46   
     47    private String getPlatform() {
     48        return CCompilerDelegator.reduceBits(EnvironmentUtils.getJavaPlatform(),
     49                mc.getCCompiler().getTargetPlatforms());
     50    }
     51   
     52    private String getSharedLibrary(External<K> ext) {
     53        String sharedLib = "";
     54        String extLibrary = "";
     55       
     56        if (ext.library() != null && ext.library().length == 1) {
     57            extLibrary = ext.library()[0];
     58        } else {
     59            return sharedLib;
     60        }
     61       
     62        HashSet<String> externalLibraryDirectories = new HashSet<String>();
     63        externalLibraryDirectories.add(ext.libraryDirectory());
     64        Set<String> expandedLibDirs = mc.getCCompiler().expandCompilerSpecificLibraryPaths(mc.log(), ext.myOptions(),
     65                                                   externalLibraryDirectories, getPlatform());
     66       
     67        for (String dir : expandedLibDirs) {
     68            File testlib1 = new File(dir, extLibrary + SystemUtil.sharedLibraryExtension());
     69            File testlib2 = new File(dir, "lib" + extLibrary + SystemUtil.sharedLibraryExtension());
     70           
     71            if (testlib1.exists() && !testlib1.isDirectory()) {
     72                sharedLib = testlib1.toString();
     73                break;
     74            }
     75            if (testlib2.exists() && !testlib2.isDirectory()) {
     76                sharedLib = testlib2.toString();
     77                break;
     78            }
     79        }
     80       
     81        return sharedLib;
     82    }
     83   
     84    private static Collection<String> builtinExternalFunctions = Arrays.asList(
     85        "ModelicaStrings_substring",
     86        "ModelicaStrings_length",
     87        "ModelicaStrings_skipWhiteSpace",
     88        "ModelicaStrings_compare"
     89    );
     90   
     91    private static Collection<String> supportedSignatures = Arrays.asList(
     92        "d+d,d,",
     93        "d+i,",
     94        "d+i,d,d,",
     95        "s+s,i,i,",
     96        "i+s,",
     97        "i+s,i,",
     98        "i+s,s,i,",
     99        "i+i,i,",
     100        "void+i,d,d,*R[d,d,d,d,d,d,d,d,d,d,d,],",
     101        "void+d,d,*d,"
     102    );
     103   
     104    public boolean canUseEvaluator(E ext, ArrayList<String> arguments) {
     105        if (!ext.dynamicEvaluatorEnabled()) {
     106            return false;
     107        }
     108       
     109        String sharedLibrary = getSharedLibrary(ext);
     110        String functionName  = ext.getName();
     111        String outputArguments = ext.functionReturnArgSerialized();
     112        String inputArguments  = ext.functionArgsSerialized();
     113       
     114        if (sharedLibrary.equals("")) {
     115            if (builtinExternalFunctions.contains(functionName)) {
     116                sharedLibrary = "NoSharedLibrary";
     117            } else {
     118                mc.log().debug("Could not find a shared library containing '" + functionName + "'. Disabling use of the evaluator...");
     119                return false;
     120            }
     121        }
     122       
     123        if (!supportedSignatures.contains(outputArguments+"+"+inputArguments)) {
     124            mc.log().debug("The function signature, outputs '" + outputArguments + "', inputs '" + inputArguments + "', is not supported. Disabling use of the evaluator...");
     125            return false;
     126        }
     127       
     128        arguments.add(sharedLibrary);
     129        arguments.add(functionName);
     130        arguments.add(outputArguments);
     131        arguments.add(inputArguments);
     132
     133        return true;
     134    }
     135   
    45136    @Override
    46137    public ExternalFunction<K, V> getExternalFunction(E ext) {
     
    48139        if (ef == null) {
    49140            if (mc == null) {
    50                 return failedEval(ext, "Missing ModelicaCompiler", false);
     141                return FailedExternalFunction.<K,V,T,E>failedEval(mc, ext, "Missing ModelicaCompiler", false);
    51142            }
    52143            try {
    53144                long time = System.currentTimeMillis();
    54                 String executable = mc.compileExternal(ext);
    55                 if (ext.shouldCacheProcess()) {
    56                     ef = new MappedExternalFunction(ext, executable);
     145                String executable = null;
     146                ArrayList<String> arguments = new ArrayList<String>();
     147                String debugMsg = "";
     148                ExternalFunctionExecutable extFunctionExecutable;
     149                if (canUseEvaluator(ext, arguments)) {
     150                    String jmHome = System.getenv("JMODELICA_HOME");
     151                    String bits = getPlatform().contains("64") && SystemUtil.isWindows() ? "64" : "";
     152                    executable = jmHome + File.separator + "bin" + bits + File.separator + "jmi_evaluator" + SystemUtil.executableExtension();
     153                   
     154                    arguments.add(0, executable); /* Needs to be first */
     155                   
     156                    extFunctionExecutable = new ExternalFunctionExecutableDynamic(arguments);
     157                   
     158                    debugMsg = "Succesfully connected external function '" + ext.getName() + "' to the evaluator '"
     159                            + executable + "' with outputs: '" + ext.functionReturnArgSerialized() + "' and inputs: '" + ext.functionArgsSerialized() + "'";
    57160                } else {
    58                     ef = new CompiledExternalFunction(ext, executable);
     161                    executable = mc.compileExternal(ext);
     162                   
     163                    extFunctionExecutable = new ExternalFunctionExecutableGenerated(executable);
     164                   
     165                    debugMsg = "Succesfully compiled external function '" + ext.getName() + "' to executable '"
     166                            + executable + "' code for evaluation";
     167                }
     168               
     169                if (ext.processLimit() > 0) {
     170                    ef = new MappedExternalFunction<K,V,T,E>(mc, ext, extFunctionExecutable, livingCachedExternals);
     171                } else {
     172                    ef = new ExternalFunctionImpl<K,V,T,E>(mc, ext, extFunctionExecutable);
    59173                }
    60174                time = System.currentTimeMillis() - time;
    61                 mc.log().debug("Succesfully compiled external function '" + ext.getName() + "' to executable '"
    62                         + executable + "' code for evaluation, time: " + time + "ms");
     175                mc.log().debug(debugMsg +", time: " + time + "ms");
    63176            } catch (FileNotFoundException e) {
    64                 ef = failedEval(ext, "c-code generation failed '" + e.getMessage() + "'", true);
     177                ef = FailedExternalFunction.<K,V,T,E>failedEval(mc, ext, "c-code generation failed '" + e.getMessage() + "'", true);
    65178                mc.log().debug(ef.getMessage());
    66179            } catch (CcodeCompilationException e) {
    67                 ef = failedEval(ext, "c-code compilation failed '" + e.getMessage() + "'", true);
     180                ef = FailedExternalFunction.<K,V,T,E>failedEval(mc, ext, "c-code compilation failed '" + e.getMessage() + "'", true);
    68181                mc.log().debug(ef.getMessage());
    69182                e.printStackTrace(new PrintStream(mc.log().debugStream()));
     
    95208    }
    96209
    97     @Override
    98     public ExternalFunction<K, V> failedEval(External<?> ext, String msg, boolean log) {
    99         return new FailedExternalFunction(failedEvalMsg(ext.getName(), msg), log);
    100     }
    101 
    102     public static String failedEvalMsg(String name, String msg) {
    103         return "Failed to evaluate external function '" + name + "', " + msg;
    104     }
    105 
    106     private class FailedExternalFunction implements ExternalFunction<K, V> {
    107         private String msg;
    108         private boolean log;
    109 
    110         public FailedExternalFunction(String msg, boolean log) {
    111             this.msg = msg;
    112             this.log = log;
    113         }
    114 
    115         @Override
    116         public String getMessage() {
    117             return msg;
    118         }
    119 
    120         @Override
    121         public int evaluate(External<K> ext, Map<K, V> values, int timeout) throws IOException {
    122             if (log) {
    123                 log().debug("Evaluating failed external function: " + ext.getName());
    124             }
    125             throw new ConstantEvaluationException(null, getMessage());
    126         }
    127 
    128         @Override
    129         public void destroyProcess() {
    130             // Do nothing
    131         }
    132 
    133         @Override
    134         public void remove() {
    135             // Do nothing
    136         }
    137     }
    138 
    139     /**
    140      * Represents an external function that has been compiled successfully.
    141      */
    142     private class CompiledExternalFunction implements ExternalFunction<K, V> {
    143         protected String executable;
    144         protected ProcessBuilder processBuilder;
    145         private String msg;
    146 
    147         public CompiledExternalFunction(External<K> ext, String executable) {
    148             this.executable = executable;
    149             this.processBuilder = createProcessBuilder(ext);
    150             this.msg = "Succesfully compiled external function '" + ext.getName() + "'";
    151         }
    152 
    153         @Override
    154         public String getMessage() {
    155             return msg;
    156         }
    157 
    158         protected ProcessCommunicator<V, T> createProcessCommunicator() throws IOException {
    159             return new ProcessCommunicator<V, T>(mc, processBuilder.start());
    160         }
    161 
    162         @Override
    163         public int evaluate(External<K> ext, Map<K, V> values, int timeout) throws IOException {
    164             log().debug("Evaluating compiled external function: " + ext.getName());
    165             ProcessCommunicator<V, T> com = null;
    166             try {
    167                 com = createProcessCommunicator();
    168                 setup(ext, values, timeout, com);
    169                 evaluate(ext, values, timeout, com);
    170                 return teardown(timeout, com);
    171             } finally {
    172                 if (com != null) {
    173                     com.destroy();
    174                 }
    175             }
    176         }
    177 
    178         public void setup(External<K> ext, Map<K, V> values, int timeout, ProcessCommunicator<V, T> com)
    179                 throws IOException {
    180             com.startTimer(timeout);
    181             com.accept("START");
    182             for (K eo : ext.externalObjectsToSerialize()) {
    183                 com.put(values.containsKey(eo) ? values.get(eo) : eo.ceval(), eo.type());
    184             }
    185             com.accept("READY");
    186             com.cancelTimer();
    187         }
    188 
    189         public void evaluate(External<K> ext, Map<K, V> values, int timeout, ProcessCommunicator<V, T> com)
    190                 throws IOException {
    191             com.startTimer(timeout);
    192             com.check("EVAL");
    193 
    194             for (K arg : ext.functionArgsToSerialize()) {
    195                 com.put(values.containsKey(arg) ? values.get(arg) : arg.ceval(), arg.type());
    196             }
    197             com.accept("CALC");
    198             com.accept("DONE");
    199             for (K cvd : ext.varsToDeserialize())
    200                 values.put(cvd, com.get(cvd.type()));
    201             com.accept("READY");
    202             com.cancelTimer();
    203         }
    204 
    205         public int teardown(int timeout, ProcessCommunicator<V, T> com) throws IOException {
    206             com.startTimer(timeout);
    207             com.check("EXIT");
    208             com.accept("END");
    209             int result = com.end();
    210             com.cancelTimer();
    211             // log().debug("SUCCESS TEARDOWN");
    212             return result;
    213         }
    214 
    215         @Override
    216         public void destroyProcess() {
    217             // Do nothing
    218         }
    219 
    220         @Override
    221         public void remove() {
    222             new File(executable).delete();
    223         }
    224 
    225         private ProcessBuilder createProcessBuilder(External<K> ext) {
    226             ProcessBuilder pb = new ProcessBuilder(executable);
    227             Map<String, String> env = pb.environment();
    228             if (env.keySet().contains("Path")) {
    229                 env.put("PATH", env.get("Path"));
    230                 env.remove("Path");
    231             }
    232             pb.redirectErrorStream(true);
    233             if (ext.libraryDirectory() != null) {
    234                 // Update environment in case of shared library
    235                 String platform = CCompilerDelegator.reduceBits(EnvironmentUtils.getJavaPlatform(),
    236                         mc.getCCompiler().getTargetPlatforms());
    237                 File f = new File(ext.libraryDirectory(), platform);
    238                 String libLoc = f.isDirectory() ? f.getPath() : ext.libraryDirectory();
    239                 appendPath(env, libLoc, platform);
    240             }
    241             return pb;
    242         }
    243 
    244         /**
    245          * Append a library location <code>libLoc</code> to the path variable in
    246          * environment <code>env</code>.
    247          */
    248         private void appendPath(Map<String, String> env, String libLoc, String platform) {
    249             String sep = platform.startsWith("win") ? ";" : ":";
    250             String var = platform.startsWith("win") ? "PATH" : "LD_LIBRARY_PATH";
    251             String res = env.get(var);
    252             if (res == null)
    253                 res = libLoc;
    254             else
    255                 res = res + sep + libLoc;
    256             env.put(var, res);
    257         }
    258     }
    259 
    260     /**
    261      * A CompiledExternalFunction which can cache several processes with external
    262      * object constructor only called once.
    263      */
    264     private class MappedExternalFunction extends CompiledExternalFunction {
    265 
    266         private Map<String, ExternalFunction<K, V>> lives = new HashMap<>();
    267 
    268         private final int externalConstantEvaluationMaxProc;
    269 
    270         public MappedExternalFunction(External<K> ext, String executable) {
    271             super(ext, executable);
    272             externalConstantEvaluationMaxProc = ext.myOptions()
    273                     .getIntegerOption("external_constant_evaluation_max_proc");
    274         }
    275 
    276         /**
    277          * Find a LiveExternalFunction based on the external object of this external
    278          * function. Start a new process if not up already. Failure to set up (call
    279          * constructor) will cache and return a Failed external function.
    280          */
    281         private ExternalFunction<K, V> getActual(External<K> ext, Map<K, V> values, int timeout) {
    282             Variable<V, T> cvd = ext.cachedExternalObject();
    283             String name = cvd == null ? "" : cvd.ceval().getMarkedExternalObject();
    284             ExternalFunction<K, V> ef = lives.get(name);
    285             if (ef == null) {
    286                 LiveExternalFunction lef = new LiveExternalFunction();
    287                 try {
    288                     lef.ready(ext, values, timeout);
    289                     ef = lef;
    290                 } catch (IOException e) {
    291                     lef.destroyProcess();
    292                     ef = failedEval(ext, " error starting process '" + e.getMessage() + "'", true);
    293                 } catch (ConstantEvaluationException e) {
    294                     lef.destroyProcess();
    295                     ef = failedEval(ext, " error starting process '" + e.getMessage() + "'", true);
    296                 }
    297                 lives.put(name, ef);
    298             }
    299             return ef;
    300         }
    301 
    302         @Override
    303         public int evaluate(External<K> ext, Map<K, V> values, int timeout) throws IOException {
    304             return getActual(ext, values, timeout).evaluate(ext, values, timeout);
    305         }
    306 
    307         @Override
    308         public void destroyProcess() {
    309             for (ExternalFunction<K, V> ef : lives.values()) {
    310                 ef.destroyProcess();
    311             }
    312             lives.clear();
    313         }
    314 
    315         /**
    316          * Represents a (possible) living external function process.
    317          */
    318         private class LiveExternalFunction implements ExternalFunction<K, V> {
    319 
    320             protected ProcessCommunicator<V, T> com;
    321 
    322             public LiveExternalFunction() {
    323                 super();
    324             }
    325 
    326             @Override
    327             public String getMessage() {
    328                 return MappedExternalFunction.this.getMessage();
    329             }
    330 
    331             @Override
    332             public int evaluate(External<K> ext, Map<K, V> values, int timeout) throws IOException {
    333                 log().debug("Evaluating live external function: " + ext.getName());
    334                 try {
    335                     ready(ext, values, timeout);
    336                     long time = System.currentTimeMillis();
    337                     MappedExternalFunction.this.evaluate(ext, values, timeout, com);
    338                     time = System.currentTimeMillis() - time;
    339                     log().debug("Finished evaluating live external function, time: " + time + "ms");
    340                 } catch (ProcessCommunicator.AbortConstantEvaluationException e) {
    341 
    342                 } catch (ConstantEvaluationException e) {
    343                     destroyProcess();
    344                     throw e;
    345                 } catch (IOException e) {
    346                     destroyProcess();
    347                     throw e;
    348                 }
    349                 return 0;
    350             }
    351 
    352             /**
    353              * Make sure process is ready for evaluation call.
    354              */
    355             protected void ready(External<K> ext, Map<K, V> values, int timeout) throws IOException {
    356                 if (com == null) {
    357                     long time1 = System.currentTimeMillis();
    358                     // Start process if not live.
    359                     com = createProcessCommunicator();
    360                     long time2 = System.currentTimeMillis();
    361                     // Send external object constructor inputs
    362                     MappedExternalFunction.this.setup(ext, values, timeout, com);
    363                     long time3 = System.currentTimeMillis();
    364                     log().debug("Setup live external function: " + ext.getName()
    365                               + ", createProcessCommunicator() time: " + (time2 - time1)
    366                               + "ms, setup time: " + (time3 - time2) + "ms");
    367                 }
    368 
    369                 // Mark as most recently used
    370                 livingCachedExternals.remove(this);
    371                 livingCachedExternals.add(this);
    372 
    373                 // If we are over the allowed number of cached processes
    374                 // we kill the least recently used.
    375                 if (livingCachedExternals.size() > externalConstantEvaluationMaxProc) {
    376                     livingCachedExternals.iterator().next().destroyProcess();
    377                 }
    378             }
    379 
    380             @Override
    381             public void destroyProcess() {
    382                 if (com != null) {
    383                     livingCachedExternals.remove(this);
    384                     com.destroy();
    385                     com = null;
    386                 }
    387             }
    388 
    389             @Override
    390             public void remove() {
    391                 // Removing this executable is handled by surrounding MappedExternalFunction
    392                 throw new UnsupportedOperationException();
    393             }
    394         }
    395     }
    396210}
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalProcessMultiCache.java

    r13252 r13896  
    22
    33import java.io.BufferedWriter;
    4 import java.io.FileNotFoundException;
    54import java.io.IOException;
    65import java.util.LinkedHashMap;
    76import java.util.Map;
    87
    9 import org.jmodelica.common.LogContainer;
    108import org.jmodelica.common.options.AbstractOptionRegistry;
    11 import org.jmodelica.util.ccompiler.CCompilerDelegator;
    12 import org.jmodelica.util.exceptions.CcodeCompilationException;
    139
    1410public class ExternalProcessMultiCache<K extends ExternalProcessMultiCache.Variable<V, T>, V extends ExternalProcessMultiCache.Value, T extends ExternalProcessMultiCache.Type<V>, E extends ExternalProcessMultiCache.External<K>> {
    15 
    16     public interface Compiler<K, E extends External<K>> extends LogContainer {
    17         public String compileExternal(E ext) throws FileNotFoundException, CcodeCompilationException;
    18 
    19         public CCompilerDelegator getCCompiler();
    20     }
    2111
    2212    public interface External<K> {
    2313        public String getName();
    2414
    25         public boolean shouldCacheProcess();
     15        public int processLimit();
     16
     17        public boolean dynamicEvaluatorEnabled();
    2618
    2719        public AbstractOptionRegistry myOptions();
     
    3527        public Iterable<K> functionArgsToSerialize();
    3628
     29        public String functionArgsSerialized();
     30
     31        public String functionReturnArgSerialized();
     32
    3733        public Iterable<K> varsToDeserialize();
     34
     35        public String[] library();
    3836    }
    3937
     
    5654    private Map<String, ExternalProcessCache<K, V, T, E>> map = new LinkedHashMap<>();
    5755
    58     private Compiler<K, E> mc;
     56    private ExternalFunctionCompiler<K, E> mc;
    5957
    60     public ExternalProcessMultiCache(Compiler<K, E> mc) {
     58    public ExternalProcessMultiCache(ExternalFunctionCompiler<K, E> mc) {
    6159        this.mc = mc;
    6260    }
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ProcessCommunicator.java

    r12940 r13896  
    4949    private String getLine() throws IOException {
    5050        String line = buffLine;
    51         if (line == null)
     51        if (line == null) {
    5252            line = in.readLine();
     53        }
    5354        if (line == null) {
    5455            if (timeOutHappened) {
     
    110111            String format = deserializeString();
    111112            String value = deserializeString();
    112             if (warning != 0)
     113            if (warning != 0) {
    113114                mc.log().warning("%s: " + format, name, value);
    114             else
     115            } else {
    115116                mc.log().verbose("%s: " + format, name, value);
     117            }
    116118            line = getLine();
    117119        }
     
    133135            super(null, string);
    134136        }
     137    }
     138
     139    public int teardown(int timeout) throws IOException {
     140        startTimer(timeout);
     141        check("EXIT");
     142        accept("END");
     143        int result = end();
     144        cancelTimer();
     145        return result;
    135146    }
    136147
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/options/AbstractOptionRegistry.java

    r13252 r13896  
    4040 * to get an option registry populated with all available options.
    4141 */
     42@SuppressWarnings("javadoc")
    4243public abstract class AbstractOptionRegistry {
    4344
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/separateProcess/CompilerInstance.java

    r13396 r13896  
    274274         * {@link org.jmodelica.modelica.compiler.ModelicaCompiler ModelicaCompiler}.
    275275         */
     276        @SuppressWarnings("javadoc")
    276277        MODELICA("org.jmodelica.modelica.compiler.ModelicaCompiler"),
    277278
     
    279280         * {@link org.jmodelica.optimica.compiler.OptimicaCompiler OptimicaCompiler}.
    280281         */
     282        @SuppressWarnings("javadoc")
    281283        OPTIMICA("org.jmodelica.optimica.compiler.OptimicaCompiler");
    282284
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/MemorySpider.java

    r12940 r13896  
    145145        private Field field;
    146146       
    147         public Object perform(Field f, Object o) {
     147        @SuppressWarnings("deprecation")
     148        public Object perform(Field f, Object o) {
    148149            field = f;
    149150            if (!f.isAccessible())
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/SystemUtil.java

    r11394 r13896  
    7272        return isLinux() ? "" : ".exe";
    7373    }
     74   
     75    public static String sharedLibraryExtension() {
     76        if (isWindows()) {
     77            return ".dll";
     78        } else if (isLinux()) {
     79            return ".so";
     80        } else {
     81            return ".dylib";
     82        }
     83    }
    7484
    7585    /**
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/files/FileUtil.java

    r11394 r13896  
    33import java.io.File;
    44import java.io.IOException;
     5import java.nio.file.DirectoryStream;
    56import java.nio.file.Files;
     7import java.nio.file.Path;
    68import java.nio.file.Paths;
    79import java.nio.file.StandardCopyOption;
     
    155157        return names;
    156158    }
     159   
     160    /**
     161     * @return A collection of all files in {@code dir} matching the {@code glob}
     162     *         pattern
     163     */
     164    public static Collection<Path> getMatching(Path dir, String glob) throws IOException {
     165        Collection<Path> res = new ArrayList<>();
     166        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, glob)) {
     167            for (Path path : stream) {
     168                res.add(path);
     169            }
     170        }
     171        return res;
     172    }
    157173
    158174    /**
     
    234250     *             if there was any error copying the files.
    235251     */
    236     public static void copyRecursive(Collection<File> files, File destination, boolean replace) throws IOException {
     252    public static void copyRecursive(Iterable<File> files, File destination, boolean replace) throws IOException {
    237253        for (File file : files) {
    238254            copyRecursive(file, destination, replace);
     255        }
     256    }
     257   
     258    /**
     259     * Copies file to a directory. Contents of directories is copied recursively.
     260     *
     261     * @param sourceFile
     262     *            The file to copy.
     263     * @param destDir
     264     *            The destination directory.
     265     * @throws IOException
     266     *             if there was any error copying the files.
     267     */
     268    public static void copyRecursive(Path sourceFile, Path destDir) throws IOException {
     269        Path outFile = destDir.resolve(sourceFile.getFileName());
     270        if (Files.isDirectory(sourceFile)) {
     271            if (!Files.exists(outFile)) {
     272                Files.createDirectory(outFile);
     273            }
     274            try (DirectoryStream<Path> stream = Files.newDirectoryStream(sourceFile)) {
     275                copyRecursive(stream, outFile);
     276            }
     277        } else {
     278            Files.copy(sourceFile, outFile, StandardCopyOption.REPLACE_EXISTING);
     279        }
     280    }
     281   
     282    /**
     283     * Copies several files to a directory.
     284     *
     285     * @param sourceFiles
     286     *            The files to copy.
     287     * @param destDir
     288     *            The destination directory.
     289     * @throws IOException
     290     *             if there was any error copying the files.
     291     */
     292    public static void copyRecursive(Iterable<Path> sourceFiles, Path destDir) throws IOException {
     293        for (Path file : sourceFiles) {
     294            copyRecursive(file, destDir);
    239295        }
    240296    }
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/logging/PipeLogger.java

    r12984 r13896  
    7272    }
    7373
     74    @SuppressWarnings("deprecation")
    7475    @Override
    7576    protected void finalize() throws Throwable {
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/ExternalProcessCacheTest.java

    r13274 r13896  
    99import java.io.IOException;
    1010
     11import org.jmodelica.common.evaluation.ExternalFunctionCompiler;
     12import org.jmodelica.common.evaluation.ExternalFunction;
    1113import org.jmodelica.common.evaluation.ExternalProcessCache;
    12 import org.jmodelica.common.evaluation.ExternalFunction;
    1314import org.jmodelica.common.evaluation.ExternalProcessMultiCache;
     15import org.jmodelica.common.evaluation.ExternalProcessMultiCache.External;
     16import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Type;
     17import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Value;
    1418import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Variable;
     19import org.jmodelica.common.evaluation.ProcessCommunicator;
    1520import org.jmodelica.common.options.AbstractOptionRegistry;
    16 import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Value;
    17 import org.jmodelica.common.evaluation.ExternalProcessMultiCache.Type;
    18 import org.jmodelica.common.evaluation.ExternalProcessMultiCache.External;
    19 import org.jmodelica.common.evaluation.ProcessCommunicator;
    2021import org.jmodelica.util.ccompiler.CCompilerDelegator;
    2122import org.jmodelica.util.exceptions.CcodeCompilationException;
     
    7475    class ExternalProcessCacheMock<K extends Variable<V,T>, V extends Value, T extends Type<V>, E extends External<K>> extends ExternalProcessMultiCache<K,V,T,E> {
    7576
    76         public ExternalProcessCacheMock(Compiler<K,E> mc) {
     77        public ExternalProcessCacheMock(ExternalFunctionCompiler<K,E> mc) {
    7778            super(mc);
    7879        }
     
    108109        }
    109110
    110         @Override
    111         public ExternalFunction<K,V> failedEval(External<?> ext, String msg, boolean log) {
    112             // TODO Auto-generated method stub
    113             return null;
    114         }
    115        
    116     }
    117 
    118     class CompilerMock implements ExternalProcessMultiCache.Compiler<VariableMock, ExternalMock> {
     111    }
     112
     113    class CompilerMock implements ExternalFunctionCompiler<VariableMock, ExternalMock> {
    119114
    120115        @Override
     
    189184
    190185        @Override
    191         public boolean shouldCacheProcess() {
    192             // TODO Auto-generated method stub
     186        public int processLimit() {
     187            // TODO Auto-generated method stub
     188            return 0;
     189        }
     190
     191        @Override
     192        public boolean dynamicEvaluatorEnabled() {
    193193            return false;
    194194        }
     
    223223            return null;
    224224        }
     225       
     226        @Override
     227        public String functionArgsSerialized() {
     228            // TODO Auto-generated method stub
     229            return null;
     230        }
     231       
     232        @Override
     233        public String functionReturnArgSerialized() {
     234            // TODO Auto-generated method stub
     235            return null;
     236        }
    225237
    226238        @Override
     
    229241            return null;
    230242        }
     243       
     244        @Override
     245        public String[] library() {
     246            // TODO Auto-generated method stub
     247            return null;
     248        }
    231249
    232250    }
  • branches/dev-mj-5835/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/GUIDManagerTest.java

    r13396 r13896  
    44import static org.junit.Assert.assertFalse;
    55import static org.junit.Assert.assertTrue;
     6
     7import java.io.ByteArrayOutputStream;
    68
    79import org.jmodelica.common.GUIDManager;
     
    2022    private void test(String source, String[] dependent, String[] expected) {
    2123        guidManager.setSourceString(source);
    22         StringBuilder[] output = new StringBuilder[dependent.length];
     24        ByteArrayOutputStream[] output = new ByteArrayOutputStream[dependent.length];
    2325        for (int i = 0; i < dependent.length; i++) {
    24             output[i] = new StringBuilder();
     26            output[i] = new ByteArrayOutputStream();
    2527            guidManager.addDependentString(dependent[i], output[i]);
    2628        }
     
    4749        String expected = "guid=277efff8e9f33c422aa6e3fecb8b592";
    4850        guidManager.setSourceString(input);
    49         StringBuilder output = new StringBuilder();
     51        ByteArrayOutputStream output = new ByteArrayOutputStream();
    5052        guidManager.addDependentString(input, output);
    5153        guidManager.processDependentFiles();
  • branches/dev-mj-5835/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/VariabilityPropagation.jrag

    r12119 r13896  
    2222     */
    2323    syn boolean FAbstractEquation.canPropagate(FClass.VariabilityPropagator propagator) =
    24             canPropagateContext(propagator) && !containsActiveAnnotations();
     24            canPropagateContext(propagator, false) && !containsActiveAnnotations();
    2525    eq FEquation.canPropagate(FClass.VariabilityPropagator propagator) =
    2626            super.canPropagate(propagator) && propagator.canPropagate(this);
     
    2929        return super.canPropagate(propagator) && propagator.variables(this).size() > 0 && numScalarEquations() > 0 &&
    3030                ((propagator.variables(this).size() == numScalarEquations() && getCall().variability().parameterOrLess())
    31                         || potentialPartialVariability().knownParameterOrLess());
     31                        || (potentialPartialVariability().knownParameterOrLess() && canPropagateContext(propagator, true)));
    3232    }
    3333    eq FAlgorithm.canPropagate(FClass.VariabilityPropagator propagator) =
     
    3636            propagator.variables(this).size() == numScalarEquations() && variabilityRHS().parameterOrLess();
    3737
    38     inh boolean FAbstractEquation   .canPropagateContext(FClass.VariabilityPropagator propagator);
    39     eq Root  .getChild()            .canPropagateContext(FClass.VariabilityPropagator propagator) = false;
    40     eq FClass.getFAbstractEquation().canPropagateContext(FClass.VariabilityPropagator propagator) = true;
    41     eq FClass.getFInitialEquation() .canPropagateContext(FClass.VariabilityPropagator propagator) =
     38    inh boolean FAbstractEquation   .canPropagateContext(FClass.VariabilityPropagator propagator, boolean partial);
     39    eq Root  .getChild()            .canPropagateContext(FClass.VariabilityPropagator propagator, boolean partial) = false;
     40    eq FClass.getFAbstractEquation().canPropagateContext(FClass.VariabilityPropagator propagator, boolean partial) = true;
     41    eq FClass.getFInitialEquation() .canPropagateContext(FClass.VariabilityPropagator propagator, boolean partial) =
    4242            propagator.propagateInitial();
    43     eq FIfWhenElseEquation.getChild().canPropagateContext(FClass.VariabilityPropagator propagator) =
    44             isTempAssign() && canPropagateContext(propagator);
     43    eq FIfWhenElseEquation.getChild().canPropagateContext(FClass.VariabilityPropagator propagator, boolean partial) =
     44            isTempAssign() && !partial && canPropagateContext(propagator, partial);
    4545
    4646    /**
  • branches/dev-mj-5835/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/Scalarization.jrag

    r13357 r13896  
    912912
    913913    public FTempAccessExp FExp.tempExp(String name, Index i) {
    914         FTempAccessExp res;
     914        FAccess access;
    915915        if (inFunction()) {
    916             res = new FTempAccessExp(new FAccessFull(name, i.createFArraySubscripts()));
     916            access = new FAccessFull(name, i.createFArraySubscripts());
    917917        } else {
    918             res = new FTempAccessExp(new FAccessString(name + i));
    919         }
    920         return (FTempAccessExp) dynamicFExp(res);
     918            access = new FAccessString(name + i);
     919        }
     920        return (FTempAccessExp) dynamicFExp(new FTempAccessExp(access));
    921921    }
    922922
    923923    public FTempAccessExp FExp.tempExp(String name, FArraySubscripts fas) {
    924         FTempAccessExp res;
     924        FAccess access;
    925925        if (inFunction()) {
    926             res = new FTempAccessExp(new FAccessFull(name, fas));
     926            if (fas == null) {
     927                access = new FAccessFull(name);
     928            } else {
     929                access = new FAccessFull(name, fas);
     930            }
    927931        } else {
    928932            if (fas == null) {
    929                 res = new FTempAccessExp(new FAccessString(name));
     933                access = new FAccessString(name);
    930934            } else {
    931                 res = new FTempAccessExp(new FAccessString(name + fas));
    932             }
    933         }
    934         return (FTempAccessExp) dynamicFExp(res);
     935                access = new FAccessString(name + fas);
     936            }
     937        }
     938        return (FTempAccessExp) dynamicFExp(new FTempAccessExp(access));
    935939    }
    936940
  • branches/dev-mj-5835/Compiler/ModelicaMiddleEnd/src/jastadd/scalarization/ScalarizeFunctions.jrag

    r12716 r13896  
    497497                List<FSubscript> subs = new List<FSubscript>();
    498498                subs.add(new FIntegerSubscript(i+1));
    499                 subs.addAll(names.createFArraySubscripts().copyAsFArrayExpSubscripts().getFSubscriptListNoTransform());
     499                if (names.hasNames()) {
     500                    subs.addAll(names.createFArraySubscripts().copyAsFArrayExpSubscripts().getFSubscriptListNoTransform());
     501                }
    500502                left = tempExp(new FArrayExpSubscripts(subs));
    501503                right.createArrayTemporaries(s);
     
    916918   
    917919    public void FAccessExp.addArrayUsesToIndexMap(Scalarizer s, FExp[] names) {
    918         if (!hasFArraySubscripts() && isArray())
     920        if (!hasFArraySubscripts() && myFV().isArray()) {
    919921            indexNames = names;
     922        }
    920923        super.addArrayUsesToIndexMap(s, names);
    921924    }
     
    12121215         * Creates a new FArraySubscripts with uses of the <code>d1</code> to <code>d2</code> names
    12131216         * in the top layer as subscripts. When out of names, adds 1s.
     1217         *
     1218         * Returns null if d1 == d2.
    12141219         */
    12151220        public FArrayExpSubscripts createFArraySubscripts(int d1, int d2) {
    1216             if (d1 < 0)
    1217                 throw new UnsupportedOperationException();
     1221            if (d1 == d2) {
     1222                return null;
     1223            }
    12181224            FArrayExpSubscripts fas = new FArrayExpSubscripts();
    12191225            for (int i = d1; i < d2; ++i) {
    1220                 if (i < topLayer().length)
     1226                if (i < topLayer().length) {
    12211227                    fas.addFSubscript(new FExpSubscript(new FTempAccessExp(new FAccessFull(topLayer()[i]))));
    1222                 else
     1228                } else {
    12231229                    fas.addFSubscript(new FIntegerSubscript(1));
     1230                }
    12241231            }
    12251232            return fas;
     
    12291236         * Creates a new FArraySubscripts with uses of the <code>d</code>
    12301237         * first names in the top layer as subscripts. When out of names, adds 1s.
     1238         * Returns null if d == 0.
    12311239         */
    12321240        public FArrayExpSubscripts createFArraySubscripts(int d) {
     
    12361244        /**
    12371245         * Creates a new FArraySubscripts with uses of all the names in the top layer.
     1246         * Returns null if no names available.
    12381247         */
    12391248        public FArrayExpSubscripts createFArraySubscripts() {
  • branches/dev-mj-5835/Compiler/ModelicaMiddleEnd/src/jastadd/structural/Symbolic.jrag

    r12811 r13896  
    121121                }
    122122            }
     123           
     124            if (activeTerms.isEmpty()) {
     125                return new FNoExp();
     126            }
     127               
    123128           
    124129            // Compute new expressions for the inactive and active terms
     
    182187                    negatedFactor = true;
    183188                } else if (ee.nbrUses(var.name())==0) {
    184                     if (ee.variability().constantVariability() &&
    185                             Math.abs(ee.ceval().realValue()) *
    186                             ee.dynamicFExp(var.nominal()).ceval().realValue() < tol) {
     189                    if (!nominalAllowsDivision(ee, var, tol)) {
    187190                        return new FNoExp();
    188191                    }
     
    207210        }
    208211        return FExp.createBalancedBinaryTree(new FAddExp(), parts);
     212    }
     213   
     214    /**
     215     * Check if nominal values allow the variable to be divided by the factor.
     216     */
     217    private static Boolean FEquation.nominalAllowsDivision(FExp factor, FVariable var, double tol) {
     218        if (factor.variability().constantVariability()) {
     219            FExp varNominalExp = factor.dynamicFExp(var.nominal());
     220            if (varNominalExp.variability().constantVariability()) {
     221                double factorNominal = Math.abs(factor.ceval().realValue());
     222                double varNominal    = varNominalExp.ceval().realValue();
     223                double totalNominal  = factorNominal * varNominal;
     224                if (totalNominal < tol) {
     225                    return false;
     226                }
     227            }
     228        }
     229        return true;
    209230    }
    210231   
  • branches/dev-mj-5835/Compiler/ModelicaMiddleEnd/test/modelica/VariabilityPropagationPartialTests.mo

    r12716 r13896  
    10131013    end PartiallyKnownDiscrete1;
    10141014
     1015    model PartiallyKnownTempAssign1
     1016        record R
     1017            Real x1;
     1018            Real x2;
     1019        end R;
     1020        function f
     1021            input Real x1;
     1022            input Real x2;
     1023            output R r = R(x1,x2);
     1024        algorithm
     1025            annotation(Inline=false);
     1026        end f;
     1027       
     1028       
     1029        R r = if time > 1 then f(1,time) else f(time,1);
     1030
     1031    annotation(__JModelica(UnitTesting(tests={
     1032        TransformCanonicalTestCase(
     1033            name="PartiallyKnownTempAssign1",
     1034            description="Partial evaluation of if equation assigning temporaries",
     1035            flatModel="
     1036fclass VariabilityPropagationPartialTests.PartiallyKnownTempAssign1
     1037 Real r.x1;
     1038 Real r.x2;
     1039 Real temp_1.x1;
     1040 Real temp_1.x2;
     1041 Real temp_2.x1;
     1042 Real temp_2.x2;
     1043equation
     1044 if time > 1 then
     1045  (VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.R(temp_1.x1, temp_1.x2)) = VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.f(1, time);
     1046 else
     1047  temp_1.x1 = 0.0;
     1048  temp_1.x2 = 0.0;
     1049 end if;
     1050 if not time > 1 then
     1051  (VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.R(temp_2.x1, temp_2.x2)) = VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.f(time, 1);
     1052 else
     1053  temp_2.x1 = 0.0;
     1054  temp_2.x2 = 0.0;
     1055 end if;
     1056 r.x1 = if time > 1 then temp_1.x1 else temp_2.x1;
     1057 r.x2 = if time > 1 then temp_1.x2 else temp_2.x2;
     1058
     1059public
     1060 function VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.f
     1061  input Real x1;
     1062  input Real x2;
     1063  output VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.R r;
     1064 algorithm
     1065  r.x1 := x1;
     1066  r.x2 := x2;
     1067  return;
     1068 annotation(Inline = false);
     1069 end VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.f;
     1070
     1071 record VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.R
     1072  Real x1;
     1073  Real x2;
     1074 end VariabilityPropagationPartialTests.PartiallyKnownTempAssign1.R;
     1075
     1076end VariabilityPropagationPartialTests.PartiallyKnownTempAssign1;
     1077")})));
     1078    end PartiallyKnownTempAssign1;
     1079
    10151080
    10161081end VariabilityPropagationPartialTests;
  • branches/dev-mj-5835/Compiler/OptimicaFrontEnd/src/jastadd/OptimicaFlatAPI.jrag

    r11676 r13896  
    7171    syn CValue FVariable.initialGuessAttributeCValue()   = CValue.UNKNOWN;
    7272    eq FRealVariable.initialGuessAttributeCValue()       = attributeCValueReal(FAttribute.INITIAL_GUESS, 0.0);
    73     eq FDerivativeVariable.initialGuessAttributeCValue() = new CValueReal(0.0);
     73    eq FDerivativeVariable.initialGuessAttributeCValue() = CValueReal.valueOf(0.0);
    7474    eq FIntegerVariable.initialGuessAttributeCValue()    = attributeCValueInteger(FAttribute.INITIAL_GUESS, 0);
    7575    eq FBooleanVariable.initialGuessAttributeCValue()    = attributeCValueBoolean(FAttribute.INITIAL_GUESS, false);
     
    157157    syn CValue FOptClass.startTimeAttributeCValue() =
    158158        startTimeAttributeSet()? startTimeAttributeExp().ceval():
    159             new CValueReal(0.0);
     159            CValueReal.valueOf(0.0);
    160160       
    161161    /**
     
    211211    syn CValue FOptClass.startTimeFreeAttributeCValue() =
    212212        startTimeFreeAttributeSet()? startTimeFreeAttributeExp().ceval():
    213             new CValueBoolean(false);
     213            CValueBoolean.FALSE;
    214214       
    215215    /**
     
    265265    syn CValue FOptClass.startTimeInitialGuessAttributeCValue() =
    266266        startTimeInitialGuessAttributeSet()? startTimeInitialGuessAttributeExp().ceval():
    267             new CValueReal(0.0);
     267            CValueReal.valueOf(0.0);
    268268       
    269269    /**
     
    311311    syn CValue FOptClass.finalTimeAttributeCValue() =
    312312        finalTimeAttributeSet()? finalTimeAttributeExp().ceval():
    313             new CValueReal(1.0);
     313            CValueReal.valueOf(1.0);
    314314       
    315315    /**
     
    357357    syn CValue FOptClass.staticAttributeCValue() =
    358358        staticAttributeSet()? staticAttributeExp().ceval():
    359             new CValueBoolean(false);
     359            CValueBoolean.FALSE;
    360360       
    361361    /**
     
    411411    syn CValue FOptClass.finalTimeFreeAttributeCValue() =
    412412        finalTimeFreeAttributeSet()? finalTimeFreeAttributeExp().ceval():
    413             new CValueBoolean(false);
     413            CValueBoolean.FALSE;
    414414
    415415    /**
     
    465465    syn CValue FOptClass.finalTimeInitialGuessAttributeCValue() =
    466466        finalTimeInitialGuessAttributeSet()? finalTimeInitialGuessAttributeExp().ceval():
    467             new CValueReal(1.0);
     467            CValueReal.valueOf(1.0);
    468468       
    469469    /**
  • branches/dev-mj-5835/Compiler/TestFramework/src/jastadd/CodeGenTestCase.jrag

    r11966 r13896  
    4444       
    4545        GUIDManager guidManager = fc.guidManager();
    46         StringBuilder actual = new StringBuilder();
     46        ByteArrayOutputStream actual = new ByteArrayOutputStream();
    4747        guidManager.setSourceString(test);
    4848        guidManager.addDependentString(test, actual);
  • branches/dev-mj-5835/Compiler/TestFramework/src/jastadd/TestAnnotationizer.jrag

    r13294 r13896  
    11791179            checkData(data);
    11801180            methodName = data[0].toString();
    1181             arguments = (data.length == 1) ? new Object[0] : (Object[]) data[1];
     1181            arguments = arguments();
    11821182            Method method = o.getClass().getMethod(methodName, TestCase.unwrapClasses(arguments));
    11831183            methodResult = method.invoke(o, arguments).toString();
     1184        }
     1185       
     1186        private Object[] arguments() {
     1187            if (data.length > 1) {
     1188                if (data[1] != null) {
     1189                    return (Object[]) data[1];
     1190                }
     1191            }
     1192            return new Object[0];
    11841193        }
    11851194       
  • branches/dev-mj-5835/Compiler/build-base.xml

    r13488 r13896  
    636636            <isset property="javadoc.packages"/>
    637637            <then>
     638
     639                <!-- We need to add this to builds with Java v9 or greater -->
     640                <condition property="javadoc_additional_params" value="" else="--no-module-directories">
     641                    <or>
     642                        <equals arg1="${ant.java.version}" arg2="1.7" />
     643                        <equals arg1="${ant.java.version}" arg2="1.8" />
     644                    </or>
     645                </condition>
     646
    638647                <!-- The javadoc directory is sometimes unusable, unclear why.
    639648                     It is recreated by the javadoc task. -->
     
    646655                    excludepackagenames="${test_helper_packages}"
    647656                    classpath="${thirdparty_jars_build}"
     657                    additionalparam="${javadoc_additional_params}"
    648658                    failonerror="true" />
    649659            </then>
  • branches/dev-mj-5835/Makefile.am

    r13396 r13896  
    4545bindistdir=JModelica.org-$(VERSION)-bin
    4646
    47 casadi:
    48 if COMPILE_WITH_IPOPT
    49     cd $(abs_builddir)/ThirdParty/CasADi; \
    50     make -f Makefile  "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR)" "IPOPT_HOME=$(IPOPT_HOME)" "CASADI_PYTHON_INST_DIR=${CASADI_PYTHON_INST_DIR}" "CASADI_INST_DIR=${CASADI_INST_DIR}" "CASADI_PLUGIN_INST_DIR=${CASADI_PLUGIN_INST_DIR}" "CMAKE_CASADI_ARGS=${CMAKE_CASADI_ARGS}" "CMAKE_CASADI_COMPILER_ARGS=${CMAKE_CASADI_COMPILER_ARGS}" "CMAKE_CASADI_CXX_FLAG=${CMAKE_CASADI_CXX_FLAG}" "CMAKE_PYTHON_LIB=${CMAKE_PYTHON_LIB}"
    51 endif
    52 if COMPILE_WITH_IPOPT64
    53     export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    54     export PYTHONHOME=$(PYTHON64_HOME); \
    55     cd $(abs_builddir)/ThirdParty/CasADi; \
    56     make -f Makefile  "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR64)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR64)" "IPOPT_HOME=$(IPOPT64_HOME)" "CASADI_PYTHON_INST_DIR=${CASADI_PYTHON_INST_DIR64}" "CASADI_INST_DIR=${CASADI_INST_DIR64}" "CASADI_PLUGIN_INST_DIR=${CASADI_PLUGIN_INST_DIR64}" "CMAKE_CASADI_ARGS=${CMAKE_CASADI_ARGS64}" "CMAKE_CASADI_COMPILER_ARGS=${CMAKE_CASADI_COMPILER_ARGS64}" "CMAKE_CASADI_CXX_FLAG=${CMAKE_CASADI_CXX_FLAG64}" "CMAKE_PYTHON_LIB=${CMAKE_PYTHON64_LIB}" "CMAKE_PYTHON_INCLUDE=${CMAKE_PYTHON64_INCLUDE}"
    57     export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    58     export PATH="$(ORIG_PATH)";
    59 endif
    60 
    61 install_casadi: casadi
    62 if COMPILE_WITH_IPOPT
    63     cd $(abs_builddir)/ThirdParty/CasADi; \
    64     make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR)" "IPOPT_HOME=$(IPOPT_HOME)"
    65     mkdir -p $(DESTDIR)$(prefix)/Python/
    66     cp -r $(abs_builddir)/casadi_install/casadi $(DESTDIR)$(prefix)/Python/
    67     ## temp fix
    68     cp $(abs_builddir)/casadi_build/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
    69 endif
    70 if COMPILE_WITH_IPOPT64 
    71     export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    72     export PYTHONHOME=$(PYTHON64_HOME); 
    73     cd $(abs_builddir)/ThirdParty/CasADi; \
    74     make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR64)" "IPOPT_HOME=$(IPOPT64_HOME)"
    75     mkdir -p $(DESTDIR)$(prefix)/Python/
    76     cp -r $(abs_builddir)/casadi_install64/casadi $(DESTDIR)$(prefix)/Python_64/
    77     ## temp fix
    78     cp $(abs_builddir)/casadi_build64/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
    79     export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    80     export PATH="$(ORIG_PATH)";
    81 endif
    82 ## Install for CasADiInterface, Variables and targets.
    83 ## MC_interface installs the system with Python.
    84 ## If C++ compilation/tests are wanted there is the target MC_interface_cplusplus
    85 
    86 MC_INTERFACE=$(abs_top_srcdir)/ModelicaCasADiInterface
    87 
    88 CASADI_HOME=$(abs_top_srcdir)/ThirdParty/CasADi/CasADi
    89 MC_SRC=$(JAVA_CASADI_BASE_DIR)/ModelicaCompilerCasADi
    90 OC_SRC=$(JAVA_CASADI_BASE_DIR)/OptimicaCompilerCasADi
    91 MC_SRC_SWIG=$(abs_top_srcdir)/Compiler/ModelicaCompilerCasADi/src/swig
    92 
    93 MC_CASADI_BUILD=$(abs_builddir)/ModelicaCompilerCasADi
    94 OC_CASADI_BUILD=$(abs_builddir)/OptimicaCompilerCasADi
    95 
    96 # The modelica casadi interface is built into a build folder
    97 MC_BUILD=$(abs_builddir)/ModelicaCasADiInterfaceBuild
    98 MC_BUILD64=$(abs_builddir)/ModelicaCasADiInterfaceBuild64
    99 # Jars from the modified modelica and optimica compilers are put into the JModelica folder
    100 MC_COMPILERS_DIR=$(MC_BUILD)/JModelica.org
    101 MC_LIB=$(DESTDIR)$(prefix)/lib/casadi_interface
    102 MC_LIB64=$(DESTDIR)$(prefix)/lib/casadi_interface64
    103 
    104 CASADI_BUILD_DIR=$(abs_builddir)/casadi_build
    105 CASADI_BUILD_DIR64=$(abs_builddir)/casadi_build64
    106 SWIGCHECK_BUILD_DIR=$(abs_builddir)/swig_check
    107 SWIGCHECK_BUILD_DIR64=$(abs_builddir)/swig_check64
    108 CASADI_PYTHON_INST_DIR=$(abs_builddir)/casadi_install
    109 CASADI_INST_DIR=$(prefix)/ThirdParty/CasADi
    110 CASADI_PLUGIN_INST_DIR=$(CASADI_INST_DIR)/lib
    111 CASADI_PYTHON_INST_DIR64=$(abs_builddir)/casadi_install64
    112 CASADI_INST_DIR64=$(prefix)/ThirdParty/CasADi64
    113 CASADI_PLUGIN_INST_DIR64=$(CASADI_INST_DIR64)/lib
    114 CMAKE_CASADI_CXX_FLAG=-m32
    115 CMAKE_CASADI_COMPILER_ARGS=-m32 -mincoming-stack-boundary=2
    116 CMAKE_CASADI_CXX_FLAG64=-m64
    117 CMAKE_CASADI_COMPILER_ARGS64=-m64 -fpermissive
    118 
    119 casadi_interface: install_casadi_interface
    120 build_casadi_interface: casadi modelicacasadi_wrapper
    121 install_casadi_interface: install_casadi $(MC_LIB) $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/__init__.py $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper/__init__.py $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/modelica_casadi_transfer_wrapper.py
    122     if [ "$(INSTALL_EXTRA_CASADI)" ]; then exec "$(INSTALL_EXTRA_CASADI)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    123 
    124 ifcasadi: casadi
    125 if COMPILE_WITH_IPOPT
    126     mkdir -p $(MC_BUILD)/ifcasadi; \
    127     cd $(MC_BUILD)/ifcasadi; \
    128     case $(build) in \
    129     *-cygwin*|*-mingw*) \
    130     cmake $(MC_SRC_SWIG) -G "MSYS Makefiles" -DCMAKE_CXX_COMPILER_ARG1="-m32" -DCMAKE_CXX_FLAGS="-m32" \
    131         -DIFCASADI_OUTDIR="$(MC_CASADI_BUILD)" -DCASADI_HOME="$(CASADI_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR)";; \
    132     *) \
    133     cmake $(MC_SRC_SWIG) \
    134         -DIFCASADI_OUTDIR="$(MC_CASADI_BUILD)" -DCASADI_HOME="$(CASADI_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR)";; \
    135     esac
    136     cd $(MC_BUILD)/ifcasadi;  make
    137 endif
    138 if COMPILE_WITH_IPOPT64
    139     export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}";
    140     export PYTHONHOME=$(PYTHON64_HOME);
    141     mkdir -p $(MC_BUILD64)/ifcasadi; \
    142     cd $(MC_BUILD64)/ifcasadi; \
    143     cmake $(MC_SRC_SWIG) -G "MSYS Makefiles" -DCMAKE_CXX_COMPILER_ARG1="-m64" -DCMAKE_CXX_FLAGS="-m64" \
    144         -DIFCASADI_OUTDIR="$(MC_CASADI_BUILD)" -DCASADI_HOME="$(CASADI_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR64)"; \
    145     cd $(MC_BUILD64)/ifcasadi;  make
    146     export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    147     export PATH="$(ORIG_PATH)";
    148 endif
    149 
    150 $(MC_LIB): $(MC_CASADI_BUILD)/bin/ModelicaCompiler.jar $(OC_CASADI_BUILD)/bin/OptimicaCompiler.jar $(MC_CASADI_BUILD)/bin/util.jar ifcasadi
    151 if COMPILE_WITH_IPOPT
    152     rm -rf $(MC_LIB)
    153     mkdir -p $(MC_LIB)
    154     cp $(MC_CASADI_BUILD)/bin/ModelicaCompiler.jar $(MC_LIB)
    155     cp $(OC_CASADI_BUILD)/bin/OptimicaCompiler.jar $(MC_LIB)
    156     cp $(MC_CASADI_BUILD)/bin/util.jar $(MC_LIB)
    157     case $(build) in \
    158     *-cygwin*) \
    159     cp $(MC_BUILD)/ifcasadi/ifcasadi.dll $(MC_LIB) ;; \
    160     *-mingw*) \
    161     cp $(MC_BUILD)/ifcasadi/ifcasadi.dll $(MC_LIB) ;; \
    162     *) \
    163     cp $(MC_BUILD)/ifcasadi/libifcasadi.so $(MC_LIB) ;; \
    164     esac
    165 endif
    166 if COMPILE_WITH_IPOPT64
    167     rm -rf $(MC_LIB64)
    168     mkdir -p $(MC_LIB64)
    169     cp $(MC_CASADI_BUILD)/bin/ModelicaCompiler.jar $(MC_LIB64)
    170     cp $(OC_CASADI_BUILD)/bin/OptimicaCompiler.jar $(MC_LIB64)
    171     cp $(MC_CASADI_BUILD)/bin/util.jar $(MC_LIB64)
    172     cp $(MC_BUILD64)/ifcasadi/ifcasadi.dll $(MC_LIB64)
    173 endif
    174 
    175 mc_modelica: ifcasadi
    176     cd $(MC_CASADI_BUILD); $(ANT_OPTS) $(ANT) -f "$(JAVA_MC_CASADI_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(MC_CASADI_BUILD)"
    177 
    178 mc_optimica: ifcasadi
    179     mkdir -p $(OC_CASADI_BUILD)/src/generated/optimica/java
    180     cp -pr $(MC_CASADI_BUILD)/src/generated/modelica/java/ifcasadi $(OC_CASADI_BUILD)/src/generated/optimica/java
    181     cd $(OC_CASADI_BUILD); $(ANT_OPTS) $(ANT) -f "$(JAVA_OC_CASADI_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(OC_CASADI_BUILD)"
    182 
    183 $(MC_CASADI_BUILD)/bin/ModelicaCompiler.jar: mc_modelica
    184 $(MC_CASADI_BUILD)/bin/util.jar:             mc_modelica
    185 $(MC_CASADI_BUILD)/bin/separateProcess.jar:  mc_modelica
    186 
    187 $(OC_CASADI_BUILD)/bin/OptimicaCompiler.jar: mc_optimica
    188 $(OC_CASADI_BUILD)/bin/util.jar:             mc_optimica
    189 $(OC_CASADI_BUILD)/bin/separateProcess.jar:  mc_optimica
    190 
    191 $(MC_BUILD)/modelicacasadi_wrapper/swig/modelicacasadi_wrapper.py: modelicacasadi_wrapper
    192 
    193 
    194 modelicacasadi_wrapper: $(MC_CASADI_BUILD)/bin/ModelicaCompiler.jar $(OC_CASADI_BUILD)/bin/OptimicaCompiler.jar $(MC_CASADI_BUILD)/bin/util.jar ifcasadi # $(MC_LIB)
    195 if COMPILE_WITH_IPOPT
    196     mkdir -p $(MC_BUILD)/modelicacasadi_wrapper; \
    197     cd $(MC_BUILD)/modelicacasadi_wrapper; \
    198     case $(build) in \
    199     *-cygwin*|*-mingw*) \
    200     cmake $(MC_INTERFACE) -G "MSYS Makefiles" -DCMAKE_CXX_COMPILER_ARG1="-m32" -DCMAKE_CXX_FLAGS="-m32" \
    201         -DMC_BUILD="$(MC_BUILD)" -DIPOPT_HOME="$(IPOPT_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR)" \
    202         -DIFCASADI_JAR_BASE="$(JAVA_CASADI_BUILD_DIR)" -DCASADI_HOME="$(CASADI_HOME)" \
    203         "$(CMAKE_PYTHON_LIB)" "$(CMAKE_PYTHON_INCLUDE)" ;; \
    204     *) \
    205     cmake $(MC_INTERFACE) \
    206         -DMC_BUILD="$(MC_BUILD)" -DIPOPT_HOME="$(IPOPT_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR)" \
    207         -DIFCASADI_JAR_BASE="$(JAVA_CASADI_BUILD_DIR)" -DCASADI_HOME="$(CASADI_HOME)" \
    208         "$(CMAKE_PYTHON_LIB)" "$(CMAKE_PYTHON_INCLUDE)" ;; \
    209     esac
    210     cd $(MC_BUILD)/modelicacasadi_wrapper;  make modelicacasadi_wrapper
    211 endif
    212 if COMPILE_WITH_IPOPT64
    213     export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    214     export PYTHONHOME=$(PYTHON64_HOME); \
    215     mkdir -p $(MC_BUILD64)/modelicacasadi_wrapper; \
    216     cd $(MC_BUILD64)/modelicacasadi_wrapper; \
    217     cmake $(MC_INTERFACE) -G "MSYS Makefiles" -DCMAKE_CXX_COMPILER_ARG1="-m64" -DCMAKE_CXX_FLAGS="-m64" \
    218         -DMC_BUILD="$(MC_BUILD64)" -DIPOPT_HOME="$(IPOPT64_HOME)" -DCASADI_BUILD_DIR="$(CASADI_BUILD_DIR64)" \
    219         -DIFCASADI_JAR_BASE="$(JAVA_CASADI_BUILD_DIR)" -DCASADI_HOME="$(CASADI_HOME)" \
    220         "$(CMAKE_PYTHON64_LIB)" "$(CMAKE_PYTHON64_INCLUDE)"; \
    221     cd $(MC_BUILD64)/modelicacasadi_wrapper;  make modelicacasadi_wrapper
    222     export PYTHONHOME=$(ORIG_PYTHON_HOME);
    223     export PATH="$(ORIG_PATH)";
    224 endif
    225 
    226  $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/__init__.py: install_modelicacasadi_transfer
    227  $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/modelica_casadi_transfer_wrapper.py: install_modelicacasadi_transfer
    228  
    229  $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper/__init__.py: install_modelicacasadi_wrapper
    230  
    231  install_modelicacasadi_wrapper: $(MC_BUILD)/modelicacasadi_wrapper/swig/modelicacasadi_wrapper.py
    232 if COMPILE_WITH_IPOPT
    233     mkdir -p $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper
    234     cp $(MC_BUILD)/modelicacasadi_wrapper/swig/*modelicacasadi_wrapper* $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper
    235     rm -f $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper/__init__.py
    236     touch $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper/__init__.py
    237     echo "from modelicacasadi_wrapper import *" >> $(DESTDIR)$(prefix)/Python/modelicacasadi_wrapper/__init__.py
    238 endif
    239 if COMPILE_WITH_IPOPT64
    240     export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    241     export PYTHONHOME=$(PYTHON64_HOME);
    242     mkdir -p $(DESTDIR)$(prefix)/Python_64/modelicacasadi_wrapper
    243     cp $(MC_BUILD64)/modelicacasadi_wrapper/swig/*modelicacasadi_wrapper* $(DESTDIR)$(prefix)/Python_64/modelicacasadi_wrapper
    244     rm -f $(DESTDIR)$(prefix)/Python_64/modelicacasadi_wrapper/__init__.py
    245     touch $(DESTDIR)$(prefix)/Python_64/modelicacasadi_wrapper/__init__.py
    246     echo "from modelicacasadi_wrapper import *" >> $(DESTDIR)$(prefix)/Python_64/modelicacasadi_wrapper/__init__.py
    247     export PYTHONHOME=$(ORIG_PYTHON_HOME)
    248     export PATH="$(ORIG_PATH)"
    249 endif
    250 
    251  install_modelicacasadi_transfer: $(MC_INTERFACE)/python/modelica_casadi_transfer_wrapper.py
    252 if COMPILE_WITH_IPOPT
    253     mkdir -p $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer
    254     rm -f $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/__init__.py
    255     touch $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/__init__.py
    256     echo "from modelica_casadi_transfer_wrapper import *" >> $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer/__init__.py
    257     cp $(MC_INTERFACE)/python/modelica_casadi_transfer_wrapper.py $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer
    258 endif
    259 if COMPILE_WITH_IPOPT64   
    260     mkdir -p $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer
    261     rm -f $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer/__init__.py
    262     touch $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer/__init__.py
    263     echo "from modelica_casadi_transfer_wrapper import *" >> $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer/__init__.py
    264     cp $(MC_INTERFACE)/python/modelica_casadi_transfer_wrapper.py $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer
    265 endif
    266        
     47include MakefileCasadi.am
     48
    26749if NUMPY_NO_MSVCR
    26850NUMPY_NO_MSVCR_ARG=--no-msvcr="true"
     
    504286JAVA_OC_CASADI_ANT_FILE=$(COMPILER_DIR)/OptimicaCompilerCasADi/build.xml
    505287
    506 all-local: build-python-packages build-compiler
    507     $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(abs_builddir)/version.txt
     288all-local: build-python-packages build-compiler $(abs_builddir)/version.txt build-extra
     289
     290$(abs_builddir)/version.txt: TODO-always-trigger
     291    $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(@)
     292
     293build-extra: TODO-always-trigger
    508294    if [ "$(BUILD_EXTRA)" ]; then exec "$(BUILD_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    509295
     
    578364ant_output_options=$(JAVA_BUILD_DIR)/src/build/DefaultOptions.xml
    579365
    580 install-compiler: $(ant_output_jars) $(ant_output_options) TODO-always-trigger
     366install-compiler: $(ant_output_jars) $(ant_output_options)
    581367if HAVE_ANT
    582368    mkdir -p $(DESTDIR)$(prefix)/lib/
     
    585371endif
    586372
    587 # Dummy target used to always trigger rebuilds. Used to enable references to
    588 # outputs from phony targets as real targets. For example ant output.
    589 TODO-always-trigger: ;
    590 
    591373$(ant_output_jars) $(ant_output_options): build-compiler
    592374
    593 build-compiler:
     375build-compiler: TODO-always-trigger
    594376if HAVE_ANT
    595377    mkdir -p $(JAVA_BUILD_DIR)
     
    599381    $(ANT_OPTS) $(ANT) -f "$(JAVA_OC_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(JAVA_BUILD_DIR)"
    600382endif
     383
     384# Dummy target used to always trigger rebuilds. Used to enable references to
     385# outputs from phony targets as real targets. For example ant output.
     386TODO-always-trigger: ;
    601387
    602388install-modules: install-modules-ModelicaFrontEnd
     
    650436
    651437clean-local: clean-frontends clean-python-packages clean-casadi-interface
    652 
    653 clean-casadi-interface:
    654     rm -rf $(MC_BUILD)
    655     rm -rf $(MC_BUILD64)
    656 #   rm -rf $(DESTDIR)$(prefix)/Python/casadi
    657 #   rm -rf $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer
    658 if HAVE_ANT
    659     cd $(JAVA_CASADI_BUILD_DIR)/ModelicaCompilerCasADi; \
    660     $(ANT_OPTS) $(ANT) clean ; rm -rf $(MC_CASADI_BUILD)/src/cpp-generated $(MC_CASADI_BUILD)/src/generated/modelica/java/ifcasadi
    661     cd $(JAVA_CASADI_BUILD_DIR)/OptimicaCompilerCasADi; \
    662     $(ANT_OPTS) $(ANT) clean ; rm -rf $(OC_CASADI_BUILD)/src/cpp-generated $(OC_CASADI_BUILD)/src/generated/optimica/java/ifcasadi
    663 endif
    664438   
    665439clean-python-packages:
     
    697471    make -C $(abs_top_srcdir)/doc/PyJMI html
    698472
    699 
    700 .PHONY: modelicacasadi_wrapper ifcasadi install_modelicacasadi_transfer install_modelicacasadi_wrapper
  • branches/dev-mj-5835/Makefile.in

    r13396 r13896  
    1515
    1616@SET_MAKE@
     17
     18#
     19#    Copyright (C) 2009 Modelon AB
     20#
     21#    This program is free software: you can redistribute it and/or modify
     22#    it under the terms of the Common Public License as published by
     23#    IBM, version 1.0 of the License.
     24#
     25#    This program is distributed in the hope that it will be useful,
     26#    but WITHOUT ANY WARRANTY. See the Common Public License for more details.
     27#
     28#    You should have received a copy of the Common Public License
     29#    along with this program.  If not, see
     30#     <http://www.ibm.com/developerworks/library/os-cpl.html/>.
    1731
    1832#
     
    4963host_triplet = @host@
    5064@PYTHON_ENABLED_TRUE@am__append_1 = Python
    51 subdir = .
    5265DIST_COMMON = $(am__configure_deps) $(srcdir)/Makefile.am \
    53     $(srcdir)/Makefile.in $(srcdir)/config.h.in \
    54     $(srcdir)/jm_tests.in \
     66    $(srcdir)/Makefile.in $(srcdir)/MakefileCasadi.am \
     67    $(srcdir)/config.h.in $(srcdir)/jm_tests.in \
    5568    $(top_srcdir)/Python/src/required_defaults.py.in \
    5669    $(top_srcdir)/configure INSTALL config.guess config.sub \
    5770    depcomp install-sh ltmain.sh missing
     71subdir = .
    5872ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
    5973am__aclocal_m4_deps = $(top_srcdir)/m4/libtool.m4 \
     
    371385am--refresh:
    372386    @:
    373 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(am__configure_deps)
     387$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(srcdir)/MakefileCasadi.am $(am__configure_deps)
    374388    @for dep in $?; do \
    375389      case '$(am__configure_deps)' in \
     
    865879
    866880
     881.PHONY: modelicacasadi_wrapper ifcasadi install_modelicacasadi_transfer install_modelicacasadi_wrapper
     882
    867883casadi:
    868884@COMPILE_WITH_IPOPT_TRUE@   cd $(abs_builddir)/ThirdParty/CasADi; \
     
    879895@COMPILE_WITH_IPOPT_TRUE@   make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR)" "IPOPT_HOME=$(IPOPT_HOME)"
    880896@COMPILE_WITH_IPOPT_TRUE@   mkdir -p $(DESTDIR)$(prefix)/Python/
    881 @COMPILE_WITH_IPOPT_TRUE@   cp -r $(abs_builddir)/casadi_install/casadi $(DESTDIR)$(prefix)/Python/
    882 @COMPILE_WITH_IPOPT_TRUE@   cp $(abs_builddir)/casadi_build/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
     897@COMPILE_WITH_IPOPT_TRUE@   cp -r $(CASADI_PYTHON_INST_DIR)/casadi $(DESTDIR)$(prefix)/Python/
     898@COMPILE_WITH_IPOPT_TRUE@   cp $(CASADI_BUILD_DIR)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
    883899@COMPILE_WITH_IPOPT64_TRUE@ export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    884900@COMPILE_WITH_IPOPT64_TRUE@ export PYTHONHOME=$(PYTHON64_HOME); 
     
    886902@COMPILE_WITH_IPOPT64_TRUE@ make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR64)" "IPOPT_HOME=$(IPOPT64_HOME)"
    887903@COMPILE_WITH_IPOPT64_TRUE@ mkdir -p $(DESTDIR)$(prefix)/Python/
    888 @COMPILE_WITH_IPOPT64_TRUE@ cp -r $(abs_builddir)/casadi_install64/casadi $(DESTDIR)$(prefix)/Python_64/
    889 @COMPILE_WITH_IPOPT64_TRUE@ cp $(abs_builddir)/casadi_build64/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
     904@COMPILE_WITH_IPOPT64_TRUE@ cp -r $(CASADI_PYTHON_INST_DIR64)/casadi $(DESTDIR)$(prefix)/Python_64/
     905@COMPILE_WITH_IPOPT64_TRUE@ cp $(CASADI_BUILD_DIR64)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
    890906@COMPILE_WITH_IPOPT64_TRUE@ export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    891907@COMPILE_WITH_IPOPT64_TRUE@ export PATH="$(ORIG_PATH)";
     
    10171033@COMPILE_WITH_IPOPT64_TRUE@ echo "from modelica_casadi_transfer_wrapper import *" >> $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer/__init__.py
    10181034@COMPILE_WITH_IPOPT64_TRUE@ cp $(MC_INTERFACE)/python/modelica_casadi_transfer_wrapper.py $(DESTDIR)$(prefix)/Python_64/modelicacasadi_transfer
     1035
     1036clean-casadi-interface:
     1037    rm -rf $(MC_BUILD)
     1038    rm -rf $(MC_BUILD64)
     1039#   rm -rf $(DESTDIR)$(prefix)/Python/casadi
     1040#   rm -rf $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer
     1041@HAVE_ANT_TRUE@ cd $(JAVA_CASADI_BUILD_DIR)/ModelicaCompilerCasADi; \
     1042@HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) clean ; rm -rf $(MC_CASADI_BUILD)/src/cpp-generated $(MC_CASADI_BUILD)/src/generated/modelica/java/ifcasadi
     1043@HAVE_ANT_TRUE@ cd $(JAVA_CASADI_BUILD_DIR)/OptimicaCompilerCasADi; \
     1044@HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) clean ; rm -rf $(OC_CASADI_BUILD)/src/cpp-generated $(OC_CASADI_BUILD)/src/generated/optimica/java/ifcasadi
    10191045
    10201046build-python-packages:
     
    11931219@PYTHON_ENABLED_TRUE@   chmod ugo+x $(DESTDIR)$(prefix)/bin/jm_*.sh
    11941220
    1195 all-local: build-python-packages build-compiler
    1196     $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(abs_builddir)/version.txt
     1221all-local: build-python-packages build-compiler $(abs_builddir)/version.txt build-extra
     1222
     1223$(abs_builddir)/version.txt: TODO-always-trigger
     1224    $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(@)
     1225
     1226build-extra: TODO-always-trigger
    11971227    if [ "$(BUILD_EXTRA)" ]; then exec "$(BUILD_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    11981228
     
    12571287    if [ "$(INSTALL_EXTRA)" ]; then exec "$(INSTALL_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    12581288
    1259 install-compiler: $(ant_output_jars) $(ant_output_options) TODO-always-trigger
     1289install-compiler: $(ant_output_jars) $(ant_output_options)
    12601290@HAVE_ANT_TRUE@ mkdir -p $(DESTDIR)$(prefix)/lib/
    12611291@HAVE_ANT_TRUE@ install -t $(DESTDIR)$(prefix)/lib/ $(ant_output_jars)
    12621292@HAVE_ANT_TRUE@ install -t $(DESTDIR)$(prefix)/ $(ant_output_options)
    12631293
    1264 # Dummy target used to always trigger rebuilds. Used to enable references to
    1265 # outputs from phony targets as real targets. For example ant output.
    1266 TODO-always-trigger: ;
    1267 
    12681294$(ant_output_jars) $(ant_output_options): build-compiler
    12691295
    1270 build-compiler:
     1296build-compiler: TODO-always-trigger
    12711297@HAVE_ANT_TRUE@ mkdir -p $(JAVA_BUILD_DIR)
    12721298@HAVE_ANT_TRUE@ cd $(JAVA_BUILD_DIR); \
     
    12741300@HAVE_ANT_TRUE@ cd $(JAVA_BUILD_DIR); \
    12751301@HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) -f "$(JAVA_OC_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(JAVA_BUILD_DIR)"
     1302
     1303# Dummy target used to always trigger rebuilds. Used to enable references to
     1304# outputs from phony targets as real targets. For example ant output.
     1305TODO-always-trigger: ;
    12761306
    12771307install-modules: install-modules-ModelicaFrontEnd
     
    13181348
    13191349clean-local: clean-frontends clean-python-packages clean-casadi-interface
    1320 
    1321 clean-casadi-interface:
    1322     rm -rf $(MC_BUILD)
    1323     rm -rf $(MC_BUILD64)
    1324 #   rm -rf $(DESTDIR)$(prefix)/Python/casadi
    1325 #   rm -rf $(DESTDIR)$(prefix)/Python/modelicacasadi_transfer
    1326 @HAVE_ANT_TRUE@ cd $(JAVA_CASADI_BUILD_DIR)/ModelicaCompilerCasADi; \
    1327 @HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) clean ; rm -rf $(MC_CASADI_BUILD)/src/cpp-generated $(MC_CASADI_BUILD)/src/generated/modelica/java/ifcasadi
    1328 @HAVE_ANT_TRUE@ cd $(JAVA_CASADI_BUILD_DIR)/OptimicaCompilerCasADi; \
    1329 @HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) clean ; rm -rf $(OC_CASADI_BUILD)/src/cpp-generated $(OC_CASADI_BUILD)/src/generated/optimica/java/ifcasadi
    13301350
    13311351clean-python-packages:
     
    13591379    make -C $(abs_top_srcdir)/doc/PyJMI html
    13601380
    1361 .PHONY: modelicacasadi_wrapper ifcasadi install_modelicacasadi_transfer install_modelicacasadi_wrapper
    1362 
    13631381# Tell versions [3.59,3.63) of GNU make to not export all variables.
    13641382# Otherwise a system limit (for SysV at least) may be exceeded.
  • branches/dev-mj-5835/Python/src/pyjmi/examples/cstr_mpc_casadi.py

    r8187 r13896  
    8686    sim_model.set('_start_T', T_0_A)
    8787    sim_model.set('Tc', 280)
    88     init_res = sim_model.simulate(start_time=0., final_time=150)
     88   
     89    opts = sim_model.simulate_options()
     90    opts["CVode_options"]["maxh"] = 0.0
     91    opts["ncp"] = 0
     92   
     93    init_res = sim_model.simulate(start_time=0., final_time=150, options=opts)
    8994
    9095    ### 2. Define the optimal control problem and solve it using the MPC class
     
    159164        sim_res = sim_model.simulate(start_time=k*sample_period,
    160165                                     final_time=(k+1)*sample_period,
    161                                      input=u_k)
     166                                     input=u_k, options=opts)
    162167
    163168        # Extract state at end of sample_period from sim_res and add Gaussian
  • branches/dev-mj-5835/Python/src/pyjmi/examples/if_example_2.py

    r4648 r13896  
    4949    t = res['time']
    5050   
    51     assert N.abs(res.final('x') - 3.5297217)    < 1e-3
    52     assert N.abs(res.final('u') - (-0.2836621)) < 1e-3
     51    assert N.abs(res.final('x') - 3.5297217)    < 1e-2, N.abs(res.final('x') - 3.5297217)
     52    assert N.abs(res.final('u') - (-0.2836621)) < 1e-2, N.abs(res.final('u') - (-0.2836621))
    5353
    5454    if with_plots:
  • branches/dev-mj-5835/Python/src/pyjmi/ukf.py

    r10171 r13896  
    368368                opt['CVode_options']['atol'] = 1e-8
    369369                opt['CVode_options']['rtol'] = 1e-6
     370                opt['CVode_options']['maxh'] = 0.0
     371                opt['ncp'] = 0
    370372                print 'Simulating sigma-point '+str(i+1)+' out of '+str(sigma.shape[1])+' :'
    371373                try:
  • branches/dev-mj-5835/Python/src/pymodelica/compiler_wrappers.py

    r12127 r13896  
    322322        if isinstance(platforms, basestring):
    323323            platforms = [platforms]
    324         self._compiler.targetPlatforms = platforms
     324        self._compiler.setTargetPlatforms(platforms)
    325325       
    326326    def compile_Unit(self, class_name, file_name, target, version, compile_to):
  • branches/dev-mj-5835/Python/src/tests_jmodelica/files/Modelica/ExtFunctionTests.mo

    r11759 r13896  
    11package ExtFunctionTests
     2
     3model Evaluator_Double
     4    function d_i
     5     input Integer a;
     6     output Real b;
     7
     8     external "C" b=f_d_i(a) annotation(Library="evaluatorTestsShared",
     9                             Include="#include \"evaluatorTests.h\"");
     10    end d_i;
     11   
     12    function d_idd
     13     input Integer a;
     14     input Real b;
     15     input Real c;
     16     output Real d;
     17
     18     external "C" d=f_d_idd(a,b,c) annotation(Library="evaluatorTestsShared",
     19                             Include="#include \"evaluatorTests.h\"");
     20    end d_idd;
     21   
     22   
     23    Real c = d_i(1);
     24    Real d = d_idd(1, 2.0, 3.0);
     25end Evaluator_Double;
     26
     27model Evaluator_Integer
     28    function i_ii
     29     input Integer a;
     30     input Integer b;
     31     output Integer c;
     32
     33     external "C" c=f_i_ii(a,b) annotation(Library="evaluatorTestsShared",
     34                             Include="#include \"evaluatorTests.h\"");
     35    end i_ii;
     36   
     37    constant Integer c = i_ii(1,2);
     38end Evaluator_Integer;
     39
     40model Evaluator_Record
     41    record R
     42        Real x0;
     43        Real x1;
     44        Real x2;
     45        Real x3;
     46        Real x4;
     47        Real x5;
     48        Real x6;
     49        Real x7;
     50        Real x8;
     51        Real x9;
     52        Real x10;
     53    end R;
     54    function iddpR_ddddddddddd_
     55     input Integer a;
     56     input Real b;
     57     input Real c;
     58     output R d;
     59
     60     external "C" f___iddpR_ddddddddddd_(a,b,c,d) annotation(Library="evaluatorTestsShared",
     61                             Include="#include \"evaluatorTests.h\"");
     62    end iddpR_ddddddddddd_;
     63   
     64    constant R c = iddpR_ddddddddddd_(1,2.0,3.0);
     65end Evaluator_Record;
     66
     67
     68model Evaluator_Substring
     69    constant String full="Yy00";
     70    constant String sub=Modelica.Utilities.Strings.substring(full,1,1);
     71    constant String string1 = "This is line 111";
     72    constant String string2 = Modelica.Utilities.Strings.substring(string1,9,12); // string2 = \"line\"
     73    constant Integer len = Modelica.Utilities.Strings.length(string1);
     74    constant Integer start = Modelica.Utilities.Strings.Advanced.skipWhiteSpace("   Hello", 1);
     75    constant Boolean not_equal = Modelica.Utilities.Strings.isEqual("Temp", "test", true);
     76    constant Boolean equal = Modelica.Utilities.Strings.isEqual("Temp", "Temp", true);
     77end Evaluator_Substring;
     78
     79model Evaluator_Add
     80 function add1
     81     input Real a;
     82     input Real b;
     83     output Real c;
     84
     85     external "C" c=add(a,b) annotation(Library="addNumbersShared",
     86                             Include="#include \"addNumbers.h\"");
     87 end add1;
     88 
     89 function add2
     90     input Real a;
     91     input Real b;
     92     output Real c;
     93
     94     external "C" add_output(a,b,c) annotation(Library="addNumbersShared",
     95                             Include="#include \"addNumbers.h\"");
     96 end add2;
     97
     98 constant Real a = 1;
     99 constant Real b = 2;
     100 Real c = add1(a,b);
     101 Real d = add2(a,b);
     102end Evaluator_Add;
     103
     104model Evaluator_Multiple_Add
     105 function add
     106     input Real a;
     107     input Real b;
     108     input Real c;
     109     input Real d;
     110     input Real e;
     111     input Real f;
     112     input Real g;
     113     input Real h;
     114     input Real i;
     115     output Real o;
     116
     117     external "C" o=multiple_add(a,b,c,d,e,f,g,h,i) annotation(Library="addNumbersShared",
     118                             Include="#include \"addNumbers.h\"");
     119 end add;
     120 
     121 constant Real a = 1;
     122 constant Real b = 2;
     123 Real c = add(a,b,a,b,a,b,a,b,a);
     124end Evaluator_Multiple_Add;
     125
     126model Evaluator_Unknown_Shared
     127    function unknown_function
     128        input Real a;
     129        output Real b;
     130        external "C" b = unknown(a) annotation(Library="unknown");
     131    end unknown_function;
     132   
     133    constant Real a = unknown_function(1.0);
     134end Evaluator_Unknown_Shared;
    2135
    3136model ExtFunctionTest1
  • branches/dev-mj-5835/Python/src/tests_jmodelica/files/Modelica/Resources/CMakeLists.txt

    r10171 r13896  
    3838include_directories(${TOP_SRC}/RuntimeLibrary/src/jmi)
    3939
     40set(EVALUATORTESTS_Sources
     41    src/evaluatorTests.c
     42    Include/evaluatorTests.h
     43)
     44
    4045set(ADDNUMBERS_Sources
    4146    src/addNumbers.c
     
    7075endif()
    7176
     77#Build evaluatorTests library
     78add_library(evaluatorTestsShared SHARED ${EVALUATORTESTS_Sources})
     79if(NOT MSVC)
     80    set_target_properties(evaluatorTestsShared PROPERTIES COMPILE_FLAGS "-Wall -g -std=c89 -pedantic -Werror -O2")
     81endif()
     82
    7283#Build addNumbers library
    7384add_library(addNumbers STATIC ${ADDNUMBERS_Sources})
     85add_library(addNumbersShared SHARED ${ADDNUMBERS_Sources})
    7486if(NOT MSVC)
    7587    set_target_properties(addNumbers PROPERTIES COMPILE_FLAGS "-Wall -g -std=c89 -pedantic -Werror -O2")
     88    set_target_properties(addNumbersShared PROPERTIES COMPILE_FLAGS "-Wall -g -std=c89 -pedantic -Werror -O2")
    7689endif()
    7790
     
    106119
    107120#Install the libraries
     121install(TARGETS evaluatorTestsShared DESTINATION "${TEST_LIBRARY_INSTALL_DIR}")
    108122install(TARGETS addNumbers DESTINATION "${TEST_LIBRARY_INSTALL_DIR}")
     123install(TARGETS addNumbersShared DESTINATION "${TEST_LIBRARY_INSTALL_DIR}")
    109124install(TARGETS arrayFunctions DESTINATION "${TEST_LIBRARY_INSTALL_DIR}")
    110125install(TARGETS externalFunctionsC DESTINATION "${TEST_LIBRARY_INSTALL_DIR}")
  • branches/dev-mj-5835/Python/src/tests_jmodelica/files/Modelica/Resources/Include/addNumbers.h

    r3965 r13896  
    22#define ADDNUMBERS_H
    33
    4 double add(double a, double b);
     4#if defined _WIN32
     5    #define DllExport __declspec(dllexport)
     6#else
     7    #define DllExport
     8#endif
     9
     10DllExport double add(double a, double b);
     11DllExport void add_output(double a, double b, double *c);
     12DllExport double multiple_add(double a, double b, double c, double d, double e, double f, double g, double h, double i);
    513void multiplyAnArray(int* inputs, int* outputs, int size, int m);
    614
  • branches/dev-mj-5835/Python/src/tests_jmodelica/files/Modelica/Resources/src/addNumbers.c

    r6459 r13896  
    11#include "addNumbers.h"
    22
    3 double add(double a, double b)
     3DllExport double add(double a, double b)
    44{
    5   return a+b;
     5  return a + b;
     6}
     7
     8DllExport void add_output(double a, double b, double *c)
     9{
     10  *c = a + b;
     11}
     12
     13DllExport double multiple_add(double a, double b, double c, double d, double e, double f, double g, double h, double i)
     14{
     15  return a+b+c+d+e+f+g+h+i;
    616}
    717
  • branches/dev-mj-5835/Python/src/tests_jmodelica/general/base_simul.py

    r10446 r13896  
    286286       
    287287        if not cvode_options:
    288             cvode_options = {'atol':self.abs_tol,'rtol':self.rel_tol}
     288            cvode_options = {'atol':self.abs_tol,'rtol':self.rel_tol, 'maxh':0.0}
     289        else:
     290            if not 'maxh' in cvode_options:
     291                cvode_options['maxh'] = 0.0
    289292       
    290293        if isinstance(self.model, FMUModelME1) or isinstance(self.model, FMUModelME2):
  • branches/dev-mj-5835/Python/src/tests_jmodelica/general/test_extfunctions.py

    r11759 r13896  
    2222
    2323import nose
     24import fnmatch
    2425
    2526from pymodelica import compile_fmu
    2627from pymodelica.common.core import get_platform_dir, create_temp_dir
    27 from pyfmi import load_fmu
     28from pyfmi import load_fmu, FMUModelME2
    2829from pyfmi.fmi import FMUException
    2930from tests_jmodelica import testattr, get_files_path
     
    3334path_to_mofiles = os.path.join(get_files_path(), 'Modelica')
    3435
     36class TestEvaluator:
     37    @classmethod
     38    def setUpClass(cls):
     39        """
     40        Sets up the test class.
     41        """
     42        cls.fpath = path(path_to_mofiles, "ExtFunctionTests.mo")
     43   
     44    @testattr(stddist_base = True)
     45    def test_builtin_substring(self):
     46        cpath = "ExtFunctionTests.Evaluator_Substring"
     47        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, compiler_log_level="d:log.txt")
     48       
     49        nbr_of_evaluator_calls = 0
     50        with open("log.txt") as f:
     51            res = fnmatch.filter(f, "Succesfully connected external function '*' to the evaluator*")
     52            nbr_of_evaluator_calls = len(res)
     53       
     54        assert nbr_of_evaluator_calls == 4, "Wrong number of external function calls, check log."
     55       
     56        model = load_fmu(fmu_name)
     57       
     58        assert model.get("sub")[0] == "Y", model.get("sub")
     59        assert model.get("string2")[0] == "line", model.get("string2")
     60        assert model.get("len") == 16, model.get("len")
     61        assert model.get("start") == 4, model.get("start")
     62        assert not model.get("not_equal"), model.get("not_equal")
     63        assert model.get("equal"), model.get("equal")
     64   
     65    @testattr(stddist_base = True)
     66    def test_add(self):
     67        cpath = "ExtFunctionTests.Evaluator_Add"
     68        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, version=2.0, compiler_log_level="d:log.txt")
     69       
     70        nbr_of_evaluator_calls = 0
     71        with open("log.txt") as f:
     72            res = fnmatch.filter(f, "Succesfully connected external function '*' to the evaluator*")
     73            nbr_of_evaluator_calls = len(res)
     74       
     75        assert nbr_of_evaluator_calls == 2, "Wrong number of external function calls, check log."
     76       
     77        model = FMUModelME2(fmu_name, _connect_dll=False)
     78       
     79        assert model.get_variable_start("c") == 3, model.get_variable_start("c")
     80        assert model.get_variable_start("d") == 3, model.get_variable_start("d")
     81   
     82    @testattr(stddist_base = True)
     83    def test_unsupported_signature(self):
     84        cpath = "ExtFunctionTests.Evaluator_Multiple_Add"
     85        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, compiler_log_level="d:log.txt")
     86       
     87        matches = 0
     88        with open("log.txt") as f:
     89            res = fnmatch.filter(f, "*is not supported. Disabling use of the evaluator*")
     90            matches = len(res)
     91       
     92        assert matches == 1, "Does not seem to disabling the evaluator"
     93
     94    @testattr(stddist_base = True)
     95    def test_unknown_shared_library(self):
     96        cpath = "ExtFunctionTests.Evaluator_Unknown_Shared"
     97        try:
     98            fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, compiler_log_level="d:log_unknown_shared.txt")
     99        except: #The compilation will fail, the interesting parts will though still be contained in the log file
     100            pass
     101       
     102        matches = 0
     103        with open("log_unknown_shared.txt") as f:
     104            res = fnmatch.filter(f, "Could not find a shared library containing*")
     105            matches = len(res)
     106       
     107        assert matches == 1, "Seems to have found an unknown shared library"
     108   
     109    @testattr(stddist_base = True)
     110    def test_double_return(self):
     111        cpath = "ExtFunctionTests.Evaluator_Double"
     112        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, version=2.0, compiler_log_level="d:log.txt")
     113       
     114        nbr_of_evaluator_calls = 0
     115        with open("log.txt") as f:
     116            res = fnmatch.filter(f, "Succesfully connected external function '*' to the evaluator*")
     117            nbr_of_evaluator_calls = len(res)
     118       
     119        assert nbr_of_evaluator_calls == 2, "Wrong number of external function calls, check log."
     120       
     121        model = FMUModelME2(fmu_name, _connect_dll=False)
     122       
     123        assert model.get_variable_start("c") == 3.0, model.get_variable_start("c")
     124        assert model.get_variable_start("d") == 9.0, model.get_variable_start("d")
     125   
     126    @testattr(stddist_base = True)
     127    def test_integer_return(self):
     128        cpath = "ExtFunctionTests.Evaluator_Integer"
     129        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, version=2.0, compiler_log_level="d:log.txt")
     130       
     131        nbr_of_evaluator_calls = 0
     132        with open("log.txt") as f:
     133            res = fnmatch.filter(f, "Succesfully connected external function '*' to the evaluator*")
     134            nbr_of_evaluator_calls = len(res)
     135       
     136        assert nbr_of_evaluator_calls == 1, "Wrong number of external function calls, check log."
     137       
     138        model = FMUModelME2(fmu_name, _connect_dll=False)
     139       
     140        assert model.get_variable_start("c") == 3.0, model.get_variable_start("c")
     141   
     142    @testattr(stddist_base = True)
     143    def test_record(self):
     144        cpath = "ExtFunctionTests.Evaluator_Record"
     145        fmu_name = compile_fmu(cpath, self.fpath, compiler_options={"external_constant_evaluation_dynamic":True}, version=2.0, compiler_log_level="d:log.txt")
     146       
     147        nbr_of_evaluator_calls = 0
     148        with open("log.txt") as f:
     149            res = fnmatch.filter(f, "Succesfully connected external function '*' to the evaluator*")
     150            nbr_of_evaluator_calls = len(res)