Changeset 13704


Ignore:
Timestamp:
Oct 8, 2019 8:34:08 PM (2 months ago)
Author:
Christian Andersson
Message:

Merged latest changes into evaluator branch. Related to ticket:5837

Location:
branches/dev-cw-evaluator
Files:
65 edited
4 copied

Legend:

Unmodified
Added
Removed
  • branches/dev-cw-evaluator

  • branches/dev-cw-evaluator/.settings/org.eclipse.jdt.core.prefs

    r12984 r13704  
    1313org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
    1414org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
    15 org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
     15org.eclipse.jdt.core.compiler.problem.comparingIdentical=error
    1616org.eclipse.jdt.core.compiler.problem.deadCode=warning
    1717org.eclipse.jdt.core.compiler.problem.deprecation=warning
     
    1919org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
    2020org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
    21 org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
     21org.eclipse.jdt.core.compiler.problem.emptyStatement=error
    2222org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=warning
    23 org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
     23org.eclipse.jdt.core.compiler.problem.fallthroughCase=error
    2424org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
    25 org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
     25org.eclipse.jdt.core.compiler.problem.fieldHiding=info
    2626org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
    2727org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
    2828org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
    29 org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
     29org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=error
    3030org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
    3131org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
    32 org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
     32org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=error
    3333org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
    3434org.eclipse.jdt.core.compiler.problem.invalidJavadoc=warning
     
    4040org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
    4141org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore
    42 org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
     42org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=warning
    4343org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
    44 org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=warning
     44org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=error
    4545org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore
    4646org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=disabled
     
    5555org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
    5656org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
    57 org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
     57org.eclipse.jdt.core.compiler.problem.noEffectAssignment=error
    5858org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
    5959org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
     
    6767org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
    6868org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning
    69 org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
     69org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=error
    7070org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
    7171org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore
     
    9090org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=info
    9191org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
    92 org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=warning
     92org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentType=error
    9393org.eclipse.jdt.core.compiler.problem.unlikelyCollectionMethodArgumentTypeStrict=disabled
    94 org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=info
     94org.eclipse.jdt.core.compiler.problem.unlikelyEqualsArgumentType=error
    9595org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
    96 org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
     96org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
    9797org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
    9898org.eclipse.jdt.core.compiler.problem.unstableAutoModuleName=warning
     
    105105org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
    106106org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
    107 org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
     107org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=warning
    108108org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
    109109org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=disabled
  • branches/dev-cw-evaluator/CHANGELOG.txt

    r13659 r13704  
    44during the compilation (for performance). Activated by the option
    55"external_constant_evaluation_dynamic"
     6
     7# Fixed ; Minor ; Compiler ; #5855
     8Nominal are now always positive in the FMI model description.
     9
     10# Fixed ; Minor ; Compiler; #5844
     11Improved attribute evaluation robustness for some cases. Parametric
     12attributes are now only generated in model description for inputs
     13and states.
     14
     15# Fixed ; Minor ; Compiler; #5835
     16Format string argument to the String function is now useable.
     17
     18# Change ; Minor ; Compiler; #5830
     19ParseHandler now have a target for Subscript.
    620
    721# Change ; Major ; PyFMI ; #5826
  • branches/dev-cw-evaluator/Compiler/FmiXMLCodeGen/src/jastadd/FmiXMLGenerator.jrag

    r12844 r13704  
    247247    /**
    248248     * Used for registering new vendor annotation tag. Returns the name
    249      * for conveninence. Vendor annotation tags should inherit
     249     * for convenience. Vendor annotation tags should inherit
    250250     * FMIVendorAnnotation.
    251251     */
     
    257257    /**
    258258     * Used for registering new tool specific tag under the vendor annotation tag.
    259      * Returns the name for conveninence.
     259     * Returns the name for convenience.
    260260     */
    261261    public static String addVendorAnnotationTool(String childName) {
  • branches/dev-cw-evaluator/Compiler/FmiXMLCodeGen/test/modelica/FmiXMLTests.mo

    r12934 r13704  
    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-cw-evaluator/Compiler/GenericCodeGen/src/jastadd/GenericXMLGenerator.jrag

    r11966 r13704  
    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-cw-evaluator/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExternal.jrag

    r11676 r13704  
    151151    }
    152152   
     153    @Override
     154    public void FSizeExp.genExternalCFuncArgs(CodePrinter p, CodeStream str, String indent, CodeGenContext cgc) {
     155        str.print("(size_t) ");
     156        super.genExternalCFuncArgs(p, str, indent, cgc);
     157    }
     158   
    153159}
  • branches/dev-cw-evaluator/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenFunctionIO.jrag

    r11676 r13704  
    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-cw-evaluator/Compiler/ModelicaCBackEnd/src/jastadd/CodeGen/StepPrinter.jrag

    r12024 r13704  
    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-cw-evaluator/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalCevalTests.mo

    r13659 r13704  
    264264    (x1,x2,x3,x4,x5) = f({1},{2},{true},{"s"},{E.A});
    265265
    266     annotation(__JModelica(UnitTesting(tests={
    267         CCodeGenTestCase(
    268             name="Array",
    269             description="Test code gen for external C functions evaluation. Arrays.",
    270             variability_propagation=false,
    271             inline_functions="none",
    272             template="
     266annotation(__JModelica(UnitTesting(tests={
     267    CCodeGenTestCase(
     268        name="Array",
     269        description="Test code gen for external C functions evaluation. Arrays.",
     270        variability_propagation=false,
     271        inline_functions="none",
     272        template="
    273273$ECE_external_includes$
    274274$ECE_record_definitions$
     
    291291$ECE_free$
    292292",
    293             generatedCode="
     293        generatedCode="
    294294---
    295295
     
    402402            jmi_copy_matrix_to_int(b5_a, b5_a->var, tmp_15->var);
    403403            tmp_16 = (int)f_arg19;
    404             f(a1_a->var, tmp_1, tmp_2->var, tmp_3, tmp_4->var, tmp_5, a4_a->var, tmp_6, tmp_7->var, tmp_8, b1_a->var, tmp_9, tmp_10->var, tmp_11, tmp_12->var, tmp_13, b4_a->var, tmp_14, tmp_15->var, tmp_16);
     404            f(a1_a->var, (size_t) tmp_1, tmp_2->var, (size_t) tmp_3, tmp_4->var, (size_t) tmp_5, a4_a->var, (size_t) tmp_6, tmp_7->var, (size_t) tmp_8, b1_a->var, (size_t) tmp_9, tmp_10->var, (size_t) tmp_11, tmp_12->var, (size_t) tmp_13, b4_a->var, (size_t) tmp_14, tmp_15->var, (size_t) tmp_16);
    405405            jmi_copy_matrix_from_int(b2_a, tmp_10->var, b2_a->var);
    406406            jmi_copy_matrix_from_int(b3_a, tmp_12->var, b3_a->var);
     
    417417
    418418---
    419 
    420419")})));
    421420end Array;
     
    488487    Real x = use2(o2);
    489488
    490     annotation(__JModelica(UnitTesting(tests={
    491         CCodeGenTestCase(
    492             name="ExtObj1",
    493             description="Test code gen for external C functions evaluation. External objects.",
    494             variability_propagation=false,
    495             inline_functions="none",
    496             template="
     489annotation(__JModelica(UnitTesting(tests={
     490    CCodeGenTestCase(
     491        name="ExtObj1",
     492        description="Test code gen for external C functions evaluation. External objects.",
     493        variability_propagation=false,
     494        inline_functions="none",
     495        template="
    497496$ECE_external_includes$
    498497$ECE_record_definitions$
     
    515514$ECE_free$
    516515",
    517             generatedCode="
     516        generatedCode="
    518517#include \"extObjects.h\"
    519518
     
    554553        tmp_4 = (int)tmp_6_arg5;
    555554        tmp_5 = (double)tmp_6_arg6;
    556         my_constructor2(tmp_6_arg0->var, tmp_2->var, &o2_v, tmp_3->var, tmp_6_arg4->var, tmp_4, tmp_5);
     555        my_constructor2(tmp_6_arg0->var, tmp_2->var, &o2_v, tmp_3->var, tmp_6_arg4->var, (size_t) tmp_4, tmp_5);
    557556
    558557---
     
    574573---
    575574        destructor(o2_v);
    576 
    577575")})));
    578576end ExtObj1;
     
    581579    extends ExtObj1(x=use3(o3));
    582580
    583     annotation(__JModelica(UnitTesting(tests={
    584         CCodeGenTestCase(
    585             name="ExtObj2",
    586             description="Test code gen for external C functions evaluation. External objects.",
    587             variability_propagation=false,
    588             inline_functions="none",
    589             template="
     581annotation(__JModelica(UnitTesting(tests={
     582    CCodeGenTestCase(
     583        name="ExtObj2",
     584        description="Test code gen for external C functions evaluation. External objects.",
     585        variability_propagation=false,
     586        inline_functions="none",
     587        template="
    590588$ECE_external_includes$
    591589$ECE_record_definitions$
     
    608606$ECE_free$
    609607",
    610             generatedCode="
     608        generatedCode="
    611609#include \"extObjects.h\"
    612610
     
    668666            tmp_11 = (int)tmp_13_arg5;
    669667            tmp_12 = (double)tmp_13_arg6;
    670             my_constructor2(tmp_13_arg0->var, tmp_9->var, &jmi_array_ref_1(tmp_2_arg1, tmp_7), tmp_10->var, tmp_13_arg4->var, tmp_11, tmp_12);
     668            my_constructor2(tmp_13_arg0->var, tmp_9->var, &jmi_array_ref_1(tmp_2_arg1, tmp_7), tmp_10->var, tmp_13_arg4->var, (size_t) tmp_11, tmp_12);
    671669        }
    672670        my_constructor3(tmp_2_arg0, tmp_2_arg1->var, &o3_v);
     
    694692---
    695693        destructor(o3_v);
    696 
    697694")})));
    698695end ExtObj2;
  • branches/dev-cw-evaluator/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenExternalTests.mo

    r12934 r13704  
    11481148
    11491149
    1150     annotation(__JModelica(UnitTesting(tests={
    1151         CCodeGenTestCase(
    1152             name="ExternalArray1",
    1153             description="External C function (undeclared) with one dim array input, scalar output.",
    1154             variability_propagation=false,
    1155             template="
    1156 $C_function_headers$
    1157 $C_functions$
    1158 ",
    1159             generatedCode="
     1150annotation(__JModelica(UnitTesting(tests={
     1151    CCodeGenTestCase(
     1152        name="ExternalArray1",
     1153        description="External C function (undeclared) with one dim array input, scalar output.",
     1154        variability_propagation=false,
     1155        template="
     1156$C_function_headers$
     1157$C_functions$
     1158",
     1159        generatedCode="
    11601160void func_CCodeGenExternalTests_ExternalArray1_f_def0(jmi_array_t* a_a, jmi_real_t* b_o);
    11611161jmi_real_t func_CCodeGenExternalTests_ExternalArray1_f_exp0(jmi_array_t* a_a);
     
    11651165    JMI_DEF(REA, b_v)
    11661166    extern double f(double*, size_t);
    1167     b_v = f(a_a->var, jmi_array_size(a_a, 0));
     1167    b_v = f(a_a->var, (size_t) jmi_array_size(a_a, 0));
    11681168    JMI_RET(GEN, b_o, b_v)
    11691169    JMI_DYNAMIC_FREE()
     
    11761176    return b_v;
    11771177}
    1178 
    11791178
    11801179")})));
     
    11921191        b_out = f(a_in);
    11931192
    1194     annotation(__JModelica(UnitTesting(tests={
    1195         CCodeGenTestCase(
    1196             name="ExternalArray2",
    1197             description="External C function (undeclared) with two dim array input, scalar output.",
    1198             variability_propagation=false,
    1199             template="
    1200 $C_function_headers$
    1201 $C_functions$
    1202 ",
    1203             generatedCode="
     1193annotation(__JModelica(UnitTesting(tests={
     1194    CCodeGenTestCase(
     1195        name="ExternalArray2",
     1196        description="External C function (undeclared) with two dim array input, scalar output.",
     1197        variability_propagation=false,
     1198        template="
     1199$C_function_headers$
     1200$C_functions$
     1201",
     1202        generatedCode="
    12041203void func_CCodeGenExternalTests_ExternalArray2_f_def0(jmi_array_t* a_a, jmi_real_t* b_o);
    12051204jmi_real_t func_CCodeGenExternalTests_ExternalArray2_f_exp0(jmi_array_t* a_a);
     
    12091208    JMI_DEF(REA, b_v)
    12101209    extern double f(double*, size_t, size_t);
    1211     b_v = f(a_a->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1));
     1210    b_v = f(a_a->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1));
    12121211    JMI_RET(GEN, b_o, b_v)
    12131212    JMI_DYNAMIC_FREE()
     
    12201219    return b_v;
    12211220}
    1222 
    12231221
    12241222")})));
     
    12371235        b_out = f(a_in);
    12381236
    1239     annotation(__JModelica(UnitTesting(tests={
    1240         CCodeGenTestCase(
    1241             name="ExternalArray3",
    1242             description="External C function (undeclared) with two dim and unknown no of elements array input, scalar output.",
    1243             variability_propagation=false,
    1244             template="
    1245 $C_function_headers$
    1246 $C_functions$
    1247 ",
    1248             generatedCode="
     1237annotation(__JModelica(UnitTesting(tests={
     1238    CCodeGenTestCase(
     1239        name="ExternalArray3",
     1240        description="External C function (undeclared) with two dim and unknown no of elements array input, scalar output.",
     1241        variability_propagation=false,
     1242        template="
     1243$C_function_headers$
     1244$C_functions$
     1245",
     1246        generatedCode="
    12491247void func_CCodeGenExternalTests_ExternalArray3_f_def0(jmi_array_t* a_a, jmi_real_t* b_o);
    12501248jmi_real_t func_CCodeGenExternalTests_ExternalArray3_f_exp0(jmi_array_t* a_a);
     
    12541252    JMI_DEF(REA, b_v)
    12551253    extern double f(double*, size_t, size_t);
    1256     b_v = f(a_a->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1));
     1254    b_v = f(a_a->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1));
    12571255    JMI_RET(GEN, b_o, b_v)
    12581256    JMI_DYNAMIC_FREE()
     
    12651263    return b_v;
    12661264}
    1267 
    12681265
    12691266")})));
     
    12831280        b_out = f(a_in);
    12841281
    1285     annotation(__JModelica(UnitTesting(tests={
    1286         CCodeGenTestCase(
    1287             name="ExternalArray4",
    1288             description="External C function (undeclared) with one dim array input, one dim array output.",
    1289             variability_propagation=false,
    1290             template="
    1291 $C_function_headers$
    1292 $C_functions$
    1293 ",
    1294             generatedCode="
     1282annotation(__JModelica(UnitTesting(tests={
     1283    CCodeGenTestCase(
     1284        name="ExternalArray4",
     1285        description="External C function (undeclared) with one dim array input, one dim array output.",
     1286        variability_propagation=false,
     1287        template="
     1288$C_function_headers$
     1289$C_functions$
     1290",
     1291        generatedCode="
    12951292void func_CCodeGenExternalTests_ExternalArray4_f_def0(jmi_array_t* a_a, jmi_array_t* b_a);
    12961293
     
    13031300        b_a = b_an;
    13041301    }
    1305     f(a_a->var, jmi_array_size(a_a, 0), b_a->var, jmi_array_size(b_a, 0));
    1306     JMI_DYNAMIC_FREE()
    1307     return;
    1308 }
    1309 
     1302    f(a_a->var, (size_t) jmi_array_size(a_a, 0), b_a->var, (size_t) jmi_array_size(b_a, 0));
     1303    JMI_DYNAMIC_FREE()
     1304    return;
     1305}
    13101306
    13111307")})));
     
    13241320        b_out = f(a_in);
    13251321
    1326     annotation(__JModelica(UnitTesting(tests={
    1327         CCodeGenTestCase(
    1328             name="ExternalArray5",
    1329             description="External C function (undeclared) with two dim array input, two dim array output.",
    1330             variability_propagation=false,
    1331             template="
    1332 $C_function_headers$
    1333 $C_functions$
    1334 ",
    1335             generatedCode="
     1322annotation(__JModelica(UnitTesting(tests={
     1323    CCodeGenTestCase(
     1324        name="ExternalArray5",
     1325        description="External C function (undeclared) with two dim array input, two dim array output.",
     1326        variability_propagation=false,
     1327        template="
     1328$C_function_headers$
     1329$C_functions$
     1330",
     1331        generatedCode="
    13361332void func_CCodeGenExternalTests_ExternalArray5_f_def0(jmi_array_t* a_a, jmi_array_t* b_a);
    13371333
     
    13441340        b_a = b_an;
    13451341    }
    1346     f(a_a->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1), b_a->var, jmi_array_size(b_a, 0), jmi_array_size(b_a, 1));
    1347     JMI_DYNAMIC_FREE()
    1348     return;
    1349 }
    1350 
     1342    f(a_a->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1), b_a->var, (size_t) jmi_array_size(b_a, 0), (size_t) jmi_array_size(b_a, 1));
     1343    JMI_DYNAMIC_FREE()
     1344    return;
     1345}
    13511346
    13521347")})));
     
    13651360        b_out = f(a_in);
    13661361
    1367     annotation(__JModelica(UnitTesting(tests={
    1368         CCodeGenTestCase(
    1369             name="ExternalArray6",
    1370             description="External C function (undeclared) with two dim and unknown no of elements array input, two dim array output.",
    1371             variability_propagation=false,
    1372             template="
    1373 $C_function_headers$
    1374 $C_functions$
    1375 ",
    1376             generatedCode="
     1362annotation(__JModelica(UnitTesting(tests={
     1363    CCodeGenTestCase(
     1364        name="ExternalArray6",
     1365        description="External C function (undeclared) with two dim and unknown no of elements array input, two dim array output.",
     1366        variability_propagation=false,
     1367        template="
     1368$C_function_headers$
     1369$C_functions$
     1370",
     1371        generatedCode="
    13771372void func_CCodeGenExternalTests_ExternalArray6_f_def0(jmi_array_t* a_a, jmi_array_t* b_a);
    13781373
     
    13851380        b_a = b_an;
    13861381    }
    1387     f(a_a->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1), b_a->var, jmi_array_size(b_a, 0), jmi_array_size(b_a, 1));
    1388     JMI_DYNAMIC_FREE()
    1389     return;
    1390 }
    1391 
     1382    f(a_a->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1), b_a->var, (size_t) jmi_array_size(b_a, 0), (size_t) jmi_array_size(b_a, 1));
     1383    JMI_DYNAMIC_FREE()
     1384    return;
     1385}
    13921386
    13931387")})));
     
    14051399        b_out = f(a_in);
    14061400
    1407     annotation(__JModelica(UnitTesting(tests={
    1408         CCodeGenTestCase(
    1409             name="IntegerExternalArray1",
    1410             description="External C function (undeclared) with one dim Integer array input, scalar Real output.",
    1411             variability_propagation=false,
    1412             template="
    1413 $C_function_headers$
    1414 $C_functions$
    1415 ",
    1416             generatedCode="
     1401annotation(__JModelica(UnitTesting(tests={
     1402    CCodeGenTestCase(
     1403        name="IntegerExternalArray1",
     1404        description="External C function (undeclared) with one dim Integer array input, scalar Real output.",
     1405        variability_propagation=false,
     1406        template="
     1407$C_function_headers$
     1408$C_functions$
     1409",
     1410        generatedCode="
    14171411void func_CCodeGenExternalTests_IntegerExternalArray1_f_def0(jmi_array_t* a_a, jmi_real_t* b_o);
    14181412jmi_real_t func_CCodeGenExternalTests_IntegerExternalArray1_f_exp0(jmi_array_t* a_a);
     
    14251419    JMI_ARRAY_INIT_1(HEAP, jmi_int_t, jmi_int_array_t, tmp_1, jmi_array_size(a_a, 0), 1, jmi_array_size(a_a, 0))
    14261420    jmi_copy_matrix_to_int(a_a, a_a->var, tmp_1->var);
    1427     b_v = f(tmp_1->var, jmi_array_size(a_a, 0));
     1421    b_v = f(tmp_1->var, (size_t) jmi_array_size(a_a, 0));
    14281422    JMI_RET(GEN, b_o, b_v)
    14291423    JMI_DYNAMIC_FREE()
     
    14361430    return b_v;
    14371431}
    1438 
    14391432
    14401433")})));
     
    14521445        b_out = f(a_in);   
    14531446
    1454     annotation(__JModelica(UnitTesting(tests={
    1455         CCodeGenTestCase(
    1456             name="IntegerExternalArray2",
    1457             description="External C function (undeclared) with two dim Integer array input, scalar Real output.",
    1458             variability_propagation=false,
    1459             template="
    1460 $C_function_headers$
    1461 $C_functions$
    1462 ",
    1463             generatedCode="
     1447annotation(__JModelica(UnitTesting(tests={
     1448    CCodeGenTestCase(
     1449        name="IntegerExternalArray2",
     1450        description="External C function (undeclared) with two dim Integer array input, scalar Real output.",
     1451        variability_propagation=false,
     1452        template="
     1453$C_function_headers$
     1454$C_functions$
     1455",
     1456        generatedCode="
    14641457void func_CCodeGenExternalTests_IntegerExternalArray2_f_def0(jmi_array_t* a_a, jmi_real_t* b_o);
    14651458jmi_real_t func_CCodeGenExternalTests_IntegerExternalArray2_f_exp0(jmi_array_t* a_a);
     
    14721465    JMI_ARRAY_INIT_2(HEAP, jmi_int_t, jmi_int_array_t, tmp_1, jmi_array_size(a_a, 0) * jmi_array_size(a_a, 1), 2, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1))
    14731466    jmi_copy_matrix_to_int(a_a, a_a->var, tmp_1->var);
    1474     b_v = f(tmp_1->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1));
     1467    b_v = f(tmp_1->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1));
    14751468    JMI_RET(GEN, b_o, b_v)
    14761469    JMI_DYNAMIC_FREE()
     
    14831476    return b_v;
    14841477}
    1485 
    14861478
    14871479")})));
     
    14991491        b_out = f(a_in);
    15001492
    1501     annotation(__JModelica(UnitTesting(tests={
    1502         CCodeGenTestCase(
    1503             name="IntegerExternalArray3",
    1504             description="External C function (undeclared) with one scalar Real input, one dim array Integer output.",
    1505             variability_propagation=false,
    1506             template="
    1507 $C_function_headers$
    1508 $C_functions$
    1509 ",
    1510             generatedCode="
     1493annotation(__JModelica(UnitTesting(tests={
     1494    CCodeGenTestCase(
     1495        name="IntegerExternalArray3",
     1496        description="External C function (undeclared) with one scalar Real input, one dim array Integer output.",
     1497        variability_propagation=false,
     1498        template="
     1499$C_function_headers$
     1500$C_functions$
     1501",
     1502        generatedCode="
    15111503void func_CCodeGenExternalTests_IntegerExternalArray3_f_def0(jmi_real_t a_v, jmi_array_t* b_a);
    15121504
     
    15221514    JMI_ARRAY_INIT_1(HEAP, jmi_int_t, jmi_int_array_t, tmp_1, jmi_array_size(b_a, 0), 1, jmi_array_size(b_a, 0))
    15231515    jmi_copy_matrix_to_int(b_a, b_a->var, tmp_1->var);
    1524     f(a_v, tmp_1->var, jmi_array_size(b_a, 0));
     1516    f(a_v, tmp_1->var, (size_t) jmi_array_size(b_a, 0));
    15251517    jmi_copy_matrix_from_int(b_a, tmp_1->var, b_a->var);
    15261518    JMI_DYNAMIC_FREE()
    15271519    return;
    15281520}
    1529 
    15301521
    15311522")})));
     
    15441535        b_out = f(a_in);   
    15451536
    1546     annotation(__JModelica(UnitTesting(tests={
    1547         CCodeGenTestCase(
    1548             name="IntegerExternalArray4",
    1549             description="External C function (undeclared) with one 2-dim Integer array input, one 2-dim Integer array output.",
    1550             variability_propagation=false,
    1551             template="
    1552 $C_function_headers$
    1553 $C_functions$
    1554 ",
    1555             generatedCode="
     1537annotation(__JModelica(UnitTesting(tests={
     1538    CCodeGenTestCase(
     1539        name="IntegerExternalArray4",
     1540        description="External C function (undeclared) with one 2-dim Integer array input, one 2-dim Integer array output.",
     1541        variability_propagation=false,
     1542        template="
     1543$C_function_headers$
     1544$C_functions$
     1545",
     1546        generatedCode="
    15561547void func_CCodeGenExternalTests_IntegerExternalArray4_f_def0(jmi_array_t* a_a, jmi_array_t* b_a);
    15571548
     
    15701561    JMI_ARRAY_INIT_2(HEAP, jmi_int_t, jmi_int_array_t, tmp_2, jmi_array_size(b_a, 0) * jmi_array_size(b_a, 1), 2, jmi_array_size(b_a, 0), jmi_array_size(b_a, 1))
    15711562    jmi_copy_matrix_to_int(b_a, b_a->var, tmp_2->var);
    1572     f(tmp_1->var, jmi_array_size(a_a, 0), jmi_array_size(a_a, 1), tmp_2->var, jmi_array_size(b_a, 0), jmi_array_size(b_a, 1));
     1563    f(tmp_1->var, (size_t) jmi_array_size(a_a, 0), (size_t) jmi_array_size(a_a, 1), tmp_2->var, (size_t) jmi_array_size(b_a, 0), (size_t) jmi_array_size(b_a, 1));
    15731564    jmi_copy_matrix_from_int(b_a, tmp_2->var, b_a->var);
    15741565    JMI_DYNAMIC_FREE()
    15751566    return;
    15761567}
    1577 
    15781568
    15791569")})));
  • branches/dev-cw-evaluator/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenGlobalsTests.mo

    r13099 r13704  
    478478    Real y = f1(time) + f2(time);
    479479
    480     annotation(__JModelica(UnitTesting(tests={
    481         CCodeGenTestCase(
    482             name="GlobalConstantScalar1",
    483             description="Constants in external calls",
    484             variability_propagation=false,
    485             template="
     480annotation(__JModelica(UnitTesting(tests={
     481    CCodeGenTestCase(
     482        name="GlobalConstantScalar1",
     483        description="Constants in external calls",
     484        variability_propagation=false,
     485        template="
    486486$C_global_temps$
    487487$C_model_init_eval_independent_globals$
     
    489489$C_functions$
    490490",
    491             generatedCode="
     491        generatedCode="
    492492    jmi_real_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_c;
    493493    jmi_array_t* CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f1_d;
     
    555555    JMI_DEF(REA, y_v)
    556556    extern double f2(double, double, double*, size_t);
    557     y_v = f2(x_v, JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c), JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d)->var, jmi_array_size(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d), 0));
     557    y_v = f2(x_v, JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_c), JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d)->var, (size_t) jmi_array_size(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantScalar1_f2_d), 0));
    558558    JMI_RET(GEN, y_o, y_v)
    559559    JMI_DYNAMIC_FREE()
     
    14371437    JMI_DEF(EXO, eo_v)
    14381438    extern void* constructor(double*, size_t);
    1439     eo_v = constructor(x_a->var, jmi_array_size(x_a, 0));
     1439    eo_v = constructor(x_a->var, (size_t) jmi_array_size(x_a, 0));
    14401440    JMI_RET(GEN, eo_o, eo_v)
    14411441    JMI_DYNAMIC_FREE()
     
    14511451
    14521452    func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo));
    1453 
    14541453")})));
    14551454end GlobalConstantExternalObject1;
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/Arrays.jrag

    r13017 r13704  
    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-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13629 r13704  
    8080         * Copy this constant value.
    8181         */
     82        @Override
    8283        public CValue clone() {
    8384            try {
     
    117118         */
    118119        public CValue convertInteger() {
    119             return new CValueInteger(intValue());
     120            return CValueInteger.valueOf(intValue());
    120121        }
    121122
     
    124125         */
    125126        public CValue convertReal() {
    126             return new CValueReal(realValue());
     127            return CValueReal.valueOf(realValue());
    127128        }
    128129
     
    131132         */
    132133        public CValue convertBoolean() {
    133             return new CValueBoolean(booleanValue());
     134            return CValueBoolean.valueOf(booleanValue());
    134135        }
    135136
     
    299300     */
    300301    public class CValueInteger extends CValue {
    301         private int value;
    302        
    303         /**
    304          * Constructor.
    305          *
    306          * @param i Integer value.
    307          */
    308         public CValueInteger(int i) {
     302        private final int value;
     303       
     304        private CValueInteger(int i) {
    309305            this.value = i;
     306        }
     307       
     308        private static final CValueInteger ZERO = new CValueInteger(0);
     309       
     310        public static CValueInteger valueOf(int i) {
     311            if (i == 0) {
     312                return ZERO;
     313            }
     314            return new CValueInteger(i);
    310315        }
    311316
     
    420425            return true;
    421426        }
     427       
     428        @Override
     429        public CValueInteger clone() {
     430            return this;
     431        }       
    422432    }
    423433   
     
    426436     */     
    427437    public class CValueReal extends CValue {
    428         private double value;
     438        private final double value;
    429439       
    430440        /**
     
    433443         * @param d Double value.
    434444         */
    435         public CValueReal(double d) {
     445        private CValueReal(double d) {
    436446            this.value = d;
     447        }
     448       
     449        private static final CValueReal ZERO = new CValueReal(0.0);
     450       
     451        public static CValueReal valueOf(double d) {
     452            if (d == 0.0 && (Double.doubleToLongBits(d) & 0x8000000000000000L) == 0L) {
     453                return ZERO;
     454            }
     455            return new CValueReal(d);
    437456        }
    438457
     
    548567            return true;
    549568        }
     569       
     570        @Override
     571        public CValueReal clone() {
     572            return this;
     573        }       
     574       
    550575    }
    551576   
     
    560585        public static final CValueBoolean TRUE  = new CValueBoolean(true);
    561586       
    562         private boolean value;
     587        private final boolean value;
    563588
    564589        /**
     
    567592         * @param b Boolean value.
    568593         */
    569         public CValueBoolean(boolean b) {
    570             this.value = b;
     594        private CValueBoolean(boolean b) {
     595            this.value = b;
     596        }
     597       
     598        public static CValueBoolean valueOf(boolean b) {
     599            return b ? TRUE : FALSE;
    571600        }
    572601
     
    650679            return true;
    651680        }
     681       
     682        @Override
     683        public CValueBoolean clone() {
     684            return this;
     685        }
    652686    }
    653687
     
    656690     */
    657691    public class CValueString extends CValue {
    658         private String value;
     692        private final String value;
    659693       
    660694        /**
     
    716750            return true;
    717751        }
     752       
     753        @Override
     754        public CValueString clone() {
     755            return this;
     756        }       
     757       
    718758      }
    719759   
     
    16141654    public class CValueEnum extends CValue {
    16151655
    1616         private FEnumType type;
    1617         private String value;
    1618         private int index;
     1656        private final FEnumType type;
     1657        private final String value;
     1658        private final int index;
    16191659
    16201660        /**
     
    16271667            this.type = (FEnumType) type;
    16281668            this.value = value;
    1629             index = 0;
     1669            int temp_index = 0;
    16301670            int n = this.type.getNumFEnumLiteralType();
    1631             for (int i = 0; i < n && index == 0; i++)
    1632                 if (this.type.getFEnumLiteralType(i).getName().equals(value))
    1633                     index = i + 1;
     1671            for (int i = 0; i < n && temp_index == 0; i++) {
     1672                if (this.type.getFEnumLiteralType(i).getName().equals(value)) {
     1673                    temp_index = i + 1;
     1674                }
     1675            }
     1676            index = temp_index;
    16341677        }
    16351678
     
    17051748         *  @return an CommonAccessExp pointing to the literal in the FEnumDecl.
    17061749         */
     1750        @Override
    17071751        public FExp buildLiteral() {
    17081752            return type.createLiteral(index);
     
    17191763        }
    17201764
     1765        @Override
    17211766        public CValue constrainWithin(CValue min, CValue max) {
    17221767            if (!min.isUnknown() && min.intValue() > index)
     
    17261771            return this;
    17271772        }
     1773       
     1774       @Override
     1775       public CValueEnum clone() {
     1776           return this;
     1777       }
    17281778
    17291779    }
     
    17461796    public CValue FType.zeroCValueScalar()        { return CValue.UNKNOWN; }
    17471797    public CValue FArrayType.zeroCValueScalar()   { return getFPrimitiveType().zeroCValueScalar(); }
    1748     public CValue FRealType.zeroCValueScalar()    { return new CValueReal(0.0); }
    1749     public CValue FIntegerType.zeroCValueScalar() { return new CValueInteger(0); }
     1798    public CValue FRealType.zeroCValueScalar()    { return CValueReal.valueOf(0.0); }
     1799    public CValue FIntegerType.zeroCValueScalar() { return CValueInteger.valueOf(0); }
    17501800    public CValue FEnumType.zeroCValueScalar()    { return new CValueEnum(this, 1); }
    17511801    public CValue FStringType.zeroCValueScalar()  { return new CValueString(""); }
    1752     public CValue FBooleanType.zeroCValueScalar() { return new CValueBoolean(false); }
     1802    public CValue FBooleanType.zeroCValueScalar() { return CValueBoolean.FALSE; }
    17531803   
    17541804    public CValue FType.createCValue(int v) {
     
    17631813    }
    17641814   
    1765     public CValue FType.createCValueScalar(int v)     { return new CValueInteger(v); }
    1766     public CValue FRealType.createCValueScalar(int v) { return new CValueReal(v); }
     1815    public CValue FType.createCValueScalar(int v)     { return CValueInteger.valueOf(v); }
     1816    public CValue FRealType.createCValueScalar(int v) { return CValueReal.valueOf(v); }
    17671817
    17681818    public CValue FType.convert(CValue v)        { return v; }
     
    17731823
    17741824    public CValue FType.limitCValueScalar(boolean high)        { return CValue.UNSUPPORTED; }
    1775     public CValue FRealType.limitCValueScalar(boolean high)    { return new CValueReal(      high ? Double.MAX_VALUE  : -Double.MAX_VALUE); }
    1776     public CValue FIntegerType.limitCValueScalar(boolean high) { return new CValueInteger(   high ? Integer.MAX_VALUE : Integer.MIN_VALUE); }
    1777     public CValue FBooleanType.limitCValueScalar(boolean high) { return new CValueBoolean(   high ? true : false); }
     1825    public CValue FRealType.limitCValueScalar(boolean high)    { return CValueReal.valueOf(      high ? Double.MAX_VALUE  : -Double.MAX_VALUE); }
     1826    public CValue FIntegerType.limitCValueScalar(boolean high) { return CValueInteger.valueOf(   high ? Integer.MAX_VALUE : Integer.MIN_VALUE); }
     1827    public CValue FBooleanType.limitCValueScalar(boolean high) { return CValueBoolean.valueOf(high); }
    17781828    public CValue FEnumType.limitCValueScalar(boolean high)    { return new CValueEnum(this, high ? getNumFEnumLiteralType() : 1); }
    17791829
     
    23872437       
    23882438        FType t = type();
    2389         CValue sum = new CValueInteger(0);
     2439        CValue sum = CValueInteger.valueOf(0);
    23902440        CValueArray l = getLeft().ceval(evaluator).array();
    23912441        CValueArray r = getRight().ceval(evaluator).array();
     
    24812531   
    24822532    eq FEndExp.cevalCalc(VariableEvaluator evaluator) = mySize().ceval(evaluator, 0);
    2483     eq FNdimsExp.cevalCalc(VariableEvaluator evaluator) = new CValueInteger(getFExp().ndims());
     2533    eq FNdimsExp.cevalCalc(VariableEvaluator evaluator) = CValueInteger.valueOf(getFExp().ndims());
    24842534   
    24852535    eq FSubscriptedExp.cevalCalc(VariableEvaluator evaluator) {
     
    24902540    eq FCardinality.cevalCalc(VariableEvaluator evaluator) {
    24912541        final int v = getFExp().cardinalityValue();
    2492         return (v <= 0) ? CValue.UNKNOWN : new CValueInteger(v);
     2542        return (v <= 0) ? CValue.UNKNOWN : CValueInteger.valueOf(v);
    24932543    }
    24942544
     
    25002550    eq FConnBoolOp.cevalCalc(VariableEvaluator evaluator) {
    25012551        if (connectionGraph != null && connectionGraph.builtTreesDone())
    2502           return new CValueBoolean(cevalFromGraph());
     2552          return CValueBoolean.valueOf(cevalFromGraph());
    25032553        else
    25042554          throw new ConstantEvaluationNotReadyException();
     
    25472597    public CValue Size.ceval(VariableEvaluator evaluator, int d) {
    25482598        int s = get(d);
    2549         return (s == Size.UNKNOWN) ? CValue.UNKNOWN : new CValueInteger(s);
     2599        return (s == Size.UNKNOWN) ? CValue.UNKNOWN : CValueInteger.valueOf(s);
    25502600    }
    25512601
     
    26142664    /** Set the value for initial() to evaluate to. */
    26152665    public static void FInitialExp.setIsInitial(boolean value) {
    2616           evaluationValue = new CValueBoolean(value);
     2666          evaluationValue = CValueBoolean.valueOf(value);
    26172667    }
    26182668
     
    26292679    eq FMaxExp.selectLesser() = false;
    26302680
    2631     eq FRealLitExp.cevalCalc(VariableEvaluator evaluator)         = new CValueReal(getValue());
    2632     eq FIntegerLitExp.cevalCalc(VariableEvaluator evaluator)      = new CValueInteger(getValue());
    2633     eq FBooleanLitExpTrue.cevalCalc(VariableEvaluator evaluator)  = new CValueBoolean(true);
    2634     eq FBooleanLitExpFalse.cevalCalc(VariableEvaluator evaluator) = new CValueBoolean(false);
     2681    eq FRealLitExp.cevalCalc(VariableEvaluator evaluator)         = CValueReal.valueOf(getValue());
     2682    eq FIntegerLitExp.cevalCalc(VariableEvaluator evaluator)      = CValueInteger.valueOf(getValue());
     2683    eq FBooleanLitExpTrue.cevalCalc(VariableEvaluator evaluator)  = CValueBoolean.TRUE;
     2684    eq FBooleanLitExpFalse.cevalCalc(VariableEvaluator evaluator) = CValueBoolean.FALSE;
    26352685    eq FStringLitExp.cevalCalc(VariableEvaluator evaluator)       = new CValueString(unEscape());
    26362686    eq FEnumLitExp.cevalCalc(VariableEvaluator evaluator)         = new CValueEnum(type(), getValue());
     
    26892739    eq FAbstractDerExp.cevalUse(VariableEvaluator evaluator) {
    26902740        if (getFAccess().variability().discreteOrLess())
    2691             return new CValueInteger(0);
     2741            return CValueInteger.valueOf(0);
    26922742        FAbstractVariable decl = myFV();
    26932743        return decl == null ? CValue.UNKNOWN : evaluator.ceval(decl);
     
    27062756    eq InstGlobalAccess.ceval(VariableEvaluator evaluator, Index i)   = getInstAccess().ceval(evaluator, i);
    27072757    eq InstNamedAccess.ceval(VariableEvaluator evaluator, Index i) {
    2708         CValue res = unknownCValue();
     2758        CValue res;
    27092759        if (myInstComponentDecl().isAssignable()) {
    27102760          Index iHere = Index.NULL;
     
    27282778              res = res.getCell(iHere);
    27292779        } else if (myInstClassDecl().isEnum()) {
    2730             res = new CValueInteger(myInstClassDecl().enumLiterals().size());
     2780            res = CValueInteger.valueOf(myInstClassDecl().enumLiterals().size());
    27312781        } else if (myInstClassDecl().isBoolean()) {
    2732             res = new CValueInteger(2);
     2782            res = CValueInteger.valueOf(2);
     2783        } else {
     2784            res = unknownCValue();
    27332785        }
    27342786        return res;
     
    27862838    eq FAbsExp.cevalCalc(VariableEvaluator evaluator)  = type().abs(getFExp().ceval(evaluator));
    27872839    eq FSignExp.cevalCalc(VariableEvaluator evaluator) = type().sign(getFExp().ceval(evaluator));
    2788     eq FSqrtExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.sqrt(getFExp().ceval(evaluator).realValue()));
     2840    eq FSqrtExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.sqrt(getFExp().ceval(evaluator).realValue()));
    27892841    eq FEnumIntegerExp.cevalCalc(VariableEvaluator evaluator) = getFExp().ceval(evaluator).convertInteger();
    27902842    eq FStringExp.cevalCalc(VariableEvaluator evaluator) {
     
    27922844            return CValue.UNKNOWN;
    27932845        }
     2846       
    27942847        CValue cval = getValue().ceval(evaluator);
    2795         if (getValue().type().isReal()) {
     2848        boolean isReal = getValue().type().isReal();
     2849        if (isReal) {
    27962850            cval = cval.convertReal();
    27972851        }
    27982852        Object value = cval.objectValue();
    2799         String format = formatString(evaluator);
    2800         return new CValueString(String.format((Locale) null, format, value));
     2853        final String format = formatString(evaluator);
     2854        char formatChar = format.charAt(format.length() - 1);
     2855       
     2856        // Modelica allows Integer to Real conversion for formatting but not the other direction
     2857        boolean mustBeInteger = formatChar == 'd' || formatChar == 'i' || formatChar == 'o' ||
     2858            formatChar == 'x' || formatChar == 'X' || formatChar == 'u' || formatChar == 'c';
     2859        if (mustBeInteger && isReal) {
     2860            throw new ConstantEvaluationException(cval, "format the resulting value. The format '"+ format + "' requires value of Integer type but Real value is provided. ");
     2861        }
     2862
     2863        if (getValue().type().isInteger()) {
     2864            // Java formatter do not convert types
     2865            final boolean convertToFloat = formatChar == 'e' || formatChar == 'E' ||
     2866                    formatChar == 'f' || formatChar == 'g' || formatChar == 'G';
     2867            if (convertToFloat) {
     2868                return new CValueString(String.format((Locale) null, format, cval.realValue()));
     2869            }
     2870            if (formatChar == 'u') {
     2871                String formatCorrect = format.substring(0, format.length()-1) + "s";
     2872                long unsigned = ((long) cval.intValue()) & 0xffffffffL; // Java 8 Integer.toUnsignedLong
     2873                return new CValueString(String.format((Locale) null, formatCorrect, unsigned));
     2874            }
     2875
     2876            if (formatChar == 'i') {
     2877                String formatCorrect = format.substring(0, format.length()-1) + "d";
     2878                return new CValueString(String.format((Locale) null, formatCorrect, cval.intValue()));
     2879            }
     2880        }
     2881       
     2882        try {
     2883            return new CValueString(String.format((Locale) null, format, value));
     2884        } catch (java.util.IllegalFormatException e) {
     2885            throw new ConstantEvaluationException(cval,
     2886                    "format the resulting value. " + format + " is not a supported valid format string");
     2887        }
    28012888    }
    28022889    eq FGetInstanceName.cevalCalc(VariableEvaluator evaluator) = new CValueString(calcInstanceName());
     
    28542941    eq FIntegerFuncExp.cevalCalc(VariableEvaluator evaluator)     = getX().ceval(evaluator).convertInteger();
    28552942
    2856     eq FSinExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.sin(getFExp().ceval(evaluator).realValue()));
    2857     eq FCosExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.cos(getFExp().ceval(evaluator).realValue()));
    2858     eq FTanExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.tan(getFExp().ceval(evaluator).realValue()));
    2859     eq FAsinExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.asin(getFExp().ceval(evaluator).realValue()));
    2860     eq FAcosExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.acos(getFExp().ceval(evaluator).realValue()));
    2861     eq FAtanExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.atan(getFExp().ceval(evaluator).realValue()));
    2862     eq FAtan2Exp.cevalCalc(VariableEvaluator evaluator) = new CValueReal(StrictMath.atan2(getFExp().ceval(evaluator).realValue(),
     2943    eq FSinExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.sin(getFExp().ceval(evaluator).realValue()));
     2944    eq FCosExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.cos(getFExp().ceval(evaluator).realValue()));
     2945    eq FTanExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.tan(getFExp().ceval(evaluator).realValue()));
     2946    eq FAsinExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.asin(getFExp().ceval(evaluator).realValue()));
     2947    eq FAcosExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.acos(getFExp().ceval(evaluator).realValue()));
     2948    eq FAtanExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.atan(getFExp().ceval(evaluator).realValue()));
     2949    eq FAtan2Exp.cevalCalc(VariableEvaluator evaluator) = CValueReal.valueOf(StrictMath.atan2(getFExp().ceval(evaluator).realValue(),
    28632950                                                               getY().ceval(evaluator).realValue()));
    2864     eq FSinhExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.sinh(getFExp().ceval(evaluator).realValue()));
    2865     eq FCoshExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.cosh(getFExp().ceval(evaluator).realValue()));
    2866     eq FTanhExp.cevalCalc(VariableEvaluator evaluator)  = new CValueReal(StrictMath.tanh(getFExp().ceval(evaluator).realValue()));
    2867     eq FExpExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.exp(getFExp().ceval(evaluator).realValue()));
    2868     eq FLogExp.cevalCalc(VariableEvaluator evaluator)   = new CValueReal(StrictMath.log(getFExp().ceval(evaluator).realValue()));
    2869     eq FLog10Exp.cevalCalc(VariableEvaluator evaluator) = new CValueReal(StrictMath.log10(getFExp().ceval(evaluator).realValue()));
     2951    eq FSinhExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.sinh(getFExp().ceval(evaluator).realValue()));
     2952    eq FCoshExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.cosh(getFExp().ceval(evaluator).realValue()));
     2953    eq FTanhExp.cevalCalc(VariableEvaluator evaluator)  = CValueReal.valueOf(StrictMath.tanh(getFExp().ceval(evaluator).realValue()));
     2954    eq FExpExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.exp(getFExp().ceval(evaluator).realValue()));
     2955    eq FLogExp.cevalCalc(VariableEvaluator evaluator)   = CValueReal.valueOf(StrictMath.log(getFExp().ceval(evaluator).realValue()));
     2956    eq FLog10Exp.cevalCalc(VariableEvaluator evaluator) = CValueReal.valueOf(StrictMath.log10(getFExp().ceval(evaluator).realValue()));
    28702957
    28712958    eq FExInStream.cevalCalc(VariableEvaluator evaluator) {
     
    28962983                div += flow;
    28972984            }
    2898             return new CValueReal(sum / div);
     2985            return CValueReal.valueOf(sum / div);
    28992986        }
    29002987    }
     
    29052992    syn CValue FSubscript.ceval(VariableEvaluator evaluator) = CValue.UNSUPPORTED;
    29062993    eq FExpSubscript.ceval(VariableEvaluator evaluator)      = getFExp().ceval(evaluator);
    2907     eq FIntegerSubscript.ceval(VariableEvaluator evaluator)  = new CValueInteger(getValue());
     2994    eq FIntegerSubscript.ceval(VariableEvaluator evaluator)  = CValueInteger.valueOf(getValue());
    29082995   
    29092996    syn int FSubscript.value()   = ceval(defaultVariableEvaluator()).intValue();
     
    31423229    eq InstPrimitive.attributeCValueDefault(String name) {
    31433230        if (name.equals(FAttribute.FIXED))
    3144             return new CValueBoolean(isConstant() || isParameter() || isString());
     3231            return CValueBoolean.valueOf(isConstant() || isParameter() || isString());
    31453232        CValue res = attributeCValueDefaultMap().get(name);
    31463233        return (res == null) ? CValue.UNKNOWN : res;
     
    31683255            real.put(FAttribute.UNIT, emptyStr);
    31693256            real.put(FAttribute.DISPLAY_UNIT, emptyStr);
    3170             real.put(FAttribute.START, new CValueReal(0.0));
     3257            real.put(FAttribute.START, CValueReal.valueOf(0.0));
    31713258            // TODO: add stateSelect, but how to get type?
    31723259            REAL_DEFAULT_ATTRIBUTES = real;
    31733260            Map<String,CValue> integer = new HashMap<String,CValue>();
    31743261            integer.put(FAttribute.QUANTITY, emptyStr);
    3175             integer.put(FAttribute.START, new CValueInteger(0));
     3262            integer.put(FAttribute.START, CValueInteger.valueOf(0));
    31763263            INTEGER_DEFAULT_ATTRIBUTES = integer;
    31773264            Map<String,CValue> bool = new HashMap<String,CValue>();
     
    41964283            return CValue.UNKNOWN;
    41974284        }
    4198         return new CValueReal(v1.realValue() + v2.realValue());
     4285        return CValueReal.valueOf(v1.realValue() + v2.realValue());
    41994286    }
    42004287
     
    42034290            return CValue.UNKNOWN;
    42044291        }
    4205         return new CValueInteger(v1.intValue() + v2.intValue());
     4292        return CValueInteger.valueOf(v1.intValue() + v2.intValue());
    42064293    }
    42074294
     
    42264313            return CValue.UNKNOWN;
    42274314        }
    4228         return new CValueReal(v1.realValue() - v2.realValue());
     4315        return CValueReal.valueOf(v1.realValue() - v2.realValue());
    42294316    }
    42304317
     
    42334320            return CValue.UNKNOWN;
    42344321        }
    4235         return new CValueInteger(v1.intValue() - v2.intValue());
     4322        return CValueInteger.valueOf(v1.intValue() - v2.intValue());
    42364323    }
    42374324
     
    42494336            return CValue.UNKNOWN;
    42504337        }
    4251         return new CValueReal(v1.realValue() * v2.realValue());
     4338        return CValueReal.valueOf(v1.realValue() * v2.realValue());
    42524339    }
    42534340
     
    42564343            return CValue.UNKNOWN;
    42574344        }
    4258         return new CValueInteger(v1.intValue() * v2.intValue());
     4345        return CValueInteger.valueOf(v1.intValue() * v2.intValue());
    42594346    }
    42604347
     
    42724359            return CValue.UNKNOWN;
    42734360        }
    4274         return new CValueReal(v1.realValue() / v2.realValue());
     4361        return CValueReal.valueOf(v1.realValue() / v2.realValue());
    42754362    }
    42764363
     
    42794366            return CValue.UNKNOWN;
    42804367        }
    4281         return new CValueReal(v1.realValue() / v2.realValue());
     4368        return CValueReal.valueOf(v1.realValue() / v2.realValue());
    42824369    }
    42834370
     
    42954382            return CValue.UNKNOWN;
    42964383        }
    4297         return new CValueReal(java.lang.StrictMath.pow(v1.realValue(), v2.realValue()));
     4384        return CValueReal.valueOf(java.lang.StrictMath.pow(v1.realValue(), v2.realValue()));
    42984385    }
    42994386
     
    43054392     */
    43064393    syn CValue FType.neg(CValue v) = CValue.UNKNOWN;
    4307     eq FRealType.neg(CValue v) = v.hasRealValue() ? new CValueReal(-v.realValue()) : CValue.UNKNOWN;
    4308     eq FIntegerType.neg(CValue v) = v.hasIntValue() ? new CValueInteger(-v.intValue()) : CValue.UNKNOWN;
     4394    eq FRealType.neg(CValue v) = v.hasRealValue() ? CValueReal.valueOf(-v.realValue()) : CValue.UNKNOWN;
     4395    eq FIntegerType.neg(CValue v) = v.hasIntValue() ? CValueInteger.valueOf(-v.intValue()) : CValue.UNKNOWN;
    43094396
    43104397    /**
     
    43154402     */
    43164403    syn CValue FType.abs(CValue v) = CValue.UNKNOWN;
    4317     eq FRealType.abs(CValue v) = v.hasRealValue() ? new CValueReal(StrictMath.abs(v.realValue())) : CValue.UNKNOWN;
     4404    eq FRealType.abs(CValue v) = v.hasRealValue() ? CValueReal.valueOf(StrictMath.abs(v.realValue())) : CValue.UNKNOWN;
    43184405    eq FIntegerType.abs(CValue v) =
    4319             v.hasIntValue() ? new CValueInteger(StrictMath.abs(v.intValue())) : CValue.UNKNOWN;
     4406            v.hasIntValue() ? CValueInteger.valueOf(StrictMath.abs(v.intValue())) : CValue.UNKNOWN;
    43204407
    43214408    /**
     
    43284415
    43294416    eq FIntegerType.sign(CValue v) =
    4330             v.hasIntValue() ? new CValueInteger((int) StrictMath.signum(v.realValue())) : CValue.UNKNOWN;
     4417            v.hasIntValue() ? CValueInteger.valueOf((int) StrictMath.signum(v.realValue())) : CValue.UNKNOWN;
    43314418
    43324419    /**
     
    43384425    syn CValue FType.ceil(CValue v) = CValue.UNKNOWN;
    43394426
    4340     eq FRealType.ceil(CValue v) = v.hasRealValue() ? new CValueReal(StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
     4427    eq FRealType.ceil(CValue v) = v.hasRealValue() ? CValueReal.valueOf(StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
    43414428
    43424429    eq FIntegerType.ceil(CValue v) =
    4343             v.hasIntValue() ? new CValueInteger((int) StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
     4430            v.hasIntValue() ? CValueInteger.valueOf((int) StrictMath.ceil(v.realValue())) : CValue.UNKNOWN;
    43444431
    43454432    /**
     
    43784465            return CValue.UNKNOWN;
    43794466        }
    4380         return new CValueBoolean(v1.booleanValue() && v2.booleanValue());
     4467        return CValueBoolean.valueOf(v1.booleanValue() && v2.booleanValue());
    43814468    }
    43824469
     
    43944481            return CValue.UNKNOWN;
    43954482        }
    4396         return new CValueBoolean(v1.booleanValue() || v2.booleanValue());
     4483        return CValueBoolean.valueOf(v1.booleanValue() || v2.booleanValue());
    43974484    }
    43984485
     
    44044491     */
    44054492    syn CValue FType.not(CValue v) = CValue.UNKNOWN;
    4406     eq FBooleanType.not(CValue v) = v.isBoolean() ? new CValueBoolean(!v.booleanValue()) : CValue.UNKNOWN;
     4493    eq FBooleanType.not(CValue v) = v.isBoolean() ? CValueBoolean.valueOf(!v.booleanValue()) : CValue.UNKNOWN;
    44074494
    44084495    /* Machine epsilon */
     
    44294516            return CValue.UNKNOWN;
    44304517        }
    4431         return new CValueBoolean(v1.intValue() == v2.intValue());
     4518        return CValueBoolean.valueOf(v1.intValue() == v2.intValue());
    44324519    }
    44334520
     
    44364523            return CValue.UNKNOWN;
    44374524        }
    4438         return new CValueBoolean(almostZero(v1.realValue() - v2.realValue()));
     4525        return CValueBoolean.valueOf(almostZero(v1.realValue() - v2.realValue()));
    44394526    }
    44404527
     
    44434530            return CValue.UNKNOWN;
    44444531        }
    4445         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) == 0);
     4532        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) == 0);
    44464533    }
    44474534
     
    44594546            return CValue.UNKNOWN;
    44604547        }
    4461         return new CValueBoolean(v1.intValue() != v2.intValue());
     4548        return CValueBoolean.valueOf(v1.intValue() != v2.intValue());
    44624549    }
    44634550
     
    44664553            return CValue.UNKNOWN;
    44674554        }
    4468         return new CValueBoolean(v1.realValue() != v2.realValue());
     4555        return CValueBoolean.valueOf(v1.realValue() != v2.realValue());
    44694556    }
    44704557
     
    44734560            return CValue.UNKNOWN;
    44744561        }
    4475         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) != 0);
     4562        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) != 0);
    44764563    }
    44774564
     
    44894576            return CValue.UNKNOWN;
    44904577        }
    4491         return new CValueBoolean(v1.intValue() >= v2.intValue());
     4578        return CValueBoolean.valueOf(v1.intValue() >= v2.intValue());
    44924579    }
    44934580
     
    44964583            return CValue.UNKNOWN;
    44974584        }
    4498         return new CValueBoolean(almostGtZero(v1.realValue() - v2.realValue()));
     4585        return CValueBoolean.valueOf(almostGtZero(v1.realValue() - v2.realValue()));
    44994586    }
    45004587
     
    45034590            return CValue.UNKNOWN;
    45044591        }
    4505         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) >= 0);
     4592        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) >= 0);
    45064593    }
    45074594
     
    45194606            return CValue.UNKNOWN;
    45204607        }
    4521         return new CValueBoolean(v1.intValue() > v2.intValue());
     4608        return CValueBoolean.valueOf(v1.intValue() > v2.intValue());
    45224609    }
    45234610
     
    45264613            return CValue.UNKNOWN;
    45274614        }
    4528         return new CValueBoolean(v1.realValue() > v2.realValue());
     4615        return CValueBoolean.valueOf(v1.realValue() > v2.realValue());
    45294616    }
    45304617
     
    45334620            return CValue.UNKNOWN;
    45344621        }
    4535         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) > 0);
     4622        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) > 0);
    45364623    }
    45374624
     
    45494636            return CValue.UNKNOWN;
    45504637        }
    4551         return new CValueBoolean(v1.intValue() <= v2.intValue());
     4638        return CValueBoolean.valueOf(v1.intValue() <= v2.intValue());
    45524639    }
    45534640
     
    45564643            return CValue.UNKNOWN;
    45574644        }
    4558         return new CValueBoolean(almostLtZero(v1.realValue() - v2.realValue()));
     4645        return CValueBoolean.valueOf(almostLtZero(v1.realValue() - v2.realValue()));
    45594646    }
    45604647
     
    45634650            return CValue.UNKNOWN;
    45644651        }
    4565         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) <= 0);
     4652        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) <= 0);
    45664653    }
    45674654
     
    45794666            return CValue.UNKNOWN;
    45804667        }
    4581         return new CValueBoolean(v1.intValue() < v2.intValue());
     4668        return CValueBoolean.valueOf(v1.intValue() < v2.intValue());
    45824669    }
    45834670
     
    45864673            return CValue.UNKNOWN;
    45874674        }
    4588         return new CValueBoolean(v1.realValue() < v2.realValue());
     4675        return CValueBoolean.valueOf(v1.realValue() < v2.realValue());
    45894676    }
    45904677
     
    45934680            return CValue.UNKNOWN;
    45944681        }
    4595         return new CValueBoolean(v1.stringValue().compareTo(v2.stringValue()) < 0);
     4682        return CValueBoolean.valueOf(v1.stringValue().compareTo(v2.stringValue()) < 0);
    45964683    }
    45974684
    45984685    eq CValueUnknown.lt(CValue v1, CValue v2) = CValue.UNKNOWN;
    45994686
     4687   
     4688    public CValue CValue.absoluteValue() {
     4689        return this;
     4690    }
     4691    @Override
     4692    public CValue CValueReal.absoluteValue() {
     4693        return new CValueReal(Math.abs(realValue()));
     4694    }
     4695    @Override
     4696    public CValue CValueInteger.absoluteValue() {
     4697        return new CValueInteger(Math.abs(intValue()));
     4698    }
     4699   
    46004700}
    46014701
     
    48564956    eq SrcBooleanLitExpTrue.ceval()  = CValueBoolean.TRUE;
    48574957    eq SrcBooleanLitExpFalse.ceval() = CValueBoolean.FALSE;
    4858     eq SrcIntegerLitExp.ceval()      = new CValueInteger(Integer.parseInt(getUNSIGNED_INTEGER()));
    4859     eq SrcRealLitExp.ceval()         = new CValueReal(Double.parseDouble(getUNSIGNED_NUMBER()));
     4958    eq SrcIntegerLitExp.ceval()      = CValueInteger.valueOf(Integer.parseInt(getUNSIGNED_INTEGER()));
     4959    eq SrcRealLitExp.ceval()         = CValueReal.valueOf(Double.parseDouble(getUNSIGNED_NUMBER()));
    48604960    eq SrcArrayConstructor.ceval()   = cevalArray();
    48614961    eq SrcMatrix.ceval()             = cevalArray();
     
    48634963        CValue value = getSrcExp().ceval();
    48644964        if (value.isInteger())
    4865             return new CValueInteger(-value.intValue());
     4965            return CValueInteger.valueOf(-value.intValue());
    48664966        else if (value.isReal())
    4867             return new CValueReal(-value.realValue());
     4967            return CValueReal.valueOf(-value.realValue());
    48684968        else
    48694969            return CValue.UNKNOWN;
     
    49545054    public class VariableEvaluator {
    49555055        public static final VariableEvaluator instance = new VariableEvaluator(true);
    4956         private boolean externalEvaluationEnabled;
     5056        private final boolean externalEvaluationEnabled;
    49575057       
    49585058        public VariableEvaluator(boolean externalEvaluationEnabled) {
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ExternalConstantEvaluation.jrag

    r13639 r13704  
    336336    }
    337337    public CValue FRealType.deserializeScalar(ProcessCommunicator com) throws IOException {
    338         return new CValueReal(com.deserializeReal());
     338        return CValueReal.valueOf(com.deserializeReal());
    339339    }
    340340    public CValue FIntegerType.deserializeScalar(ProcessCommunicator com) throws IOException {
    341         return new CValueInteger((int) com.deserializeReal());
     341        return CValueInteger.valueOf((int) com.deserializeReal());
    342342    }
    343343    public CValue FBooleanType.deserializeScalar(ProcessCommunicator com) throws IOException {
    344         return new CValueBoolean(com.deserializeReal() != 0);
     344        return CValueBoolean.valueOf(com.deserializeReal() != 0);
    345345    }
    346346    public CValue FStringType.deserializeScalar(ProcessCommunicator com) throws IOException {
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r13357 r13704  
    3535import org.jmodelica.common.GUIDManager;
    3636import org.jmodelica.util.streams.StreamGobbler;
     37import org.jmodelica.common.ast.prefixes.CausalityConnectorPrefix.CausalPortsEvaluator;
    3738
    3839aspect FlatAPI {
     
    23672368    inh FClass FFunctionDecl.myFClass();
    23682369    inh FClass FRecordDecl.myFClass();
     2370    inh FClass FDerivedType.myFClass();
     2371    inh FClass FEnumDecl.myFClass();
    23692372    inh FClass FAlgorithm.myFClass();
    23702373    inh FClass FAbstractEquation.myFClass();
     
    31633166   
    31643167    syn boolean FAbstractVariable.isInput() = false;
    3165     eq FVariable.isInput() = getCausalityConnectorPrefix().inputCausality();
    31663168    syn boolean FAbstractVariable.isOutput() = false;
    3167     eq FVariable.isOutput() = getCausalityConnectorPrefix().outputCausality();
    3168      
     3169    eq FVariable.isInput()          = getCausalityConnectorPrefix().inputCausality (this);
     3170    eq FVariable.isOutput()         = getCausalityConnectorPrefix().outputCausality(this);
     3171    eq FFunctionVariable.isInput()  = getCausalityConnectorPrefix().inputCausality (this);
     3172    eq FFunctionVariable.isOutput() = getCausalityConnectorPrefix().outputCausality(this);
     3173   
     3174    ASTNode implements CausalPortsEvaluator;
     3175    syn boolean ASTNode.useCausalPorts() = myOptions().causal_ports.getValue();
    31693176}
    31703177
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPIAttributes.jrag

    r11676 r13704  
    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-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/FlatUtil.jrag

    r13396 r13704  
    707707    }
    708708   
     709   
     710    public abstract FAccess FAccess.copyAndAddSuffix(String suffix);
     711   
     712    public FAccessString FAccessEmpty.copyAndAddSuffix(String suffix) {
     713        throw new UnsupportedOperationException();
     714    }
     715   
     716    public FAccessString FAccessString.copyAndAddSuffix(String suffix) {
     717        String name = getName();
     718        String end = "";
     719        if (name.endsWith("'")) {
     720            name = name.substring(0, name.length() - 1);
     721            end = "'";
     722        }
     723        return new FAccessString(name + suffix + end);
     724    }
     725   
     726    public FAccessFull FAccessFull.copyAndAddSuffix(String suffix) {
     727        FAccessFull res = fullCopy();
     728        String name = res.getFAccessPart(0).getName();
     729        String end = "";
     730        if (name.endsWith("'")) {
     731            name = name.substring(0, name.length() - 1);
     732            end = "'";
     733        }
     734        res.getFAccessPart(0).setName(name + suffix + end);
     735        return res;
     736    }
     737   
    709738    /**
    710739     * Create a copy of the name, with an FSubscript added to the last part.
     
    11121141    syn boolean FFunctionCall.isPartialFunctionCall() = false;
    11131142    eq FPartialFunctionCall.isPartialFunctionCall()   = true;
    1114      
    1115      syn boolean FFunctionVariable.isInput()  = getCausalityConnectorPrefix().inputCausality();
    1116      syn boolean FFunctionVariable.isOutput() = getCausalityConnectorPrefix().outputCausality();
    11171143     
    11181144     /**
     
    16631689     
    16641690
    1665     public String FClass.nextTempFuncName() {
    1666         String name;
    1667         do {
    1668             name = "temp_" + nextTempFuncIndex++;
    1669         } while (lookupFunc(name) != null);
    1670         return name;
    1671     }
    1672     private int FClass.nextTempFuncIndex = 1;
    1673 
    1674 
    16751691    /**
    16761692     * Creates new temporary variables with the given name.
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r13357 r13704  
    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(";");
     
    22032216        getParameterEquations().prettyPrintWithFix(p, str, nextInd, "", ";" + str.getLineEnder());
    22042217    */
    2205         boolean wroteEquation = false;
    2206         for (FAbstractEquation e : getFAbstractEquations()) {
    2207             if (e instanceof FAlgorithm) {
    2208                 p.print(e, str, indent);
    2209                 wroteEquation = false;
    2210             } else {
    2211                 if (!e.isIgnored()) {
    2212                     if (!wroteEquation) {
    2213                         str.println(indent, "equation");
    2214                         wroteEquation = true;
    2215                     }
    2216                     p.print(e, str, nextInd);
    2217                     str.println(";");
    2218                 }
    2219             }
    2220         }
     2218        prettyPrintEquations(p, str, indent);
    22212219               
    22222220        str.println(indent, "end ", nameUnderscore(), ";");
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r13431 r13704  
    211211    inh CommonVariableDecl FExternalStmt.myConstructorOutput();
    212212    eq Root.getChild().myConstructorOutput() = null;
    213     eq FFunctionDecl.getChild().myConstructorOutput()     = myOutputs().get(0);
    214     eq InstFullClassDecl.getChild().myConstructorOutput() = myOutputs().get(0);
     213    eq FFunctionDecl.getChild().myConstructorOutput()      = myOutputs().get(0);
     214    eq InstFullClassDecl.getChild().myConstructorOutput()  = myOutputs().get(0);
     215    eq InstShortClassDecl.getChild().myConstructorOutput() = myOutputs().get(0);
    215216
    216217    public ArrayList<FExp> FExternalStmt.myConstructorArgs() {
  • branches/dev-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/Variability.jrag

    r12811 r13704  
    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-cw-evaluator/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r13357 r13704  
    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-cw-evaluator/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r13431 r13704  
    47224722end StringConvertWithParam2;
    47234723
     4724model StringRealformatSpecifier_f
     4725    constant Real x = 1.23456789;
     4726    constant String s = String(x, format = "1.3f");
     4727
     4728annotation(__JModelica(UnitTesting(tests={
     4729    FlatteningTestCase(
     4730        name="StringRealformatSpecifier_f",
     4731        description="String() operator,  Real, format using f specifier",
     4732        flatModel="
     4733fclass EvaluationTests.StringConvert.StringRealformatSpecifier_f
     4734 constant Real x = 1.23456789;
     4735 constant String s = \"1.235\";
     4736end EvaluationTests.StringConvert.StringRealformatSpecifier_f;
     4737")})));
     4738end StringRealformatSpecifier_f;
     4739
     4740model StringIntegerformatSpecifier_f
     4741    constant Integer x = 1234;
     4742    constant String s = String(x, format = "1.3f");
     4743
     4744annotation(__JModelica(UnitTesting(tests={
     4745    FlatteningTestCase(
     4746        name="StringIntegerformatSpecifier_f",
     4747        description="String() operator,  Integer, format using f specifier",
     4748        flatModel="
     4749fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_f
     4750 constant Integer x = 1234;
     4751 constant String s = \"1234.000\";
     4752end EvaluationTests.StringConvert.StringIntegerformatSpecifier_f;
     4753")})));
     4754end StringIntegerformatSpecifier_f;
     4755
     4756model StringRealformatSpecifier_e
     4757    constant Real x = 1.23456789;
     4758    constant String s = String(x, format = "1.3e");
     4759
     4760annotation(__JModelica(UnitTesting(tests={
     4761    FlatteningTestCase(
     4762        name="StringRealformatSpecifier_e",
     4763        description="String() operator,  Real, format using e specifier",
     4764        flatModel="
     4765fclass EvaluationTests.StringConvert.StringRealformatSpecifier_e
     4766 constant Real x = 1.23456789;
     4767 constant String s = \"1.235e+00\";
     4768end EvaluationTests.StringConvert.StringRealformatSpecifier_e;
     4769")})));
     4770end StringRealformatSpecifier_e;
     4771
     4772model StringIntegerformatSpecifier_e
     4773    constant Integer x = 1234;
     4774    constant String s = String(x, format = "1.3e");
     4775
     4776annotation(__JModelica(UnitTesting(tests={
     4777    FlatteningTestCase(
     4778        name="StringIntegerformatSpecifier_e",
     4779        description="String() operator, Integer, format using e specifier",
     4780        flatModel="
     4781fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_e
     4782 constant Integer x = 1234;
     4783 constant String s = \"1.234e+03\";
     4784end EvaluationTests.StringConvert.StringIntegerformatSpecifier_e;
     4785")})));
     4786end StringIntegerformatSpecifier_e;
     4787
     4788model StringRealformatSpecifier_E
     4789    constant Real x = 1.23456789;
     4790    constant String s = String(x, format = "1.3E");
     4791
     4792annotation(__JModelica(UnitTesting(tests={
     4793    FlatteningTestCase(
     4794        name="StringRealformatSpecifier_E",
     4795        description="String() operator,  Real, format using E specifier",
     4796        flatModel="
     4797fclass EvaluationTests.StringConvert.StringRealformatSpecifier_E
     4798 constant Real x = 1.23456789;
     4799 constant String s = \"1.235E+00\";
     4800end EvaluationTests.StringConvert.StringRealformatSpecifier_E;
     4801")})));
     4802end StringRealformatSpecifier_E;
     4803
     4804model StringIntegerformatSpecifier_E
     4805    constant Integer x = 1234;
     4806    constant String s = String(x, format = "1.3E");
     4807
     4808annotation(__JModelica(UnitTesting(tests={
     4809    FlatteningTestCase(
     4810        name="StringIntegerformatSpecifier_E",
     4811        description="String() operator,  Integer, format using E specifier",
     4812        flatModel="
     4813fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_E
     4814 constant Integer x = 1234;
     4815 constant String s = \"1.234E+03\";
     4816end EvaluationTests.StringConvert.StringIntegerformatSpecifier_E;
     4817")})));
     4818end StringIntegerformatSpecifier_E;
     4819
     4820model StringRealformatSpecifier_g
     4821    constant Real x = 1.23456789;
     4822    constant String s = String(x, format = "1.3g");
     4823
     4824annotation(__JModelica(UnitTesting(tests={
     4825    FlatteningTestCase(
     4826        name="StringRealformatSpecifier_g",
     4827        description="String() operator, Real, format using g specifier",
     4828        flatModel="
     4829fclass EvaluationTests.StringConvert.StringRealformatSpecifier_g
     4830 constant Real x = 1.23456789;
     4831 constant String s = \"1.23\";
     4832end EvaluationTests.StringConvert.StringRealformatSpecifier_g;
     4833")})));
     4834end StringRealformatSpecifier_g;
     4835
     4836model StringIntegerformatSpecifier_g
     4837    constant Integer x = 1234;
     4838    constant String s = String(x, format = "1.3g");
     4839
     4840annotation(__JModelica(UnitTesting(tests={
     4841    FlatteningTestCase(
     4842        name="StringIntegerformatSpecifier_g",
     4843        description="String() operator,  Integer, format using g specifier",
     4844        flatModel="
     4845fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_g
     4846 constant Integer x = 1234;
     4847 constant String s = \"1.23e+03\";
     4848end EvaluationTests.StringConvert.StringIntegerformatSpecifier_g;
     4849")})));
     4850end StringIntegerformatSpecifier_g;
     4851
     4852model StringRealformatSpecifier_G
     4853    constant Real x = 1.23456789;
     4854    constant String s = String(x, format = "1.3G");
     4855
     4856annotation(__JModelica(UnitTesting(tests={
     4857    FlatteningTestCase(
     4858        name="StringRealformatSpecifier_G",
     4859        description="String() operator, Real, format using G specifier",
     4860        flatModel="
     4861fclass EvaluationTests.StringConvert.StringRealformatSpecifier_G
     4862 constant Real x = 1.23456789;
     4863 constant String s = \"1.23\";
     4864end EvaluationTests.StringConvert.StringRealformatSpecifier_G;
     4865")})));
     4866end StringRealformatSpecifier_G;
     4867
     4868model StringIntegerformatSpecifier_G
     4869    constant Integer x = 1234;
     4870    constant String s = String(x, format = "1.3G");
     4871
     4872annotation(__JModelica(UnitTesting(tests={
     4873    FlatteningTestCase(
     4874        name="StringIntegerformatSpecifier_G",
     4875        description="String() operator,  Integer, format using G specifier",
     4876        flatModel="
     4877fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_G
     4878 constant Integer x = 1234;
     4879 constant String s = \"1.23E+03\";
     4880end EvaluationTests.StringConvert.StringIntegerformatSpecifier_G;
     4881")})));
     4882end StringIntegerformatSpecifier_G;
     4883
     4884model StringRealformatSpecifier_d
     4885    constant Real x = 1.23456789;
     4886    constant String s = String(x, format = "3d");
     4887
     4888annotation(__JModelica(UnitTesting(tests={
     4889      ErrorTestCase(
     4890            name="StringRealformatSpecifier_d",
     4891            description="String() operator, Real, format using d specifier",
     4892            errorMessage="
     4893Error at line 3, column 25, in file '...':
     4894  Could not evaluate binding expression for constant 's': 'String(x, \"3d\")'
     4895    Cannot format the resulting value. The format '%3d' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     4896")})));
     4897end StringRealformatSpecifier_d;
     4898
     4899model StringIntegerformatSpecifier_d
     4900    constant Integer x = 1234;
     4901    constant String s = String(x, format = "3d");
     4902
     4903annotation(__JModelica(UnitTesting(tests={
     4904    FlatteningTestCase(
     4905        name="StringIntegerformatSpecifier_d",
     4906        description="String() operator,  Integer, format using d specifier",
     4907        flatModel="
     4908fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_d
     4909 constant Integer x = 1234;
     4910 constant String s = \"1234\";
     4911end EvaluationTests.StringConvert.StringIntegerformatSpecifier_d;
     4912")})));
     4913end StringIntegerformatSpecifier_d;
     4914
     4915model StringRealformatSpecifier_i
     4916    constant Real x = 1.23456789;
     4917    constant String s = String(x, format = "3i");
     4918
     4919annotation(__JModelica(UnitTesting(tests={
     4920    ErrorTestCase(
     4921        name="StringRealformatSpecifier_i",
     4922        description="String() operator, Real, format using i specifier",
     4923        errorMessage="
     4924Error at line 3, column 25, in file '...':
     4925  Could not evaluate binding expression for constant 's': 'String(x, \"3i\")'
     4926    Cannot format the resulting value. The format '%3i' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     4927")})));
     4928end StringRealformatSpecifier_i;
     4929
     4930model StringIntegerformatSpecifier_i
     4931    constant Integer x = 1234;
     4932    constant String s = String(x, format = "3i");
     4933
     4934annotation(__JModelica(UnitTesting(tests={
     4935    FlatteningTestCase(
     4936        name="StringIntegerformatSpecifier_i",
     4937        description="String() operator,  Integer, format using i specifier",
     4938        flatModel="
     4939fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_i
     4940 constant Integer x = 1234;
     4941 constant String s = \"1234\";
     4942end EvaluationTests.StringConvert.StringIntegerformatSpecifier_i;
     4943")})));
     4944end StringIntegerformatSpecifier_i;
     4945
     4946model StringRealformatSpecifier_o
     4947    constant Real x = 1.23456789;
     4948    constant String s = String(x, format = "3o");
     4949
     4950annotation(__JModelica(UnitTesting(tests={
     4951    ErrorTestCase(
     4952        name="StringRealformatSpecifier_o",
     4953        description="String() operator, Real, format using o specifier",
     4954        errorMessage="
     4955Error at line 3, column 25, in file '...':
     4956  Could not evaluate binding expression for constant 's': 'String(x, \"3o\")'
     4957    Cannot format the resulting value. The format '%3o' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     4958")})));
     4959end StringRealformatSpecifier_o;
     4960
     4961model StringIntegerformatSpecifier_o
     4962    constant Integer x = 1234;
     4963    constant String s = String(x, format = "3o");
     4964
     4965annotation(__JModelica(UnitTesting(tests={
     4966    FlatteningTestCase(
     4967        name="StringIntegerformatSpecifier_o",
     4968        description="String() operator,  Integer, format using o specifier",
     4969        flatModel="
     4970fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_o
     4971 constant Integer x = 1234;
     4972 constant String s = \"2322\";
     4973end EvaluationTests.StringConvert.StringIntegerformatSpecifier_o;
     4974")})));
     4975end StringIntegerformatSpecifier_o;
     4976
     4977model StringRealformatSpecifier_x
     4978    constant Real x = 1.23456789;
     4979    constant String s = String(x, format = "3x");
     4980
     4981annotation(__JModelica(UnitTesting(tests={
     4982    ErrorTestCase(
     4983        name="StringRealformatSpecifier_x",
     4984        description="String() operator, Real, format using x specifier",
     4985        errorMessage="
     4986Error at line 3, column 25, in file '...':
     4987  Could not evaluate binding expression for constant 's': 'String(x, \"3x\")'
     4988    Cannot format the resulting value. The format '%3x' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     4989")})));
     4990end StringRealformatSpecifier_x;
     4991
     4992model StringIntegerformatSpecifier_x
     4993    constant Integer x = 1234;
     4994    constant String s = String(x, format = "3x");
     4995
     4996annotation(__JModelica(UnitTesting(tests={
     4997    FlatteningTestCase(
     4998        name="StringIntegerformatSpecifier_x",
     4999        description="String() operator,  Integer, format using x specifier",
     5000        flatModel="
     5001fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_x
     5002 constant Integer x = 1234;
     5003 constant String s = \"4d2\";
     5004end EvaluationTests.StringConvert.StringIntegerformatSpecifier_x;
     5005")})));
     5006end StringIntegerformatSpecifier_x;
     5007
     5008model StringRealformatSpecifier_X
     5009    constant Real x = 1.23456789;
     5010    constant String s = String(x, format = "3X");
     5011
     5012annotation(__JModelica(UnitTesting(tests={
     5013    ErrorTestCase(
     5014        name="StringRealformatSpecifier_X",
     5015        description="String() operator, Real, format using X specifier",
     5016        errorMessage="
     5017Error at line 3, column 25, in file '...':
     5018  Could not evaluate binding expression for constant 's': 'String(x, \"3X\")'
     5019    Cannot format the resulting value. The format '%3X' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     5020")})));
     5021end StringRealformatSpecifier_X;
     5022
     5023model StringIntegerformatSpecifier_X
     5024    constant Integer x = 1234;
     5025    constant String s = String(x, format = "3X");
     5026
     5027annotation(__JModelica(UnitTesting(tests={
     5028    FlatteningTestCase(
     5029        name="StringIntegerformatSpecifier_X",
     5030        description="String() operator,  Integer, format using X specifier",
     5031        flatModel="
     5032fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_X
     5033 constant Integer x = 1234;
     5034 constant String s = \"4D2\";
     5035end EvaluationTests.StringConvert.StringIntegerformatSpecifier_X;
     5036")})));
     5037end StringIntegerformatSpecifier_X;
     5038
     5039model StringRealformatSpecifier_u
     5040    constant Real x = 1.23456789;
     5041    constant String s = String(x, format = "3u");
     5042
     5043annotation(__JModelica(UnitTesting(tests={
     5044    ErrorTestCase(
     5045        name="StringRealformatSpecifier_u",
     5046        description="String() operator, Real, format using u specifier",
     5047        errorMessage="
     5048Error at line 3, column 25, in file '...':
     5049  Could not evaluate binding expression for constant 's': 'String(x, \"3u\")'
     5050    Cannot format the resulting value. The format '%3u' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     5051")})));
     5052end StringRealformatSpecifier_u;
     5053
     5054model StringIntegerformatSpecifier_u
     5055    constant Integer x = -1234;
     5056    constant String s = String(x, format = "3u");
     5057
     5058annotation(__JModelica(UnitTesting(tests={
     5059    FlatteningTestCase(
     5060        name="StringIntegerformatSpecifier_u",
     5061        description="String() operator,  Integer, format using u specifier",
     5062        flatModel="
     5063fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_u
     5064 constant Integer x = -1234;
     5065 constant String s = \"4294966062\";
     5066end EvaluationTests.StringConvert.StringIntegerformatSpecifier_u;
     5067")})));
     5068end StringIntegerformatSpecifier_u;
     5069
     5070model StringRealformatSpecifier_c
     5071    constant Real x = 1.23456789;
     5072    constant String s = String(x, format = "3c");
     5073
     5074annotation(__JModelica(UnitTesting(tests={
     5075    ErrorTestCase(
     5076        name="StringRealformatSpecifier_c",
     5077        description="String() operator, Real, format using c specifier",
     5078        errorMessage="
     5079Error at line 3, column 25, in file '...':
     5080  Could not evaluate binding expression for constant 's': 'String(x, \"3c\")'
     5081    Cannot format the resulting value. The format '%3c' requires value of Integer type but Real value is provided. CValueReal (1.23456789)
     5082")})));
     5083
     5084end StringRealformatSpecifier_c;
     5085
     5086model StringIntegerformatSpecifier_c
     5087    constant Integer x = 123;
     5088    constant String s = String(x, format = "3c");
     5089
     5090annotation(__JModelica(UnitTesting(tests={
     5091    FlatteningTestCase(
     5092        name="StringIntegerformatSpecifier_c",
     5093        description="String() operator,  Integer, format using c specifier",
     5094        flatModel="
     5095fclass EvaluationTests.StringConvert.StringIntegerformatSpecifier_c
     5096 constant Integer x = 123;
     5097 constant String s = \"  {\";
     5098end EvaluationTests.StringConvert.StringIntegerformatSpecifier_c;
     5099")})));
     5100end StringIntegerformatSpecifier_c;
     5101
     5102model StringIncorrectformat
     5103    constant Integer x = 1234;
     5104    constant String s = String(x, format = "*.1.3c");
     5105
     5106annotation(__JModelica(UnitTesting(tests={
     5107    ErrorTestCase(
     5108        name="StringIncorrectformat",
     5109        description="String() operator, Real, format using c specifier",
     5110        errorMessage="
     5111Error at line 3, column 25, in file '...':
     5112  Could not evaluate binding expression for constant 's': 'String(x, \"*.1.3c\")'
     5113    Cannot format the resulting value. %*.1.3c is not a supported valid format stringCValueInteger (1234)
     5114")})));
     5115end StringIncorrectformat;
     5116
    47245117end StringConvert;
    47255118
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/flattening/Flattening.jrag

    r13396 r13704  
    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);
     781        contribute(stmt);
    781782        if (hasInstExternalCall()) {
    782783            InstExternalCall call = getInstExternalCall();
     
    829830                new Opt<CommonAccessExp>();
    830831               
    831         FExternalStmt stmt = new FExternalStmt(getFExternalLanguage().treeCopy(), ret, getName(), args, getLibTopPackagePath());
     832        FExternalStmt stmt = new FExternalStmt(getFExternalLanguage().treeCopy(), ret, getName(), args, getLibTopPackagePath(), new List<FAttribute>());
    832833        stmt.extractLibrary(this);
    833834        sl.add(stmt);
     835        contribute(stmt);
    834836        return false;
    835837    }
     
    12381240                f.addFVariable(fv);
    12391241            }
     1242            if (fv.getCausalityConnectorPrefix().isStream() && useCausalPorts()) {
     1243                FVariable inStream = fv.treeCopy();
     1244                FAccess inStreamAccess = createInStreamAccess(inStream.getFAccess());
     1245                inStream.setFAccess(inStreamAccess);
     1246                inStream.setCausalityConnectorPrefix(CausalityConnectorPrefix.INSTREAM);
     1247                fv.annotation().vendorNode().forPath("internal/instream").setValue(new FStringLitExp(inStreamAccess.name()));
     1248                f.addFVariable(inStream);
     1249            }
    12401250            flattenMyType(f);
    12411251            clearModificationLevel(oldLevels);
    12421252        }
     1253    }
     1254   
     1255    inh FAccess InstAssignable.createInStreamAccess(FAccess streamAccess);
     1256    eq InstClassDecl.getChild().createInStreamAccess(FAccess streamAccess) {
     1257        FAccess result = streamAccess.copyAndAddSuffix("__instream_");
     1258        int i = 2;
     1259        while (componentExists(new QualifiedName(result.name()))) {
     1260            result = streamAccess.copyAndAddSuffix("__instream_" + i);
     1261            i++;
     1262        }
     1263        return result;
    12431264    }
    12441265   
     
    21372158            List<FAttribute> attrs, AttributeExpRetriever aer, boolean cls) {}
    21382159
    2139     syn boolean InstComponentDecl.isBuiltIn() = false;
    2140     eq InstBuiltIn.isBuiltIn()                = true;
    2141 
     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   
    21422174    public void InstComponentModification.collectAttributes(Flattener f,
    21432175            List<FAttribute> attrs, AttributeExpRetriever aer, boolean cls) {
     
    24272459        int i = 0;
    24282460        for (CommonForIndex fi : forIndices) {
    2429             fi.setEvaluationValue(new CValueInteger(index[i++]));
     2461            fi.setEvaluationValue(CValueInteger.valueOf(index[i++]));
    24302462        }
    24312463    }
     
    33673399    /**
    33683400     * Class used during instantiation of equations and flattening of variables
    3369      * to delecate to different contributors. This class is subtyped for each
    3370      * contributor!
     3401     * to delegate to different contributors. This class is subtyped for each
     3402     * contributor.
    33713403     */
    33723404    public abstract class AttributeContributor {
     
    34033435
    34043436        /**
     3437         * This method is called during flattening of external statements. All
     3438         * expressions that are added must be flattened.
     3439         */
     3440        protected void contribute(AnnotationNode src, FExternalStmt dest) {}
     3441
     3442        /**
    34053443         * This method is called in order to determine if an attribute should
    34063444         * be considered as active. Return true if the attributes that was
     
    34933531    }
    34943532   
     3533    public class InstExternal {
     3534        public FExternalStmt contribute(FExternalStmt stmt) {
     3535            for (AttributeContributor contributor : attributeContributors()) {
     3536                contributor.contribute(annotation(), stmt);
     3537            }
     3538            return stmt;
     3539        }
     3540    }
     3541   
     3542    public class FExternalStmt {
     3543        public FExternalStmt contribute(FExternalStmt stmt) {
     3544            for (AttributeContributor contributor : attributeContributors()) {
     3545                contributor.contribute(annotation(), stmt);
     3546            }
     3547            return stmt;
     3548        }
     3549    }
     3550   
    34953551}
    34963552
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/flattening/FlatteningStatements.jrag

    r12184 r13704  
    245245    eq Root.getChild().breakCondName() = null;
    246246
    247     public boolean InstClassDecl.componentExists(String name) {
     247    public boolean InstNode.componentExists(String name) {
    248248        for (InstComponentDecl decl : allInstComponentDecls()) {
    249249            if (decl.name().equals(name)) {
    250250                return true;
    251251            }
     252        }
     253        return false;
     254    }
     255   
     256    public boolean InstNode.componentExists(Iterator<String> qualifiedName) {
     257        if (!qualifiedName.hasNext()) {
     258            return true;
     259        }
     260        String name = qualifiedName.next();
     261        if (componentExists(name)) {
     262            return memberInstComponent(name).targetOrNull().componentExists(qualifiedName);
    252263        }
    253264        return false;
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/flattening/connections/Connections.jrag

    r13357 r13704  
    8282    protected FExp FInStream.expandInStreamExp() {
    8383        // Always create expression from the connection set where the variable is an inside connector.
    84         String name = getFExp().asCommonAccess().name();
    85         ConnectionSet cs = myFClass().getConnectionSetManager().getStreamConnectionSet(name, false);
     84        FAccess name = getFExp().asCommonAccess().asFAccess();
     85        ConnectionSet cs = myFClass().getConnectionSetManager().getStreamConnectionSet(name.name(), false);
    8686        return cs.expandInStreamExp(name);
    8787    }
     
    470470         * @param name  the name of the variable to generate name for
    471471         */
    472         public FExp expandInStreamExp(String name) {
     472        public FExp expandInStreamExp(FAccess name) {
    473473            throw new UnsupportedOperationException();
    474474        }
     
    537537        public void generateEquations(Flattener f) {
    538538            ConnectionSetEntry fst = first();
    539             if (size() == 1 && fst.isInside() && fst.getVar().isTopLevelCausalOrConnector()) {
     539            InstComponentDecl fstVar = fst.getVar();
     540            if (size() == 1 && fst.isInside() && fstVar.isTopLevelCausalOrConnector()
     541                    && (fstVar.isInput() || fstVar.isOutput() || fstVar.useCausalPorts())) {
    540542                return;
    541543            }
     
    550552
    551553    public class StreamConnectionSet extends ConnectionSet {
     554       
     555        private static final String inStreamSuffix = "__instream_";
    552556
    553557        private double nominal = Double.MAX_VALUE;
     
    579583         * @param name  the name of the variable to generate name for
    580584         */
    581         public FExp expandInStreamExp(String name) {
     585        @Override
     586        public FExp expandInStreamExp(FAccess access) {
     587            String name = access.name();
    582588            ConnectionSetEntry e = getConnectionSetEntry(name, false);
    583             FExp exp = expandInStreamExp(e, name, new FAccessExp(name));
     589            if (access.useCausalPorts()) {
     590                AnnotationNode instreamAnnotation = access.myFV().annotation().vendorNode().forPath("internal/instream");
     591                if (instreamAnnotation.exists()) {
     592                    String instreamName = instreamAnnotation.ceval().stringValue();
     593                    access = nameWithSubscripts(instreamName, name);
     594                }
     595            }
     596            FExp exp = expandInStreamExp(e, name, new FAccessExp(access));
    584597            exp.enableStreamsRewrite();
    585598            return exp;
    586599        }
     600       
     601        public FAccess nameWithSubscripts(String name, String access) {
     602            String subscripts = (access.endsWith("]")) ? access.substring(access.lastIndexOf("[")) : "";
     603            return new FAccessString(name + subscripts);
     604       }
    587605
    588606        /**
     
    13741392            int[] ii = indices.translate(i).index();
    13751393            for (InstForIndex fi : getInstForIndexs()) {
    1376                 fi.getInstPrimitive().setLocalCachedEvaluationValue(new CValueInteger(ii[j]));
     1394                fi.getInstPrimitive().setLocalCachedEvaluationValue(CValueInteger.valueOf(ii[j]));
    13771395                j++;
    13781396            }
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/flattening/connections/ExpandableConnectors.jrag

    r13224 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupClasses.jrag

    r13317 r13704  
    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()) {
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupComponents.jrag

    r13317 r13704  
    2323    interface InstCallable  extends    InstLookupResult.Item {}
    2424
     25        /**
     26         * Indicates that the target was not found.
     27         */
     28        public static <T extends Item> InstLookupResult<T> InstLookupResult.notFound() {
     29            return NOT_FOUND;
     30        }
     31
     32        /**
     33         * Indicates that the target was found.
     34         *
     35         * Includes the found class or component.
     36         */
     37        public static <T extends Item> InstLookupResult<T> InstLookupResult.found(T target) {
     38            return new Found(target);
     39        }
     40
     41        /**
     42         * Indicates that the target was found, but not accessible due to a constrainedby clause.
     43         *
     44         * Includes the declaration with the limiting constrainedby clause.
     45         */
     46        public static <T extends Item> InstLookupResult<T> InstLookupResult.constrained(T target, InstNode constr) {
     47            return new Constrained(target, constr);
     48        }
     49
     50        /**
     51         * Indicates that the target was found, but not accessible due to a constrainedby clause.
     52         *
     53         * Includes the declaration with the limiting constrainedby clause.
     54         */
     55        public static <T extends Item> InstLookupResult<T> InstLookupResult.constrained(InstLookupResult<T> res, InstNode constr) {
     56            return new Constrained(res.target(), constr);
     57        }
     58       
     59        /**
     60         * Indicates that the target was found as an outer, target() returns the corresponding inner.
     61         */
     62        public static InstLookupResult<InstComponentDecl> InstLookupResult.outer(InstComponentDecl outer) {
     63            return new Outer(outer);
     64        }
     65
     66
    2567    /**
    2668     * Result class for lookups in the instance tree.
     
    3375            public InstLookupResult<InstComponentDecl> memberInstComponent(String name);
    3476            public InstCallable asCallable();
    35         }
    36        
    37         /**
    38          * Indicates that the target was not found.
    39          */
    40         public static <T extends Item> InstLookupResult<T> notFound() {
    41             return (InstLookupResult<T>) NOT_FOUND;
    42         }
    43 
    44         /**
    45          * Indicates that the target was found.
    46          *
    47          * Includes the found class or component.
    48          */
    49         public static <T extends Item> InstLookupResult<T> found(T target) {
    50             return new Found(target);
    51         }
    52 
    53         /**
    54          * Indicates that the target was found, but not accessible due to a constrainedby clause.
    55          *
    56          * Includes the declaration with the limiting constrainedby clause.
    57          */
    58         public static <T extends Item> InstLookupResult<T> constrained(T target, InstNode constr) {
    59             return new Constrained(target, constr);
    60         }
    61 
    62         /**
    63          * Indicates that the target was found, but not accessible due to a constrainedby clause.
    64          *
    65          * Includes the declaration with the limiting constrainedby clause.
    66          */
    67         public static <T extends Item> InstLookupResult<T> constrained(InstLookupResult<T> res, InstNode constr) {
    68             return new Constrained(res.target(), constr);
    69         }
    70        
    71         /**
    72          * Indicates that the target was found as an outer, target() returns the corresponding inner.
    73          */
    74         public static InstLookupResult<InstComponentDecl> outer(InstComponentDecl outer) {
    75             return new Outer(outer);
    76         }
    77 
     77            public InstNode asInstNode();
     78        }
     79       
    7880        /**
    7981         * Did the lookup succeed?
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstanceTree.jrag

    r13396 r13704  
    17681768        hasInstClassModification() ||
    17691769        getSrcClassDecl().hasSrcTypePrefix() ||
    1770         !filteredEnvironment().isEmpty();
     1770        !filteredEnvironment().isEmpty() ||
     1771        inExternalObject();
    17711772    eq InstReplacingShortClassDecl.shouldBeExpanded() =
    17721773        super.shouldBeExpanded() ||
     
    18061807    }
    18071808    public List<InstComponentDecl> InstLibNode.getInstComponentDeclList() {
    1808         throw new UnsupportedOperationException();
     1809        return resolveLib().getInstComponentDeclList();
    18091810    }
    18101811
     
    18131814    }
    18141815    public List<InstClassDecl> InstLibNode.getInstClassDeclList() {
    1815         throw new UnsupportedOperationException();
     1816        return resolveLib().getInstClassDeclList();
    18161817    }
    18171818
     
    18201821    }
    18211822    public List<InstExtends> InstLibNode.getInstExtendsList() {
    1822         throw new UnsupportedOperationException();
     1823        return resolveLib().getInstExtendsList();
    18231824    }
    18241825
     
    18271828    }
    18281829    public List<InstImport> InstLibNode.getInstImportList() {
    1829         throw new UnsupportedOperationException();
     1830        return resolveLib().getInstImportList();
    18301831    }
    18311832
     
    18341835    }
    18351836    public List<InstClassDecl> InstLibNode.getRedeclaredInstClassDeclList() {
    1836         throw new UnsupportedOperationException();
     1837        return actualInstClass().getRedeclaredInstClassDeclList();
    18371838    }
    18381839
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/instance/Types.jrag

    r12962 r13704  
    6666    eq InstPrimitive.isPrimitiveType()     = true;
    6767    eq InstClassDecl.isPrimitiveType()     = isPrimitive();
     68   
     69    syn boolean SrcBaseNode.isPrimitiveType() = false;
     70    eq SrcClassDecl.isPrimitiveType()         = isPrimitive();
    6871
    6972    public static String InstNode.subTypeMessage(String name, String message) {
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/source/Library.jrag

    r13354 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/source/PredefinedTypes.jrag

    r12975 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/source/SimpleLookup.jrag

    r13396 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/source/SourceTraversal.jrag

    r13294 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/util/Annotations.jrag

    r13294 r13704  
    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-cw-evaluator/Compiler/ModelicaFrontEnd/src/jastadd/util/Util.jrag

    r13396 r13704  
    16201620    }
    16211621   
     1622    syn InstClassDecl InstNode.asInstClassDecl() {
     1623        throw new UnsupportedOperationException();
     1624    }
    16221625    syn InstClassDecl InstClassDecl.asInstClassDecl() = this;
    16231626    syn InstClassDecl InstPartialFunction.asInstClassDecl()  = unknownInstClassDecl();
     
    16291632    syn InstClassDecl InstPartialFunction.actualInstClassDecl() = myInstClass().actualInstClass();
    16301633   
    1631     syn InstNode InstClassDecl.asInstNode() = this;
    1632     syn InstNode InstPartialFunction.asInstNode()  = this;
     1634    syn InstNode InstNode.asInstNode() = this;
    16331635   
    16341636    syn InstCallable InstFunctionCall.myInstCallable() = getName().myInstCallable();
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/ast/prefixes/CausalityConnectorPrefix.java

    r13357 r13704  
    2222    }
    2323   
    24     public boolean inputCausality() {
    25         return this == INPUT || this == FLOW || this == INSTREAM;
     24    public boolean isStream() {
     25        return this == STREAM;
    2626    }
    2727   
    28     public boolean outputCausality() {
    29         return this == OUTPUT || this == POTENTIAL || this == STREAM;
     28    public interface CausalPortsEvaluator {
     29        boolean useCausalPorts();
     30    }
     31   
     32    /**
     33     * We use a {@link CausalPortsEvaluator} here instead of an evaluated boolean
     34     * to reduce the number of calls to useCausalPorts().
     35     * Replace with a Predicate when updating to Java 8.
     36     */
     37    public boolean inputCausality(CausalPortsEvaluator evaluator) {
     38        if (this == INPUT) {
     39            return true;
     40        }
     41        if (this == FLOW || this == INSTREAM) {
     42            return evaluator.useCausalPorts();
     43        }
     44        return false;
     45    }
     46   
     47    public boolean outputCausality(CausalPortsEvaluator evaluator) {
     48        if (this == OUTPUT) {
     49            return true;
     50        }
     51        if (this == POTENTIAL || this == STREAM) {
     52            return evaluator.useCausalPorts();
     53        }
     54        return false;
    3055    }
    3156   
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/junit/TestTreeRunner.java

    r12940 r13704  
    100100            }
    101101            if (!(test instanceof TestTree)) {
    102                 String maybeSubTestName = test.getName();
     102                String uniqueName = nc.makeUnique(testName);
     103                test.setName(uniqueName);
    103104                // TODO: Upgrade JUnit version, then use createTestDescription(String, String) instead
    104                 String descStr = String.format("%s(%s)", nc.makeUnique(testName), packageName);
     105                String descStr = String.format("%s(%s)", uniqueName, packageName);
    105106                chDesc = Description.createSuiteDescription(descStr);
    106                 caseDesc.put(maybeSubTestName, chDesc);
     107                caseDesc.put(uniqueName, chDesc);
    107108                if(outputFailing) {
    108109                    if(name.equals(testFile.getName())) { //Top-level test
    109                         modelNames.put(maybeSubTestName, testName);
     110                        modelNames.put(uniqueName, testName);
    110111                    } else {
    111                         modelNames.put(maybeSubTestName, String.format("%s.%s", name, testName));
     112                        modelNames.put(uniqueName, String.format("%s.%s", name, testName));
    112113                    }
    113114                }
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/AbstractModelicaScanner.java

    r11221 r13704  
    3535
    3636    public int[] getLineBreakMap() {
    37         if (lineBreakMap.length > maxLineBreakLine + 1)
    38             lineBreakMap = Arrays.copyOf(lineBreakMap, maxLineBreakLine + 1);
     37        if (lineBreakMap.length > maxLineBreakLine + 1) {
     38            lineBreakMap = Arrays.copyOf(lineBreakMap, maxLineBreakLine + 1);
     39        }
    3940        return lineBreakMap;
    4041    }
     
    6869            switch (text.charAt(i)) {
    6970            case '\r':
    70                 if (i < text.length() - 1 && text.charAt(i + 1) == '\n')
    71                     ++i;
    72             case '\n':
     71                if (i < text.length() - 1 && text.charAt(i + 1) == '\n') {
     72                    ++i;
     73                }
     74                //$FALL-THROUGH$
     75            case '\n':
    7376                addLineBreak(++line, matchOffset() + i + 1);
    7477                ++numberOfLineBreaksAdded;
     
    7982
    8083    private void addLineBreak(int line, int offset) {
    81         if (lineBreakMap.length <= line)
    82             lineBreakMap = Arrays.copyOf(lineBreakMap, 4 * lineBreakMap.length);
     84        if (lineBreakMap.length <= line) {
     85            lineBreakMap = Arrays.copyOf(lineBreakMap, 4 * lineBreakMap.length);
     86        }
    8387        lineBreakMap[line] = offset;
    84         if (line > maxLineBreakLine)
    85             maxLineBreakLine = line;
     88        if (line > maxLineBreakLine) {
     89            maxLineBreakLine = line;
     90        }
    8691    }
    8792
     
    157162    protected void addFormattingInformation(FormattingType type, String data, int numberOfLineBreaks) {
    158163        int endColumn;
    159         if (numberOfLineBreaks > 0)
    160             endColumn = data.length() - Math.max(data.lastIndexOf('\n'), data.lastIndexOf('\r')) - 1;
    161         else
    162             endColumn = matchColumn() + matchLength();
     164        if (numberOfLineBreaks > 0) {
     165            endColumn = data.length() - Math.max(data.lastIndexOf('\n'), data.lastIndexOf('\r')) - 1;
     166        } else {
     167            endColumn = matchColumn() + matchLength();
     168        }
    163169        formattingRecorder.addItem(type, data, matchLine() + 1, matchColumn() + 1, matchLine() + numberOfLineBreaks + 1, endColumn);
    164170    }
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/TestAnnotationizer.java

    r13431 r13704  
    159159        @SuppressWarnings("resource")
    160160        BufferedReader in = cont ? new BufferedReader(new InputStreamReader(System.in)) : null;
    161         String packageName = getPackageName(filePath);
    162161        while (cont) {
    163162            if (hasInputFilePath) {
     
    165164                String[] parts = line.split(",");
    166165                filePath = parts[0];
    167                 packageName = getPackageName(filePath);
    168                 modelName = packageName + "." + parts[1];
     166                modelName = getPackageName(filePath) + "." + parts[1];
    169167            } else if (all_models) {
    170168                modelName = allModelsIterator.next();
     
    177175                    System.exit(0);
    178176                }
    179                 modelName = composeModelName(packageName, given);
     177                modelName = composeModelName(getPackageName(filePath), given);
    180178            }
    181179           
    182             if (inputlang == Lang.none)
     180            if (inputlang == Lang.none) {
    183181                lang = filePath.contains("Optimica") ? Lang.optimica : Lang.modelica;
    184             else {
     182            } else {
    185183                lang = inputlang;
    186184            }
     
    295293
    296294    private static String composeModelName(String extracted, String entered) {
    297         if (entered == null)
    298             return extracted;
    299         else if (entered.contains("."))
    300             return entered;
    301         else
    302             return extracted + "." + entered;
     295        if (entered == null) {
     296            return extracted;
     297        } else if (entered.contains(".")) {
     298            return entered;
     299        } else {
     300            return extracted + "." + entered;
     301        }
    303302    }
    304303
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/collections/ListUtil.java

    r13396 r13704  
    101101     */
    102102    @SafeVarargs
    103     public static <T> ArrayList<T> concatenate(List<T>... lists) {
     103    public static <T> ArrayList<T> concatenate(List<? extends T>... lists) {
    104104        return buildList(lists);
    105105    }
     
    112112     */
    113113    @SafeVarargs
    114     public static <T> ArrayList<T> buildList(Collection<T>... collections) {
     114    public static <T> ArrayList<T> buildList(Collection<? extends T>... collections) {
    115115        int size = 0;
    116         for (Collection<T> list : collections) {
     116        for (Collection<? extends T> list : collections) {
    117117            size += list.size();
    118118        }
    119119        ArrayList<T> res = new ArrayList<T>(size);
    120         for (Collection<T> list : collections) {
     120        for (Collection<? extends T> list : collections) {
    121121            res.addAll(list);
    122122        }
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/test/GenericTestTreeNode.java

    r7909 r13704  
    2020    public String getName();
    2121
     22    public void setName(String name);
     23
    2224}
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/test/TestTree.java

    r12940 r13704  
    4141
    4242    public TestTree exit() {
    43         if (children.isEmpty() && parent != null)
     43        if (children.isEmpty() && parent != null) {
    4444            parent.children.remove(parentIndex);
     45        }
    4546        return parent;
    4647    }
     
    5455        return name;
    5556    }
     57   
     58    @Override
     59    public void setName(String name) {
     60        this.name = name;
     61    }
    5662
    5763    public int numChildren() {
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/QualifiedNameTest.java

    r12700 r13704  
    22
    33import static org.junit.Assert.assertEquals;
     4import static org.junit.Assert.assertFalse;
    45import static org.junit.Assert.assertTrue;
    5 import static org.junit.Assert.assertFalse;
    66
    77import org.jmodelica.util.QualifiedName;
     
    7979    @Test(expected=NameFormatException.class)
    8080    public void missplacedQuote() {
    81         new QualifiedName("first.secon'd.third'");
     81        new QualifiedName("first.secon'd.third'").toString();
    8282    }
    8383
    8484    @Test(expected=NameFormatException.class)
    8585    public void unmatchedQuotes() {
    86         new QualifiedName("first.'unclosedPart");
     86        new QualifiedName("first.'unclosedPart").toString();
    8787    }
    8888
    8989    @Test(expected=NameFormatException.class)
    9090    public void emptyNames() {
    91         new QualifiedName("first...last");
     91        new QualifiedName("first...last").toString();
    9292    }
    9393
    9494    @Test(expected=NameFormatException.class)
    9595    public void emptyNamesQuoted()  {
    96         new QualifiedName("first...'last'");
     96        new QualifiedName("first...'last'").toString();
    9797    }
    9898
    9999    @Test(expected=NameFormatException.class)
    100100    public void noName()  {
    101         new QualifiedName("");
     101        new QualifiedName("").toString();
    102102    }
    103103}
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/ConnectTests.mo

    r13103 r13704  
    316316 a1[2].x = a2[2].x;
    317317 - a1[2].y - a2[2].y = 0.0;
     318 a1[1].y = 0.0;
     319 a1[2].y = 0.0;
     320 a2[1].y = 0.0;
     321 a2[2].y = 0.0;
    318322end ConnectTests.ConnectTest7;
    319323")})));
     
    352356 a[3].x = a[4].x;
    353357 - a[1].y - a[2].y - a[3].y - a[4].y = 0.0;
     358 a[1].y = 0.0;
     359 a[2].y = 0.0;
     360 a[3].y = 0.0;
     361 a[4].y = 0.0;
    354362end ConnectTests.ConnectTest8;
    355363")})));
     
    380388 a[1].x = a[2].x;
    381389 - a[1].y - a[2].y = 0.0;
     390 a[1].y = 0.0;
     391 a[2].y = 0.0;
    382392end ConnectTests.ConnectTest9;
    383393")})));
     
    454464 c1.b2.x = c2.b2.x;
    455465 - c1.b2.y - c2.b2.y = 0.0;
     466 c1.b1.y = 0.0;
     467 c1.b2.y = 0.0;
     468 c2.b1.y = 0.0;
     469 c2.b2.y = 0.0;
    456470end ConnectTests.ConnectTest11;
    457471")})));
     
    549563 b[3,2].a[2].x = b[3,3].a[2].x;
    550564 - b[1,1].a[1].y - b[1,1].a[2].y - b[1,2].a[1].y - b[1,2].a[2].y - b[1,3].a[1].y - b[1,3].a[2].y - b[1,4].a[1].y - b[2,1].a[1].y - b[2,1].a[2].y - b[2,2].a[1].y - b[2,2].a[2].y - b[2,3].a[1].y - b[2,3].a[2].y - b[2,4].a[1].y - b[3,1].a[2].y - b[3,2].a[2].y - b[3,3].a[2].y = 0.0;
     565 b[1,1].a[1].y = 0.0;
     566 b[1,1].a[2].y = 0.0;
     567 b[1,2].a[1].y = 0.0;
     568 b[1,2].a[2].y = 0.0;
     569 b[1,3].a[1].y = 0.0;
     570 b[1,3].a[2].y = 0.0;
     571 b[1,4].a[1].y = 0.0;
     572 b[1,4].a[2].y = 0.0;
     573 b[2,1].a[1].y = 0.0;
     574 b[2,1].a[2].y = 0.0;
     575 b[2,2].a[1].y = 0.0;
     576 b[2,2].a[2].y = 0.0;
     577 b[2,3].a[1].y = 0.0;
     578 b[2,3].a[2].y = 0.0;
     579 b[2,4].a[1].y = 0.0;
     580 b[2,4].a[2].y = 0.0;
     581 b[3,1].a[1].y = 0.0;
     582 b[3,1].a[2].y = 0.0;
     583 b[3,2].a[1].y = 0.0;
     584 b[3,2].a[2].y = 0.0;
     585 b[3,3].a[1].y = 0.0;
     586 b[3,3].a[2].y = 0.0;
     587 b[3,4].a[1].y = 0.0;
     588 b[3,4].a[2].y = 0.0;
    551589end ConnectTests.ConnectTest12;
    552590")})));
     
    595633 b[2].a[2].x = b[3].a[2].x;
    596634 - b[1].a[2].y - b[2].a[2].y - b[3].a[2].y = 0.0;
     635 b[1].a[1].y = 0.0;
     636 b[1].a[2].y = 0.0;
     637 b[2].a[1].y = 0.0;
     638 b[2].a[2].y = 0.0;
     639 b[3].a[1].y = 0.0;
     640 b[3].a[2].y = 0.0;
    597641end ConnectTests.ConnectTest13;
    598642")})));
     
    670714 b1[2,2].a[2].x = b2[2,2].a[2].x;
    671715 - b1[2,2].a[2].y - b2[2,2].a[2].y = 0.0;
     716 b1[1,1].a[1].y = 0.0;
     717 b1[1,1].a[2].y = 0.0;
     718 b1[1,2].a[1].y = 0.0;
     719 b1[1,2].a[2].y = 0.0;
     720 b1[2,1].a[1].y = 0.0;
     721 b1[2,1].a[2].y = 0.0;
     722 b1[2,2].a[1].y = 0.0;
     723 b1[2,2].a[2].y = 0.0;
     724 b2[1,1].a[1].y = 0.0;
     725 b2[1,1].a[2].y = 0.0;
     726 b2[1,2].a[1].y = 0.0;
     727 b2[1,2].a[2].y = 0.0;
     728 b2[2,1].a[1].y = 0.0;
     729 b2[2,1].a[2].y = 0.0;
     730 b2[2,2].a[1].y = 0.0;
     731 b2[2,2].a[2].y = 0.0;
    672732end ConnectTests.ConnectTest14;
    673733")})));
     
    744804 b[1,2,2].a[2].x = b[2,2,2].a[2].x;
    745805 - b[1,2,2].a[2].y - b[2,2,2].a[2].y = 0.0;
     806 b[1,1,1].a[1].y = 0.0;
     807 b[1,1,1].a[2].y = 0.0;
     808 b[1,1,2].a[1].y = 0.0;
     809 b[1,1,2].a[2].y = 0.0;
     810 b[1,2,1].a[1].y = 0.0;
     811 b[1,2,1].a[2].y = 0.0;
     812 b[1,2,2].a[1].y = 0.0;
     813 b[1,2,2].a[2].y = 0.0;
     814 b[2,1,1].a[1].y = 0.0;
     815 b[2,1,1].a[2].y = 0.0;
     816 b[2,1,2].a[1].y = 0.0;
     817 b[2,1,2].a[2].y = 0.0;
     818 b[2,2,1].a[1].y = 0.0;
     819 b[2,2,1].a[2].y = 0.0;
     820 b[2,2,2].a[1].y = 0.0;
     821 b[2,2,2].a[2].y = 0.0;
    746822end ConnectTests.ConnectTest15;
    747823")})));
     
    11251201 a1.b[2].x = a2.b[2].x;
    11261202 - a1.b[2].y - a2.b[2].y = 0.0;
     1203 a1.b[1].y = 0.0;
     1204 a1.b[2].y = 0.0;
     1205 a2.b[1].y = 0.0;
     1206 a2.b[2].y = 0.0;
    11271207end ConnectTests.ConnectTest26;
    11281208")})));
     
    15701650 Real b.d.c2.y;
    15711651equation
     1652 c1.y = 0.0;
    15721653 b.c2.x = c1.x;
    15731654 - b.c2.y - c1.y = 0.0;
     
    26192700    end for;
    26202701
    2621     annotation(__JModelica(UnitTesting(tests={
    2622         TransformCanonicalTestCase(
    2623             name="StreamTest6",
    2624             description="Check that inStream() using out-of-bounds array access does not cause crash when used in inactive if branch",
    2625             flatModel="
     2702annotation(__JModelica(UnitTesting(tests={
     2703    TransformCanonicalTestCase(
     2704        name="StreamTest6",
     2705        description="Check that inStream() using out-of-bounds array access does not cause crash when used in inactive if branch",
     2706        eliminate_alias_variables=false,
     2707        variability_propagation=false,
     2708        flatModel="
    26262709fclass ConnectTests.StreamTest6
    26272710 structural parameter Integer n = 2 /* 2 */;
     
    26532736 - a[2].b + b[2].a.b = 0.0;
    26542737 a[2].c = b[2].a.c;
     2738 a[1].b = 0.0;
     2739 a[2].b = 0.0;
    26552740end ConnectTests.StreamTest6;
    26562741")})));
     
    27142799        name="Cardinality2",
    27152800        description="cardinality(): basic test",
     2801        eliminate_alias_variables=false,
     2802        variability_propagation=false,
    27162803        flatModel="
    27172804fclass ConnectTests.Cardinality2
     
    31543241        name="TopLevelIO2",
    31553242        description="",
     3243        eliminate_alias_variables=false,
     3244        variability_propagation=false,
    31563245        flatModel="
    31573246fclass ConnectTests.TopLevelIO2
     
    31633252 - c1.f + m.c2.f = 0.0;
    31643253 c1.x = m.c2.x;
     3254 c1.f = 0.0;
    31653255end ConnectTests.TopLevelIO2;
    31663256")})));
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectorArrays.mo

    r13104 r13704  
    394394 flow Real c5.b;
    395395equation
     396 c1.b = 0.0;
     397 c2.b = 0.0;
     398 c3.b = 0.0;
     399 c4.b = 0.0;
     400 c5.b = 0.0;
    396401 c1.a = ec1[1].x.a;
    397402 ec1[1].x.a = ec2[1].x.a;
     
    652657 flow Real c[4].f;
    653658equation
     659 c[1].f = 0.0;
     660 c[2].f = 0.0;
     661 c[3].f = 0.0;
     662 c[4].f = 0.0;
    654663 - c[1].f - c[3].f - ec1[1].a.f - ec2[1].a.f - ec3[1].a.f = 0.0;
    655664 c[1].p = c[3].p;
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/ExpandableConnectors.mo

    r13103 r13704  
    105105 flow Real c5.b;
    106106equation
     107 c1.b = 0.0;
     108 c2.b = 0.0;
     109 c3.b = 0.0;
     110 c4.b = 0.0;
     111 c5.b = 0.0;
    107112 c1.a = c3.a;
    108113 c3.a = c5.a;
     
    27102715 Real ec.x.c[2];
    27112716equation
     2717 c[1].a[1:1] = zeros(1);
     2718 c[1].b = 0.0;
    27122719 - c[1].a[1:1] - ec.x.a[1:1] = zeros(1);
    27132720 - c[1].b - ec.x.b = 0.0;
     
    27542761 Real ec.x[2].c[2];
    27552762equation
     2763 c[1].a[1:1] = zeros(1);
     2764 c[1].b = 0.0;
     2765 c[2].a[1:1] = zeros(1);
     2766 c[2].b = 0.0;
    27562767 - c[1].a[1:1] - ec.x[1].a[1:1] = zeros(1);
    27572768 - c[1].b - ec.x[1].b = 0.0;
     
    28062817 Real ec.x[2].c[2];
    28072818equation
     2819 c[1].a[1:1] = zeros(1);
     2820 c[1].b = 0.0;
     2821 c[2].a[1:1] = zeros(1);
     2822 c[2].b = 0.0;
     2823 c[3].a[1:1] = zeros(1);
     2824 c[3].b = 0.0;
    28082825 - c[2].a[1:1] - ec.x[1].a[1:1] = zeros(1);
    28092826 - c[2].b - ec.x[1].b = 0.0;
     
    28592876 Real ec.x[3].c[2];
    28602877equation
     2878 c1.a[1:1] = zeros(1);
     2879 c1.b = 0.0;
     2880 c2.a[1:1] = zeros(1);
     2881 c2.b = 0.0;
    28612882 - c1.a[1:1] - ec.x[1].a[1:1] = zeros(1);
    28622883 - c1.b - ec.x[1].b = 0.0;
     
    29132934 Real ec.x[2].b[3];
    29142935equation
     2936 c[1].a[1:2] = zeros(2);
     2937 c[2].a[1:3] = zeros(3);
    29152938 - c[1].a[1:2] - ec.x[1].a[1:2] = zeros(2);
    29162939 c[1].b[1:2] = ec.x[1].b[1:2];
     
    29622985 Real ec.x[3].c;
    29632986equation
     2987 c1.a = 0.0;
     2988 c2.a = 0.0;
    29642989 - c1.a - ec.x[1].a = 0.0;
    29652990 c1.b = inStream(ec.x[1].b);
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/NameTests.mo

    r13317 r13704  
    38133813 - b1.af.x - b2.af.x = 0.0;
    38143814 b1.ap.x = b2.ap.x;
     3815 b1.af.x = 0.0;
     3816 b2.af.x = 0.0;
    38153817end NameTests.InheritFlowTest1;
    38163818")})));
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/OperatorRecordTests.mo

    r13432 r13704  
    710710
    711711
     712    model OperatorOverload14
     713        operator record Cplx2 = Cplx;
     714        Cplx c1 = Cplx(1, 2);
     715        Cplx2 c2 = Cplx2(3, 4);
     716        Cplx c3 = c1 + c2;
     717
     718    annotation(__JModelica(UnitTesting(tests={
     719        FlatteningTestCase(
     720            name="OperatorOverload14",
     721            description="Short class decls of operator records",
     722            flatModel="
     723fclass OperatorRecordTests.OperatorOverload14
     724 OperatorRecordTests.Cplx c1 = OperatorRecordTests.Cplx.'constructor'(1, 2);
     725 OperatorRecordTests.OperatorOverload14.Cplx2 c2 = OperatorRecordTests.Cplx.'constructor'(3, 4);
     726 OperatorRecordTests.Cplx c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
     727
     728public
     729 function OperatorRecordTests.Cplx.'constructor'
     730  input Real re;
     731  input Real im;
     732  output OperatorRecordTests.Cplx c;
     733 algorithm
     734  c.re := re;
     735  c.im := im;
     736  return;
     737 end OperatorRecordTests.Cplx.'constructor';
     738
     739 function OperatorRecordTests.Cplx.'+'
     740  input OperatorRecordTests.Cplx a;
     741  input OperatorRecordTests.Cplx b;
     742  output OperatorRecordTests.Cplx c;
     743 algorithm
     744  (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
     745  return;
     746 end OperatorRecordTests.Cplx.'+';
     747
     748 record OperatorRecordTests.Cplx
     749  Real re;
     750  Real im;
     751 end OperatorRecordTests.Cplx;
     752
     753 record OperatorRecordTests.OperatorOverload14.Cplx2
     754  Real re;
     755  Real im;
     756 end OperatorRecordTests.OperatorOverload14.Cplx2;
     757
     758end OperatorRecordTests.OperatorOverload14;
     759")})));
     760    end OperatorOverload14;
     761
     762
    712763    model OperatorOverload15
    713764        Cplx[2] c1 = { Cplx(1, 2), Cplx(3, 4) };
     
    14471498 c2.x = c3.x;
    14481499 OperatorRecordTests.Cplx.'-'.sub(OperatorRecordTests.Cplx.'-'.sub(OperatorRecordTests.Cplx.'-'.neg(c1.y), c2.y), c3.y) = OperatorRecordTests.Cplx.'0'();
     1500 c1.y = OperatorRecordTests.Cplx.'0'();
     1501 c2.y = OperatorRecordTests.Cplx.'0'();
     1502 c3.y = OperatorRecordTests.Cplx.'0'();
    14491503
    14501504public
     
    15911645
    15921646
     1647    model OperatorRecordConnect3
     1648        connector C = Cplx;
     1649
     1650        C c1, c2, c3;
     1651    equation
     1652        connect(c1, c2);
     1653        c3 = c1 + c2;
     1654
     1655    annotation(__JModelica(UnitTesting(tests={
     1656        FlatteningTestCase(
     1657            name="OperatorRecordConnect3",
     1658            description="Connectors that are operator records",
     1659            flatModel="
     1660fclass OperatorRecordTests.OperatorRecordConnect3
     1661 OperatorRecordTests.OperatorRecordConnect3.C c1;
     1662 OperatorRecordTests.OperatorRecordConnect3.C c2;
     1663 OperatorRecordTests.OperatorRecordConnect3.C c3;
     1664equation
     1665 c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
     1666 c1 = c2;
     1667
     1668public
     1669 function OperatorRecordTests.Cplx.'+'
     1670  input OperatorRecordTests.Cplx a;
     1671  input OperatorRecordTests.Cplx b;
     1672  output OperatorRecordTests.Cplx c;
     1673 algorithm
     1674  (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
     1675  return;
     1676 end OperatorRecordTests.Cplx.'+';
     1677
     1678 function OperatorRecordTests.Cplx.'constructor'
     1679  input Real re;
     1680  input Real im;
     1681  output OperatorRecordTests.Cplx c;
     1682 algorithm
     1683  c.re := re;
     1684  c.im := im;
     1685  return;
     1686 end OperatorRecordTests.Cplx.'constructor';
     1687
     1688 record OperatorRecordTests.OperatorRecordConnect3.C
     1689  Real re;
     1690  Real im;
     1691 end OperatorRecordTests.OperatorRecordConnect3.C;
     1692
     1693 record OperatorRecordTests.Cplx
     1694  Real re;
     1695  Real im;
     1696 end OperatorRecordTests.Cplx;
     1697
     1698end OperatorRecordTests.OperatorRecordConnect3;
     1699")})));
     1700    end OperatorRecordConnect3;
     1701
    15931702
    15941703    model OperatorRecordConnect4
     
    16081717 potential OperatorRecordTests.Cplx c.x;
    16091718 flow OperatorRecordTests.Cplx c.y;
     1719equation
     1720 c.y = OperatorRecordTests.Cplx.'0'();
    16101721
    16111722public
     
    16361747    end OperatorRecordConnect4;
    16371748
     1749
     1750    model OperatorRecordConnect5
     1751        connector C = Cplx;
     1752       
     1753        model A
     1754            C c;
     1755        end A;
     1756       
     1757        A a[2];
     1758        C c[2];
     1759    equation
     1760        connect(a.c, c);
     1761
     1762    annotation(__JModelica(UnitTesting(tests={
     1763        FlatteningTestCase(
     1764            name="OperatorRecordConnect5",
     1765            description="Test connecting to array of operator record",
     1766            flatModel="
     1767fclass OperatorRecordTests.OperatorRecordConnect5
     1768 OperatorRecordTests.OperatorRecordConnect5.C a[1].c;
     1769 OperatorRecordTests.OperatorRecordConnect5.C a[2].c;
     1770 OperatorRecordTests.OperatorRecordConnect5.C c[2];
     1771equation
     1772 a[1].c = c[1];
     1773 a[2].c = c[2];
     1774
     1775public
     1776 record OperatorRecordTests.OperatorRecordConnect5.C
     1777  Real re;
     1778  Real im;
     1779 end OperatorRecordTests.OperatorRecordConnect5.C;
     1780
     1781end OperatorRecordTests.OperatorRecordConnect5;
     1782")})));
     1783    end OperatorRecordConnect5;
    16381784
    16391785
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/OverconstrainedConnection.mo

    r13103 r13704  
    335335 potential Real c1.x;
    336336 flow Real c1.y;
     337equation
     338 c1.y = 0.0;
    337339end OverconstrainedConnection.OverconstrainedCorrect6;
    338340")})));
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/RedeclareTests.mo

    r13103 r13704  
    72457245fclass RedeclareTests.Prefix.RedeclarePrefix9
    72467246 flow Real c.x;
     7247equation
     7248 c.x = 0.0;
    72477249end RedeclareTests.Prefix.RedeclarePrefix9;
    72487250")})));
     
    72707272equation
    72717273 - c1.x - c2.x = 0.0;
     7274 c1.x = 0.0;
     7275 c2.x = 0.0;
    72727276end RedeclareTests.Prefix.RedeclarePrefix10;
    72737277")})));
  • branches/dev-cw-evaluator/Compiler/ModelicaFrontEnd/test/modelica/StreamTests.mo

    r13370 r13704  
    229229            description="Using actualStream() on array of stream variables.",
    230230            eliminate_alias_variables=false,
     231            variability_propagation=false,
    231232            flatModel="
    232233fclass StreamTests.StreamTest6
     
    235236 stream Real d.b[2];
    236237 potential Real d.c;
    237  constant Real f[1] = 1;
    238  constant Real f[2] = 2;
    239 equation
    240  1.0 = d.b[1];
    241  2.0 = d.b[2];
     238 Real f[1];
     239 Real f[2];
     240equation
     241 f[1] = d.b[1];
     242 f[2] = d.b[2];
     243 f[1] = 1;
     244 f[2] = 2;
    242245 d.c = 0;
     246 d.a = 0.0;
    243247end StreamTests.StreamTest6;
    244248")})));
     
    270274            description="",
    271275            eliminate_alias_variables=false,
     276            variability_propagation=false,
    272277            flatModel="
    273278fclass StreamTests.StreamTest7
     
    286291 g.b = f.e.b;
    287292 f.e.c = g.c;
     293 g.a = 0.0;
    288294end StreamTests.StreamTest7;
    289295")})));
     
    595601 a.c.p = c.p;
    596602 c.s = a.c.s;
     603 c.f = 0.0;
    597604 a.c.p = 2;
    598605 a.c.s = 1;
     
    799806 a2.c.p = c.p;
    800807 c.s = (_stream_positiveMax_1 * a1.c.s + _stream_positiveMax_2 * a2.c.s) / (_stream_positiveMax_1 + _stream_positiveMax_2);
     808 c.f = 0.0;
    801809 a1.c.p = 4;
    802810 a1.c.f = time;
     
    877885 c1.s = (_stream_positiveMax_1 * a.c.s + _stream_positiveMax_2 * c2.s) / (_stream_positiveMax_1 + _stream_positiveMax_2);
    878886 c2.s = (_stream_positiveMax_3 * a.c.s + _stream_positiveMax_4 * c1.s) / (_stream_positiveMax_3 + _stream_positiveMax_4);
     887 c1.f = 0.0;
     888 c2.f = 0.0;
    879889 a.c.p = 2;
    880890 a.c.s = 1;
     
    10761086 c1.s = (_stream_positiveMax_1 * a1.c.s + _stream_positiveMax_2 * a2.c.s + _stream_positiveMax_3 * c2.s) / (_stream_positiveMax_1 + _stream_positiveMax_2 + _stream_positiveMax_3);
    10771087 c2.s = (_stream_positiveMax_4 * a1.c.s + _stream_positiveMax_5 * a2.c.s + _stream_positiveMax_6 * c1.s) / (_stream_positiveMax_4 + _stream_positiveMax_5 + _stream_positiveMax_6);
     1088 c1.f = 0.0;
     1089 c2.f = 0.0;
    10781090 a1.c.p = 4;
    10791091 a1.c.f = time;
     
    11631175 c1.s = (_stream_positiveMax_1 * a2.c.s + _stream_positiveMax_2 * c2.s) / (_stream_positiveMax_1 + _stream_positiveMax_2);
    11641176 c2.s = a2.c.s;
     1177 c1.f = 0.0;
     1178 c2.f = 0.0;
    11651179 a1.c.p = 4;
    11661180 a1.c.f = time + 1;
     
    12281242 c1.s = a2.c.s;
    12291243 c2.s = a2.c.s;
     1244 c1.f = 0.0;
     1245 c2.f = 0.0;
    12301246 a1.c.p = 4;
    12311247 a1.c.f = time + 1;
     
    12851301 c1.s = c2.s;
    12861302 c2.s = 0.0;
     1303 c1.f = 0.0;
     1304 c2.f = 0.0;
    12871305 a1.c.p = 4;
    12881306 a1.c.f = time + 1;
     
    19441962 c1.s = (_stream_positiveMax_1 * a1.c.s + _stream_positiveMax_2 * a2.c.s + _stream_positiveMax_3 * c2.s) / (_stream_positiveMax_1 + _stream_positiveMax_2 + _stream_positiveMax_3);
    19451963 c2.s = (_stream_positiveMax_4 * a1.c.s + _stream_positiveMax_5 * a2.c.s + _stream_positiveMax_6 * c1.s) / (_stream_positiveMax_4 + _stream_positiveMax_5 + _stream_positiveMax_6);
     1964 c1.f = 0.0;
     1965 c2.f = 0.0;
    19461966 a1.c.p = 4;
    19471967 a1.c.f = 1;
     
    20812101 c1[2].s = (_stream_positiveMax_7 * a1[2].c.s + _stream_positiveMax_8 * a2[2].c.s + _stream_positiveMax_9 * c2[2].s) / (_stream_positiveMax_7 + _stream_positiveMax_8 + _stream_positiveMax_9);
    20822102 c2[2].s = (_stream_positiveMax_10 * a1[2].c.s + _stream_positiveMax_11 * a2[2].c.s + _stream_positiveMax_12 * c1[2].s) / (_stream_positiveMax_10 + _stream_positiveMax_11 + _stream_positiveMax_12);
     2103 c1[1].f = 0.0;
     2104 c1[2].f = 0.0;
     2105 c2[1].f = 0.0;
     2106 c2[2].f = 0.0;
    20832107 a1[1].c.p = 3;
    20842108 a1[1].c.f = 1;
  • branches/dev-cw-evaluator/Compiler/ModelicaMiddleEnd/module.options

    r12631 r13704  
    6464
    6565*******************************************************************************
     66BOOLEAN causal_ports compiler experimental false
     67
     68"Treat top level connector variables as causal variables. Flow and instream
     69variables as inputs, potential and stream variables as outputs."
     70
     71*******************************************************************************
  • branches/dev-cw-evaluator/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/AliasElimination.jrag

    r12902 r13704  
    165165    eq FVariable.canBeAlias() = !getFAccess().myDerFV(order() + 1).isDummyDerivativeVariable()
    166166            && !isPreVariable() && !isNonDummyDerivativeVariable()
    167             && !isInput() && !isOutput() && !isIndependentParameter()
     167            && getCausalityConnectorPrefix().isNone() && !isIndependentParameter()
    168168            && !isInterface();
    169169
  • branches/dev-cw-evaluator/Compiler/ModelicaMiddleEnd/src/jastadd/structural/Graphs.jadd

    r13396 r13704  
    10381038
    10391039    /**
    1040      * Retrevies the list of strongly connected component contributors.
     1040     * Retrieves the list of strongly connected component contributors.
    10411041     * This method should always be used since it ensures that the list is
    1042      * initialized propperly.
     1042     * initialized properly.
    10431043     */
    10441044    public static Collection<SCCContributor> getSCCContributors() {
  • branches/dev-cw-evaluator/Compiler/ModelicaMiddleEnd/src/jastadd/structural/Symbolic.jrag

    r12811 r13704  
    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 nominal = factor.dynamicFExp(var.nominal());
     220            if (nominal.variability().constantVariability() &&
     221                    Math.abs(factor.ceval().realValue()) *
     222                    nominal.ceval().realValue() < tol) {
     223                return false;
     224            }
     225        }
     226        return true;
    209227    }
    210228   
  • branches/dev-cw-evaluator/Compiler/OptimicaFrontEnd/src/jastadd/OptimicaFlatAPI.jrag

    r11676 r13704  
    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-cw-evaluator/Compiler/TestFramework/src/jastadd/TestAnnotationizer.jrag

    r13294 r13704  
    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-cw-evaluator/Makefile.am

    r13396 r13704  
    6464    make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR)" "IPOPT_HOME=$(IPOPT_HOME)"
    6565    mkdir -p $(DESTDIR)$(prefix)/Python/
    66     cp -r $(abs_builddir)/casadi_install/casadi $(DESTDIR)$(prefix)/Python/
     66    cp -r $(CASADI_PYTHON_INST_DIR)/casadi $(DESTDIR)$(prefix)/Python/
    6767    ## temp fix
    68     cp $(abs_builddir)/casadi_build/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
     68    cp $(CASADI_BUILD_DIR)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
    6969endif
    7070if COMPILE_WITH_IPOPT64 
     
    7474    make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR64)" "IPOPT_HOME=$(IPOPT64_HOME)"
    7575    mkdir -p $(DESTDIR)$(prefix)/Python/
    76     cp -r $(abs_builddir)/casadi_install64/casadi $(DESTDIR)$(prefix)/Python_64/
     76    cp -r $(CASADI_PYTHON_INST_DIR64)/casadi $(DESTDIR)$(prefix)/Python_64/
    7777    ## temp fix
    78     cp $(abs_builddir)/casadi_build64/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
     78    cp $(CASADI_BUILD_DIR64)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
    7979    export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    8080    export PATH="$(ORIG_PATH)";
     
    504504JAVA_OC_CASADI_ANT_FILE=$(COMPILER_DIR)/OptimicaCompilerCasADi/build.xml
    505505
    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
     506all-local: build-python-packages build-compiler $(abs_builddir)/version.txt build-extra
     507
     508$(abs_builddir)/version.txt: TODO-always-trigger
     509    $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(@)
     510
     511build-extra: TODO-always-trigger
    508512    if [ "$(BUILD_EXTRA)" ]; then exec "$(BUILD_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    509513
     
    578582ant_output_options=$(JAVA_BUILD_DIR)/src/build/DefaultOptions.xml
    579583
    580 install-compiler: $(ant_output_jars) $(ant_output_options) TODO-always-trigger
     584install-compiler: $(ant_output_jars) $(ant_output_options)
    581585if HAVE_ANT
    582586    mkdir -p $(DESTDIR)$(prefix)/lib/
     
    585589endif
    586590
    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 
    591591$(ant_output_jars) $(ant_output_options): build-compiler
    592592
    593 build-compiler:
     593build-compiler: TODO-always-trigger
    594594if HAVE_ANT
    595595    mkdir -p $(JAVA_BUILD_DIR)
     
    599599    $(ANT_OPTS) $(ANT) -f "$(JAVA_OC_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(JAVA_BUILD_DIR)"
    600600endif
     601
     602# Dummy target used to always trigger rebuilds. Used to enable references to
     603# outputs from phony targets as real targets. For example ant output.
     604TODO-always-trigger: ;
    601605
    602606install-modules: install-modules-ModelicaFrontEnd
  • branches/dev-cw-evaluator/Makefile.in

    r13396 r13704  
    879879@COMPILE_WITH_IPOPT_TRUE@   make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR)" "IPOPT_HOME=$(IPOPT_HOME)"
    880880@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
     881@COMPILE_WITH_IPOPT_TRUE@   cp -r $(CASADI_PYTHON_INST_DIR)/casadi $(DESTDIR)$(prefix)/Python/
     882@COMPILE_WITH_IPOPT_TRUE@   cp $(CASADI_BUILD_DIR)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python/casadi
    883883@COMPILE_WITH_IPOPT64_TRUE@ export PATH=$(PYTHON64_HOME):$(PYTHON64_HOME)/Scripts:$(PYTHON64_HOME)/Lib:"${PATH}"; \
    884884@COMPILE_WITH_IPOPT64_TRUE@ export PYTHONHOME=$(PYTHON64_HOME); 
     
    886886@COMPILE_WITH_IPOPT64_TRUE@ make -f Makefile install "SWIGCHECK_BUILD_DIR=$(SWIGCHECK_BUILD_DIR)" "CASADI_BUILD_DIR=$(CASADI_BUILD_DIR64)" "IPOPT_HOME=$(IPOPT64_HOME)"
    887887@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
     888@COMPILE_WITH_IPOPT64_TRUE@ cp -r $(CASADI_PYTHON_INST_DIR64)/casadi $(DESTDIR)$(prefix)/Python_64/
     889@COMPILE_WITH_IPOPT64_TRUE@ cp $(CASADI_BUILD_DIR64)/swig/casadi_core.py $(DESTDIR)$(prefix)/Python_64/casadi
    890890@COMPILE_WITH_IPOPT64_TRUE@ export PYTHONHOME=$(ORIG_PYTHON_HOME); \
    891891@COMPILE_WITH_IPOPT64_TRUE@ export PATH="$(ORIG_PATH)";
     
    11931193@PYTHON_ENABLED_TRUE@   chmod ugo+x $(DESTDIR)$(prefix)/bin/jm_*.sh
    11941194
    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
     1195all-local: build-python-packages build-compiler $(abs_builddir)/version.txt build-extra
     1196
     1197$(abs_builddir)/version.txt: TODO-always-trigger
     1198    $(abs_top_srcdir)/get_version.sh $(abs_top_srcdir) https://svn.jmodelica.org > $(@)
     1199
     1200build-extra: TODO-always-trigger
    11971201    if [ "$(BUILD_EXTRA)" ]; then exec "$(BUILD_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    11981202
     
    12571261    if [ "$(INSTALL_EXTRA)" ]; then exec "$(INSTALL_EXTRA)" "$(abs_top_srcdir)" "$(DESTDIR)$(prefix)"; fi
    12581262
    1259 install-compiler: $(ant_output_jars) $(ant_output_options) TODO-always-trigger
     1263install-compiler: $(ant_output_jars) $(ant_output_options)
    12601264@HAVE_ANT_TRUE@ mkdir -p $(DESTDIR)$(prefix)/lib/
    12611265@HAVE_ANT_TRUE@ install -t $(DESTDIR)$(prefix)/lib/ $(ant_output_jars)
    12621266@HAVE_ANT_TRUE@ install -t $(DESTDIR)$(prefix)/ $(ant_output_options)
    12631267
    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 
    12681268$(ant_output_jars) $(ant_output_options): build-compiler
    12691269
    1270 build-compiler:
     1270build-compiler: TODO-always-trigger
    12711271@HAVE_ANT_TRUE@ mkdir -p $(JAVA_BUILD_DIR)
    12721272@HAVE_ANT_TRUE@ cd $(JAVA_BUILD_DIR); \
     
    12741274@HAVE_ANT_TRUE@ cd $(JAVA_BUILD_DIR); \
    12751275@HAVE_ANT_TRUE@ $(ANT_OPTS) $(ANT) -f "$(JAVA_OC_ANT_FILE)" "-Dcompiler=$(COMPILER_DIR)" "-Dtarget=$(JAVA_BUILD_DIR)"
     1276
     1277# Dummy target used to always trigger rebuilds. Used to enable references to
     1278# outputs from phony targets as real targets. For example ant output.
     1279TODO-always-trigger: ;
    12761280
    12771281install-modules: install-modules-ModelicaFrontEnd
  • branches/dev-cw-evaluator/Python/src/pymodelica/compiler_logging.py

    r13252 r13704  
    129129        return self.last
    130130   
     131    def close(self):
     132        """
     133        Closes the underlying stream.
     134        """
     135        self.stream.close()
     136   
    131137    def genErrorMsg(self, e):
    132138        column = e.getColumnNumber()
  • branches/dev-cw-evaluator/Python/src/pymodelica/compiler_wrappers.py

    r12127 r13704  
    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-cw-evaluator/Python/src/tests_jmodelica/optimization/test_realtime_mpc.py

    r10318 r13704  
    3535def check_result(results, ref):
    3636    for key in ref:
    37         assert abs(ref[key] - results[key][-1]) < 1e-5
     37        assert abs(ref[key] - results[key][-1]) < 1e-3, abs(ref[key] - results[key][-1])
    3838       
    3939
  • branches/dev-cw-evaluator/Python/src/tests_jmodelica/test_compiler.py

    r12127 r13704  
    391391        """
    392392        fmuname = compile_fmu(Test_Compiler_functions.cpath_mc, Test_Compiler_functions.fpath_mc, compiler_options={'generate_html_diagnostics':True})
     393        (diag_name, _) = os.path.splitext(fmuname)
     394        diag_name += '_html_diagnostics'
     395
     396        assert os.access(fmuname, os.F_OK) == True, \
     397               fmuname+" was not created."
     398        assert os.access(diag_name, os.F_OK) == True, \
     399               diag_name+" was not created."
     400        os.remove(fmuname)
     401        shutil.rmtree(diag_name)
     402
     403    @testattr(stddist_base = True)
     404    def test_dynamic_state_html_diagnostics(self):
     405        """
     406        Test that generate_html_diagnostics works with a model with dynamic states, see #5839
     407        """
     408
     409        fmuname = compile_fmu("ThreeDSOneEq", os.path.join(get_files_path(), 'Modelica', 'ThreeDSOneEq.mo'), compiler_options={'generate_html_diagnostics':True})
    393410        (diag_name, _) = os.path.splitext(fmuname)
    394411        diag_name += '_html_diagnostics'
Note: See TracChangeset for help on using the changeset viewer.