Changeset 13943


Ignore:
Timestamp:
Nov 4, 2019 12:08:03 PM (10 days ago)
Author:
randersson
Message:

#5819 Merged trunk to branch

Location:
branches/dev-5819
Files:
40 edited
3 copied

Legend:

Unmodified
Added
Removed
  • branches/dev-5819

  • branches/dev-5819/.project

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

    r13800 r13943  
    11================= Unreleased ==================
     2# Fixed ; Minor ; Compiler; #5864
     3Fixed bug where partial variability propagation lead to unbalanced equation systems.
     4
     5# Fixed ; Minor ; Compiler ; #5862
     6Fixed bug where empty array subscripts added during scalarization lead to c-compilation error.
     7
    28# Feature ; Minor ; Compiler; #5837
    39Added a pre-compiled evaluator used for evaluating external functions
     
    1420
    1521# Fixed ; Minor ; Compiler; #5835
    16 Format string argument to the String function is now useable.
     22Format string argument to the String function is now respected during constant evaluations.
    1723
    1824# Change ; Minor ; Compiler; #5830
  • branches/dev-5819/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r13800 r13943  
    1717import java.util.Arrays;
    1818import org.jmodelica.common.ccodegen.CFuncParamDirection;
     19import org.jmodelica.util.values.CFormatSpecifier;
     20import org.jmodelica.util.collections.TransformerIterable;
    1921
    2022aspect CCodeGenExpressions {
     
    792794        genStringFormat_C(p, str, indent);
    793795        str.print(", ");
    794         genStringParts_C(p, str, indent);
     796        genStringParts_C(p, str, indent, null);
    795797        str.println(");");
    796798    }
     
    856858    @Override
    857859    public void FStringExp.genVarDecls_C(CodePrinter p, CodeStream str, String indent) {
    858         super.genVarDecls_C(p, str, indent);
     860        for (ASTNode ch : childrenToGenFor_C()) {
     861            ch.genVarDecls_C(p, str, indent);
     862        }
    859863        genTopStringDecl(p, str, indent);
    860864    }
     
    862866    @Override
    863867    public void FStringExp.genTempVars_C(CodePrinter p, CodeStream str, String indent) {
    864         super.genTempVars_C(p, str, indent);
     868        for (ASTNode ch : childrenToGenFor_C()) {
     869            p.printPreSteps(ch, str, indent);
     870        }
    865871        genTopStringInit(p, str, indent);
    866872    }
     
    873879    @Override
    874880    public void FStringExp.genTempFree_C(CodePrinter p, CodeStream str, String indent) {
    875         super.genTempFree_C(p, str, indent);
     881        for (ASTNode ch : childrenToGenFor_C()) {
     882            ch.genTempFree_C(p, str, indent);
     883        }
     884    }
     885
     886    private Iterable<ASTNode> FStringExp.childrenToGenFor_C() {
     887        // We want to generate for NTA CFormat but not for child Format.
     888        return new TransformerIterable<ASTNode, ASTNode>(this) {
     889            private ASTNode fmt = getFormatOpt();
     890            protected ASTNode transform(ASTNode a) throws SkipException {
     891                return (a == fmt) ? getCFormatOpt() : a;
     892            }
     893        };
    876894    }
    877895
     
    947965    public void FStringExp.genStringFormat_C(CodePrinter p, CodeStream str, String indent) {
    948966        if (hasFormat()) {
    949             p.print(getFormat(), str, indent);
     967            p.print(getCFormat(), str, indent);
    950968        } else {
    951969            if (hasLeftJustified()) {
     
    9871005        if (getValue().type().isReal())
    9881006            str.print(".*");
    989         str.print(getValue().type().formatSpecifier());
     1007        str.print(getValue().type().formatConversion());
    9901008        str.print("\"");
    9911009    }
    9921010
    993     public void FExp.genStringParts_C(CodePrinter p, CodeStream str, String indent) {
     1011    public void FExp.genStringParts_C(
     1012            CodePrinter p, CodeStream str, String indent, CFormatSpecifier format) {
    9941013        // TODO: This method should dispatch to the type!
    9951014        FType t = type();
     
    10041023            str.print(", JMI_TRUE, \"true\", \"false\")");
    10051024        } else {
    1006             if (t.isInteger())
    1007                 str.print("(int) ");
     1025            if (format != null) {
     1026                if (format.expectedType.isUnsigned()) {
     1027                    str.print("(unsigned int) ");
     1028                } else if (format.expectedType.isInteger()) {
     1029                    str.print("(int) ");
     1030                }
     1031            } else {
     1032                if (t.isInteger()) {
     1033                    str.print("(int) ");
     1034                }
     1035            }
    10081036            p.print(this, str, indent);
    10091037        }
     
    10111039
    10121040    @Override
    1013     public void FStringExp.genStringParts_C(CodePrinter p, CodeStream str, String indent) {
    1014         getValue().genStringParts_C(p, str, indent);
     1041    public void FStringExp.genStringParts_C(
     1042            CodePrinter p, CodeStream str, String indent, CFormatSpecifier format) {
     1043        try {
     1044            // This depends on non-parameters being evaluatable.
     1045            format = formatSpecifier();
     1046        } catch (ConstantEvaluationException e) {
     1047            // Assume that we don't have a format that converts real -> integer,
     1048            // and just go by the type.
     1049            format = null;
     1050        }
     1051        getValue().genStringParts_C(p, str, indent, format);
    10151052    }
    10161053
  • branches/dev-5819/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenGlobals.jrag

    r13099 r13943  
    545545            String strName = v.type().name() + ".destructor";
    546546            FCallable c = getName().lookupFCallable(strName);
    547             str.print(indent, c.funcNameUnderscore(C_SUFFIX_DEF), "(", FExp.global_C(v.nameUnderscore()), ");\n");
     547            str.print(indent, "if (", FExp.global_C(v.nameUnderscore()), " != NULL) {\n");
     548            str.print(p.indent(indent), c.funcNameUnderscore(C_SUFFIX_DEF), "(", FExp.global_C(v.nameUnderscore()), ");\n");
     549            str.print(p.indent(indent), FExp.global_C(v.nameUnderscore()), " = NULL;\n");
     550            str.print(indent, "}");
    548551        }
    549552    }
  • branches/dev-5819/Compiler/ModelicaCBackEnd/templates/FMIBase/base.c

    r12878 r13943  
    183183}
    184184
    185 int jmi_destruct_external_objs(jmi_t* jmi) {
     185int model_destruct_external_objects(jmi_t* jmi) {
    186186$C_destruct_external_object$
    187187    return 0;
  • branches/dev-5819/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenArrayTests.mo

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

    r13600 r13943  
    13771377    jmi_extobj_t CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo1;
    13781378
     1379
    13791380jmi_extobj_t jmi_global_tmp_1(jmi_t* jmi) {
    13801381    JMI_DYNAMIC_INIT()
     
    13891390    return tmp_1;
    13901391}
    1391 
    13921392int model_init_eval_independent_globals_0(jmi_t* jmi) {
    13931393    int ef = 0;
     
    14501450
    14511451
    1452     func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo));
     1452    if (JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo) != NULL) {
     1453        func_CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_EO_destructor_def1(JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo));
     1454        JMI_GLOBAL(CCodeGenGlobalsTests_GlobalVariables_GlobalConstantExternalObject1_P_eo) = NULL;
     1455    }
    14531456")})));
    14541457end GlobalConstantExternalObject1;
  • branches/dev-5819/Compiler/ModelicaCBackEnd/test/modelica/CCodeGenTests.mo

    r13168 r13943  
    10791079    StringCompare("      medium", String(enumVar, minimumLength=12, leftJustified=false));
    10801080
    1081     StringCompare("42",           String(intVar, format="%d"));
    1082     StringCompare("3.1400000",    String(realVar, format="%f"));
     1081    StringCompare("42",           String(intVar, format="d"));
     1082    StringCompare("3.1400000",    String(realVar, format="f"));
    10831083
    10841084annotation(__JModelica(UnitTesting(tests={
     
    1601916019        input Integer i;
    1602016020        input Boolean b;
    16021         input String fmt;
    1602216021        output Real y;
    1602316022        String s;
     
    1602916028        + String(x, significantDigits=i, leftJustified=b)
    1603016029        + String(x)
    16031         + String(x, format=fmt)
    1603216030       
    1603316031        + String(i, minimumLength=2, leftJustified=b)
    1603416032        + String(i, minimumLength=i, leftJustified=true)
    1603516033        + String(i, minimumLength=i, leftJustified=b)
    16036         + String(i, format=fmt)
    1603716034       
    1603816035        + String(b, minimumLength=2, leftJustified=b)
     
    1604116038    end f;
    1604216039   
    16043     Real y = f(-time, 3, true, "%g");
     16040    Real y = f(-time, 3, true);
    1604416041
    1604516042annotation(__JModelica(UnitTesting(tests={
     
    1605116048        template="$C_functions$",
    1605216049        generatedCode="
    16053 void func_CCodeGenTests_StringOperations9_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t b_v, jmi_string_t fmt_v, jmi_real_t* y_o) {
     16050void func_CCodeGenTests_StringOperations9_f_def0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t b_v, jmi_real_t* y_o) {
    1605416051    JMI_DYNAMIC_INIT()
    1605516052    JMI_DEF(REA, y_v)
     
    1605716054    JMI_DEF_STR_DYNA(tmp_1)
    1605816055    JMI_INI(STR, s_v)
    16059     JMI_INI_STR_DYNA(tmp_1, jmi_max(7 + 1.0, i_v) + jmi_max(7 + i_v, 2.0) + jmi_max(7 + i_v, i_v) + jmi_max(7 + i_v, i_v) + 7 + i_v + 7 + 6 + 16 + jmi_max(10, 2.0) + jmi_max(10, i_v) + jmi_max(10, i_v) + 16 + jmi_max(5, 2.0) + jmi_max(5, i_v) + jmi_max(5, i_v))
     16056    JMI_INI_STR_DYNA(tmp_1, jmi_max(7 + 1.0, i_v) + jmi_max(7 + i_v, 2.0) + jmi_max(7 + i_v, i_v) + jmi_max(7 + i_v, i_v) + 7 + i_v + 7 + 6 + jmi_max(10, 2.0) + jmi_max(10, i_v) + jmi_max(10, i_v) + jmi_max(5, 2.0) + jmi_max(5, i_v) + jmi_max(5, i_v))
    1606016057    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-*.*g\", \"%*.*g\"), (int) i_v, (int) 1.0, x_v);
    1606116058    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-*.*g\", \"%*.*g\"), (int) 2.0, (int) i_v, x_v);
     
    1606416061    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-.*g\", \"%.*g\"), (int) i_v, x_v);
    1606516062    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), \"%-.*g\", (int) 6, x_v);
    16066     snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), fmt_v, x_v);
    1606716063    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-*d\", \"%*d\"), (int) 2.0, (int) i_v);
    1606816064    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(JMI_TRUE, JMI_TRUE, \"%-*d\", \"%*d\"), (int) i_v, (int) i_v);
    1606916065    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-*d\", \"%*d\"), (int) i_v, (int) i_v);
    16070     snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), fmt_v, (int) i_v);
    1607116066    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(b_v, JMI_TRUE, \"%-*s\", \"%*s\"), (int) 2.0, COND_EXP_EQ(b_v, JMI_TRUE, \"true\", \"false\"));
    1607216067    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), COND_EXP_EQ(JMI_TRUE, JMI_TRUE, \"%-*s\", \"%*s\"), (int) i_v, COND_EXP_EQ(b_v, JMI_TRUE, \"true\", \"false\"));
     
    1607816073}
    1607916074
    16080 jmi_real_t func_CCodeGenTests_StringOperations9_f_exp0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t b_v, jmi_string_t fmt_v) {
     16075jmi_real_t func_CCodeGenTests_StringOperations9_f_exp0(jmi_real_t x_v, jmi_real_t i_v, jmi_real_t b_v) {
    1608116076    JMI_DEF(REA, y_v)
    16082     func_CCodeGenTests_StringOperations9_f_def0(x_v, i_v, b_v, fmt_v, &y_v);
     16077    func_CCodeGenTests_StringOperations9_f_def0(x_v, i_v, b_v, &y_v);
    1608316078    return y_v;
    1608416079}
     
    1625316248")})));
    1625416249end StringOperations11;
     16250
     16251
     16252model StringOperations12
     16253    type E = enumeration(Alice, Bob, Eve);
     16254
     16255    function f
     16256        input Integer x;
     16257        input E e;
     16258        output Real y;
     16259    protected
     16260        String s;
     16261    algorithm
     16262        s := String(x, format="7u") +
     16263             String(x, format="-3d") +
     16264             String(e);
     16265        y := x + .5;
     16266    end f;
     16267   
     16268    Real y = f(integer(time), if time < 1 then E.Alice else E.Eve);
     16269
     16270annotation(__JModelica(UnitTesting(tests={
     16271    CCodeGenTestCase(
     16272        name="StringOperations12",
     16273        description="Check that integer-typed format strings generate the correct casts",
     16274        template="$C_functions$",
     16275        generatedCode="
     16276void func_CCodeGenTests_StringOperations12_f_def0(jmi_real_t x_v, jmi_real_t e_v, jmi_real_t* y_o) {
     16277    JMI_DYNAMIC_INIT()
     16278    JMI_DEF(REA, y_v)
     16279    JMI_DEF(STR, s_v)
     16280    JMI_DEF_STR_STAT(tmp_1, 37)
     16281    JMI_INI(STR, s_v)
     16282    JMI_INI_STR_STAT(tmp_1)
     16283    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), \"%7u\", (unsigned int) x_v);
     16284    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), \"%-3d\", (int) x_v);
     16285    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), \"%-s\", E_0_e[(int) e_v]);
     16286    JMI_ASG(STR, s_v, tmp_1)
     16287    y_v = x_v + 0.5;
     16288    JMI_RET(GEN, y_o, y_v)
     16289    JMI_DYNAMIC_FREE()
     16290    return;
     16291}
     16292
     16293jmi_real_t func_CCodeGenTests_StringOperations12_f_exp0(jmi_real_t x_v, jmi_real_t e_v) {
     16294    JMI_DEF(REA, y_v)
     16295    func_CCodeGenTests_StringOperations12_f_def0(x_v, e_v, &y_v);
     16296    return y_v;
     16297}
     16298
     16299")})));
     16300end StringOperations12;
     16301
     16302
     16303model StringOperations13
     16304    function f
     16305        input Real x;
     16306        output Real y;
     16307    protected
     16308        String s;
     16309    algorithm
     16310        s := String(x, format="%g");
     16311        y := x + .5;
     16312    end f;
     16313   
     16314    Real y = f(time);
     16315
     16316annotation(__JModelica(UnitTesting(tests={
     16317    CCodeGenTestCase(
     16318        name="StringOperations13",
     16319        description="Check that we handle case where initial '%' of format specifier is included in format argument of String()",
     16320        template="$C_functions$",
     16321        generatedCode="
     16322void func_CCodeGenTests_StringOperations13_f_def0(jmi_real_t x_v, jmi_real_t* y_o) {
     16323    JMI_DYNAMIC_INIT()
     16324    JMI_DEF(REA, y_v)
     16325    JMI_DEF(STR, s_v)
     16326    JMI_DEF_STR_STAT(tmp_1, 16)
     16327    JMI_INI(STR, s_v)
     16328    JMI_INI_STR_STAT(tmp_1)
     16329    snprintf(JMI_STR_END(tmp_1), JMI_STR_LEFT(tmp_1), \"%g\", x_v);
     16330    JMI_ASG(STR, s_v, tmp_1)
     16331    y_v = x_v + 0.5;
     16332    JMI_RET(GEN, y_o, y_v)
     16333    JMI_DYNAMIC_FREE()
     16334    return;
     16335}
     16336
     16337jmi_real_t func_CCodeGenTests_StringOperations13_f_exp0(jmi_real_t x_v) {
     16338    JMI_DEF(REA, y_v)
     16339    func_CCodeGenTests_StringOperations13_f_def0(x_v, &y_v);
     16340    return y_v;
     16341}
     16342
     16343")})));
     16344end StringOperations13;
    1625516345
    1625616346package TestTerminate
  • branches/dev-5819/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r13800 r13943  
    22332233        if (target.getMakeFileFlag() != null) {
    22342234                ASTNode.beginStep("compileCCode()");
    2235                 String cFileName = fc.nameUnderscore();
     2235                String cFileName = cName(fc);
    22362236                CCompilerDelegator ccompiler = getCCompiler();
    22372237                CCompilerArguments ccArgs = new CCompilerArguments(cFileName, fc.myOptions(), target, fc.externalLibraries(), fc.externalLibraryDirectories(),
     
    22432243        hookCodeCompiled();
    22442244     }
     2245
     2246    private String ModelicaCompiler.cName(FClass fc) {
     2247        return fc.nameUnderscore(); // Hook to facilitate extensions.
     2248    }
    22452249
    22462250    /**
  • branches/dev-5819/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13800 r13943  
    2222import java.util.Map;
    2323import java.util.Set;
     24import java.util.IllegalFormatException;
    2425
    2526import org.jmodelica.util.BinaryOperation;
     
    3233import org.jmodelica.util.values.ConstantEvaluationNotReadyException;
    3334import org.jmodelica.util.values.FunctionEvaluationException;
     35import org.jmodelica.util.values.CFormatSpecifier;
    3436
    3537
     
    28462848       
    28472849        CValue cval = getValue().ceval(evaluator);
    2848         boolean isReal = getValue().type().isReal();
    2849         if (isReal) {
     2850        final CFormatSpecifier format = formatSpecifier(evaluator);
     2851       
     2852        if (!format.isValid()) {
     2853            throw new ConstantEvaluationException(format.errorMessage());
     2854        }
     2855       
     2856        // Do any necessary type conversions.
     2857        if (format.expectedType.isReal()) {
    28502858            cval = cval.convertReal();
     2859        } else if (format.expectedType.isInteger()) {
     2860            cval = cval.convertInteger();
    28512861        }
    28522862        Object value = cval.objectValue();
    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             }
     2863        if (format.expectedType.isUnsigned()) {
     2864            // Convert to the closest Java equivalent to an unsigned int.
     2865            // TODO: When we no longer need to support Java 7, use Integer.toUnsignedLong instead.
     2866            value = Long.valueOf(((Integer) value).longValue() & 0xffffffffL);
    28802867        }
    28812868       
    28822869        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");
     2870            return new CValueString(String.format((Locale) null, format.javaFormat, value));
     2871        } catch (IllegalFormatException e) {
     2872            throw new ConstantEvaluationException("The format string \"" + format.format +
     2873                    "\" and the value " + value + " do not match in the string conversion: " + this, e);
    28872874        }
    28882875    }
     
    28972884    }
    28982885
    2899     syn String FStringExp.formatString(VariableEvaluator evaluator) {
    2900         StringBuilder buf = new StringBuilder("%");
     2886    syn CFormatSpecifier FStringExp.formatSpecifier() = formatSpecifier(defaultVariableEvaluator());
     2887
     2888    syn CFormatSpecifier FStringExp.formatSpecifier(VariableEvaluator evaluator) {
    29012889        if (hasFormat()) {
    2902             buf.append(getFormat().ceval(evaluator).stringValue());
     2890            return CFormatSpecifier.parseFormat(getFormat().ceval(evaluator).stringValue());
    29032891        } else {
    2904             int minLength = minimumLength(evaluator);
    2905             if (minLength > 0) {
    2906                 if (leftJustified(evaluator)) {
    2907                     buf.append('-');
    2908                 }
    2909                 buf.append(minLength);
    2910             }
    2911             if (getValue().type().isReal()) {
    2912                 buf.append('.');
    2913                 buf.append(significantDigits(evaluator));
    2914             }
    2915             buf.append(getValue().type().formatSpecifier());
    2916         }
    2917         return buf.toString();
     2892            FType t = getValue().type();
     2893            int m = minimumLength(evaluator);
     2894            boolean l = leftJustified(evaluator);
     2895            if (t.isReal()) {
     2896                int s = significantDigits(evaluator);
     2897                return CFormatSpecifier.realFormat(l, m, s);
     2898            } else if (t.isInteger()) {
     2899                return CFormatSpecifier.integerFormat(l, m);
     2900            } else {
     2901                return CFormatSpecifier.stringFormat(l, m);
     2902            }
     2903        }
    29182904    }
    29192905
    29202906    syn int FStringExp.minimumLength(VariableEvaluator evaluator)     =
    2921         hasMinimumLength() ? getMinimumLength().ceval(evaluator).intValue() : 0;
     2907        hasMinimumLength() ? getMinimumLength().ceval(evaluator).intValue() : 1;
    29222908    syn boolean FStringExp.leftJustified(VariableEvaluator evaluator) =
    29232909        hasLeftJustified() ? getLeftJustified().ceval(evaluator).booleanValue() : true;
    29242910    syn int FStringExp.significantDigits(VariableEvaluator evaluator) =
    29252911        hasSignificantDigits() ? getSignificantDigits().ceval(evaluator).intValue() : DEFAULT_PRECISION;
    2926     syn String FType.formatSpecifier() {
     2912    syn String FType.formatConversion() {
    29272913        throw new UnsupportedOperationException();
    29282914    }
    2929     eq FRealType.formatSpecifier()    = "g";
    2930     eq FIntegerType.formatSpecifier() = "d";
    2931     eq FBooleanType.formatSpecifier() = "s";
    2932     eq FEnumType.formatSpecifier()    = "s";
    2933     eq FStringType.formatSpecifier()  = "s";
     2915    eq FRealType.formatConversion()    = "g";
     2916    eq FIntegerType.formatConversion() = "d";
     2917    eq FBooleanType.formatConversion() = "s";
     2918    eq FEnumType.formatConversion()    = "s";
     2919    eq FStringType.formatConversion()  = "s";
    29342920    public static final int FStringExp.DEFAULT_PRECISION = 6;
    29352921
  • branches/dev-5819/Compiler/ModelicaFlatTree/src/jastadd/FlatAPI/FlatAPI.jrag

    r13651 r13943  
    44684468            return unboundCopy();
    44694469    }
     4470
     4471    /**
     4472     * The format string including the implicit leading "%", if the format argument is given.
     4473     */
     4474    syn lazy Opt<FExp> FStringExp.getCFormatOpt() {
     4475        // TODO: To save memory, this could be solved in the C code generation instead.
     4476        if (hasFormat()) {
     4477            FExp fmt = getFormat();
     4478            FExp exp = fmt.treeCopy();
     4479            if (!formatSpecifier().initialPercent) {
     4480                exp = new FStringAddExp(new FStringLitExp("%"), exp);
     4481            }
     4482            if (fmt.variability().fixedParameterOrLess()) {
     4483                try {
     4484                    exp.parent = this;
     4485                    exp = exp.ceval().buildLiteral();
     4486                } catch (ConstantEvaluationException e) {
     4487                    // If we can't evaluate, just leave it as is
     4488                }
     4489            }
     4490            return new Opt<FExp>(exp);
     4491        } else {
     4492            return new Opt<FExp>();
     4493        }
     4494    }
    44704495}
  • branches/dev-5819/Compiler/ModelicaFlatTree/src/jastadd/HtmlSourcePrettyPrint.jrag

    r13246 r13943  
    11import java.io.File;
     2import java.nio.file.Path;
     3import java.nio.file.Paths;
     4import java.nio.file.InvalidPathException;
    25
    36import beaver.Symbol;
     
    276279    }
    277280   
    278     private static String BaseNode.cropAbsolutePath(String path){
    279         String p = path;
    280         String dir = System.getProperty("user.dir");
    281         try {
    282             if (p.substring(0, dir.lastIndexOf("\\")).equals(dir.substring(0, dir.lastIndexOf("\\")))) {
    283                 p = p.substring(dir.lastIndexOf("\\") + 1);
    284             }
    285         } catch (IndexOutOfBoundsException e) {}
    286         return p;
     281    private static String BaseNode.cropAbsolutePath(String path) {
     282        try {
     283            Path p = Paths.get(path);
     284            if (p.isAbsolute()) {
     285                Path cwd = Paths.get("").toAbsolutePath();
     286                if (p.startsWith(cwd)) {
     287                    p = cwd.relativize(p);
     288                }
     289            }
     290            return p.toString();
     291        } catch (InvalidPathException e) {
     292            // Incoming path is invalid, so we can't really process it
     293            return path;
     294        }
    287295    }
    288296   
  • branches/dev-5819/Compiler/ModelicaFlatTree/src/jastadd/PrettyPrint.jrag

    r13600 r13943  
    14061406   
    14071407    public void FArraySubscripts.prettyPrint(Printer p, CodeStream str, String indent) {
    1408         if (numSubscript()>0) {
    1409             str.print("[");
    1410             for (int i=0;i<numSubscript();i++) {
    1411                 subscript(i).prettyPrint(p, str, indent);
    1412                 if (i<numSubscript()-1)
    1413                     str.print(",");
    1414             }
    1415             str.print("]");
    1416         }
     1408        str.print("[");
     1409        for (int i = 0; i < numSubscript(); i++) {
     1410            subscript(i).prettyPrint(p, str, indent);
     1411            if (i < numSubscript() - 1) {
     1412                str.print(",");
     1413            }
     1414        }
     1415        str.print("]");
    14171416    }
    14181417
     
    18621861    }
    18631862
    1864     protected static final String FBuiltInFunctionCall.SEP = ", ";
    1865    
    1866     /**
    1867      * Pretty-print all arguments of function.
    1868      *
    1869      * Default implementation prints all direct FExp children (including those in Lists and Opts),
    1870      * separated by {@link #SEP}.
    1871      */
    1872     protected void FBuiltInFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
    1873         String pre = "";
    1874         for (FExp exp : myArgs()) {
    1875             str.print(pre);
    1876             p.print(exp, str, indent);
    1877             pre = SEP;
    1878         }
    1879     }
    1880    
     1863    protected static final String FBuiltInFunctionCall.SEP = ", ";
     1864
     1865    /**
     1866     * Pretty-print all arguments of function.
     1867     *
     1868     * Default implementation will in instance tree print the original arguments, and in
     1869     * flat tree print all direct FExp children (including those in Lists and Opts),
     1870     * in either case separated by {@link #SEP}.
     1871     */
     1872    protected void FBuiltInFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
     1873        String pre = "";
     1874        if (getNumOriginalArg() > 0) {
     1875            for (InstFunctionArgument arg : getOriginalArgs()) {
     1876                if (arg.isGiven()) {
     1877                    str.print(pre);
     1878                    p.print(arg, str, indent);
     1879                    pre = SEP;
     1880                }
     1881            }
     1882        } else {
     1883            for (FExp exp : myArgs()) {
     1884                str.print(pre);
     1885                p.print(exp, str, indent);
     1886                pre = SEP;
     1887            }
     1888        }
     1889    }
     1890
    18811891    protected void FInfArgsFunctionCall.prettyPrintArguments(Printer p, CodeStream str, String indent) {
    18821892        getFExps().prettyPrintWithSep(p, str, indent, SEP);
  • branches/dev-5819/Compiler/ModelicaFlatTree/src/jastadd/ast/FlatModelica.ast

    r13651 r13943  
    16061606 * String conversion operator.
    16071607 */
    1608 FStringExp : FBuiltInFunctionCall ::= Value:FExp [MinimumLength:FExp] [LeftJustified:FExp] [SignificantDigits:FExp] [Format:FExp];
     1608FStringExp : FBuiltInFunctionCall ::= Value:FExp
     1609                                      [MinimumLength:FExp]
     1610                                      [LeftJustified:FExp]
     1611                                      [SignificantDigits:FExp]
     1612                                      [Format:FExp]
     1613                                      /[CFormat:FExp]/;
    16091614
    16101615/**
  • branches/dev-5819/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r13600 r13943  
    46824682
    46834683model StringConvertWithParam1
     4684    /* TODO: a constant with a binding expression depending on parameters isn't really allowed,
     4685             but we don't check it - need to find a better way to test this when that is fixed
     4686             perhaps a string param that becomes structural?
     4687     */
    46844688    parameter Integer len = 8;
    46854689    parameter Boolean left = false;
     
    46944698        flatModel="
    46954699fclass EvaluationTests.StringConvert.StringConvertWithParam1
    4696  structural parameter Integer len = 8 /* 8 */;
    4697  structural parameter Boolean left = false /* false */;
    4698  structural parameter Integer dig = 4 /* 4 */;
     4700 parameter Integer len = 8 /* 8 */;
     4701 parameter Boolean left = false /* false */;
     4702 parameter Integer dig = 4 /* 4 */;
    46994703 constant Real x = 1.23456789;
    47004704 constant String s = \"   1.23\";
     
    47054709
    47064710model StringConvertWithParam2
     4711    /* TODO: a constant with a binding expression depending on parameters isn't really allowed,
     4712             but we don't check it - need to find a better way to test this when that is fixed
     4713             perhaps a string param that becomes structural?
     4714     */
    47074715    parameter String fmtSize = "10.4";
    47084716    constant Real x = 1.23456789;
     
    47154723        flatModel="
    47164724fclass EvaluationTests.StringConvert.StringConvertWithParam2
    4717  parameter String fmtSize = \"10.4\" /* \"10.4\" */;
     4725 structural parameter String fmtSize = \"10.4\" /* \"10.4\" */;
    47184726 constant Real x = 1.23456789;
    47194727 constant String s = \"1.2346E+00\";
     
    48834891
    48844892model StringRealformatSpecifier_d
    4885     constant Real x = 1.23456789;
     4893    constant Real x = 1234.56789;
    48864894    constant String s = String(x, format = "3d");
    48874895
    48884896annotation(__JModelica(UnitTesting(tests={
    4889       ErrorTestCase(
    4890             name="StringRealformatSpecifier_d",
    4891             description="String() operator, Real, format using d specifier",
    4892             errorMessage="
    4893 Error 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)
     4897    FlatteningTestCase(
     4898        name="StringRealformatSpecifier_d",
     4899        description="String() operator, Real, format using d specifier",
     4900        flatModel="
     4901fclass EvaluationTests.StringConvert.StringRealformatSpecifier_d
     4902 constant Real x = 1234.56789;
     4903 constant String s = \"1234\";
     4904end EvaluationTests.StringConvert.StringRealformatSpecifier_d;
    48964905")})));
    48974906end StringRealformatSpecifier_d;
     
    49144923
    49154924model StringRealformatSpecifier_i
    4916     constant Real x = 1.23456789;
     4925    constant Real x = 1234.56789;
    49174926    constant String s = String(x, format = "3i");
    49184927
    49194928annotation(__JModelica(UnitTesting(tests={
    4920     ErrorTestCase(
     4929    FlatteningTestCase(
    49214930        name="StringRealformatSpecifier_i",
    49224931        description="String() operator, Real, format using i specifier",
    4923         errorMessage="
    4924 Error 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)
     4932        flatModel="
     4933fclass EvaluationTests.StringConvert.StringRealformatSpecifier_i
     4934 constant Real x = 1234.56789;
     4935 constant String s = \"1234\";
     4936end EvaluationTests.StringConvert.StringRealformatSpecifier_i;
    49274937")})));
    49284938end StringRealformatSpecifier_i;
     
    49454955
    49464956model StringRealformatSpecifier_o
    4947     constant Real x = 1.23456789;
     4957    constant Real x = 1234.56789;
    49484958    constant String s = String(x, format = "3o");
    49494959
    49504960annotation(__JModelica(UnitTesting(tests={
    4951     ErrorTestCase(
     4961    FlatteningTestCase(
    49524962        name="StringRealformatSpecifier_o",
    49534963        description="String() operator, Real, format using o specifier",
    4954         errorMessage="
    4955 Error 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)
     4964        flatModel="
     4965fclass EvaluationTests.StringConvert.StringRealformatSpecifier_o
     4966 constant Real x = 1234.56789;
     4967 constant String s = \"2322\";
     4968end EvaluationTests.StringConvert.StringRealformatSpecifier_o;
    49584969")})));
    49594970end StringRealformatSpecifier_o;
     
    49764987
    49774988model StringRealformatSpecifier_x
    4978     constant Real x = 1.23456789;
     4989    constant Real x = 1234.56789;
    49794990    constant String s = String(x, format = "3x");
    49804991
    49814992annotation(__JModelica(UnitTesting(tests={
    4982     ErrorTestCase(
     4993    FlatteningTestCase(
    49834994        name="StringRealformatSpecifier_x",
    49844995        description="String() operator, Real, format using x specifier",
    4985         errorMessage="
    4986 Error 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)
     4996        flatModel="
     4997fclass EvaluationTests.StringConvert.StringRealformatSpecifier_x
     4998 constant Real x = 1234.56789;
     4999 constant String s = \"4d2\";
     5000end EvaluationTests.StringConvert.StringRealformatSpecifier_x;
    49895001")})));
    49905002end StringRealformatSpecifier_x;
     
    50075019
    50085020model StringRealformatSpecifier_X
    5009     constant Real x = 1.23456789;
     5021    constant Real x = 1234.56789;
    50105022    constant String s = String(x, format = "3X");
    50115023
    50125024annotation(__JModelica(UnitTesting(tests={
    5013     ErrorTestCase(
     5025    FlatteningTestCase(
    50145026        name="StringRealformatSpecifier_X",
    50155027        description="String() operator, Real, format using X specifier",
    5016         errorMessage="
    5017 Error 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)
     5028        flatModel="
     5029fclass EvaluationTests.StringConvert.StringRealformatSpecifier_X
     5030 constant Real x = 1234.56789;
     5031 constant String s = \"4D2\";
     5032end EvaluationTests.StringConvert.StringRealformatSpecifier_X;
    50205033")})));
    50215034end StringRealformatSpecifier_X;
     
    50385051
    50395052model StringRealformatSpecifier_u
    5040     constant Real x = 1.23456789;
     5053    constant Real x = -1234.56789;
    50415054    constant String s = String(x, format = "3u");
    50425055
    50435056annotation(__JModelica(UnitTesting(tests={
    5044     ErrorTestCase(
     5057    FlatteningTestCase(
    50455058        name="StringRealformatSpecifier_u",
    5046         description="String() operator, Real, format using u specifier",
    5047         errorMessage="
    5048 Error 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)
     5059        description="String() operator,  Real, format using u specifier",
     5060        flatModel="
     5061fclass EvaluationTests.StringConvert.StringRealformatSpecifier_u
     5062 constant Real x = -1234.56789;
     5063 constant String s = \"4294966061\";
     5064end EvaluationTests.StringConvert.StringRealformatSpecifier_u;
    50515065")})));
    50525066end StringRealformatSpecifier_u;
     
    50695083
    50705084model StringRealformatSpecifier_c
    5071     constant Real x = 1.23456789;
     5085    constant Real x = 123.456789;
    50725086    constant String s = String(x, format = "3c");
    50735087
    50745088annotation(__JModelica(UnitTesting(tests={
    5075     ErrorTestCase(
     5089    FlatteningTestCase(
    50765090        name="StringRealformatSpecifier_c",
    5077         description="String() operator, Real, format using c specifier",
    5078         errorMessage="
    5079 Error 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 
     5091        description="String() operator,  Real, format using c specifier",
     5092        flatModel="
     5093fclass EvaluationTests.StringConvert.StringRealformatSpecifier_c
     5094 constant Real x = 123.456789;
     5095 constant String s = \"  {\";
     5096end EvaluationTests.StringConvert.StringRealformatSpecifier_c;
     5097")})));
    50845098end StringRealformatSpecifier_c;
    50855099
     
    51005114end StringIntegerformatSpecifier_c;
    51015115
    5102 model StringIncorrectformat
    5103     constant Integer x = 1234;
    5104     constant String s = String(x, format = "*.1.3c");
     5116
     5117model StringConvertInvalidFormat1
     5118    parameter Real x = 1.23456789;
     5119    parameter String s = String(x, format = "1.2.3g");
    51055120
    51065121annotation(__JModelica(UnitTesting(tests={
    51075122    ErrorTestCase(
    5108         name="StringIncorrectformat",
    5109         description="String() operator, Real, format using c specifier",
     5123        name="StringConvert_StringConvertInvalidFormat1",
     5124        description="String() operator, Real, bad format string",
    51105125        errorMessage="
    5111 Error 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 ")})));
    5115 end StringIncorrectformat;
     5126Error at line 3, column 26, in file '...', INVALID_FORMAT_STRING:
     5127  Failed to parse format string \"1.2.3g\".
     5128")})));
     5129end StringConvertInvalidFormat1;
     5130
     5131
     5132model StringConvertInvalidFormat2
     5133    parameter Integer x = 1;
     5134    parameter String s = String(x, format = "ld");
     5135
     5136annotation(__JModelica(UnitTesting(tests={
     5137    ErrorTestCase(
     5138        name="StringConvert_StringConvertInvalidFormat2",
     5139        description="String() operator, Real, bad format string (different internal exception)",
     5140        errorMessage="
     5141Error at line 3, column 26, in file '...', INVALID_FORMAT_STRING:
     5142  Length modifiers are not allowed in format strings, but \"ld\" has length modifier \"l\".
     5143")})));
     5144end StringConvertInvalidFormat2;
    51165145
    51175146end StringConvert;
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/jastadd/ast/Modelica.ast

    r13600 r13943  
    277277SrcWhileStmt           : SrcStatement ::= Test:SrcExp SrcWhileStmt:SrcStatement*;
    278278
     279SrcFunctionCallList    ::= ConvertRules:SrcFunctionCall*;
     280
    279281SrcParExp    : SrcExp ::= SrcExp;
    280282SrcIfExp     : SrcExp ::= SrcIfExp:SrcExp ThenExp:SrcExp ElseExp:SrcExp;
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/jastadd/errorcheck/ComplianceCheck.jadd

    r11639 r13943  
    283283
    284284    public static final SimpleProblemProducer ASTNode.UNSUPPORTED_NON_FIXED_STRING_ARGUMENT =
    285             new SimpleErrorProducer("UNSUPPORTED_NON_FIXED_STRING_ARGUMENT", ProblemKind.COMPLIANCE, "%s with higher than parameter variability is not supported");
     285            new SimpleErrorProducer("UNSUPPORTED_NON_FIXED_STRING_ARGUMENT", ProblemKind.COMPLIANCE,
     286                    "Argument format of String operator is only supported as a fixed parameter expression.");
    286287
    287288    public void FStringExp.complianceCheck(ErrorCheckType checkType) {
    288289        super.complianceCheck(checkType);
    289         boolean func = inFunction();
    290         if (!func && hasMinimumLength()) {
    291             getMinimumLength().markAsStructuralParameter(checkType);
    292             if (!getMinimumLength().variability().parameterOrLess())
    293                 UNSUPPORTED_NON_FIXED_STRING_ARGUMENT.invoke(getMinimumLength(), "minimumLength");
    294         }
    295         if (!func && hasLeftJustified()) {
    296             getLeftJustified().markAsStructuralParameter(checkType);
    297            if (!getLeftJustified().variability().parameterOrLess())
    298                UNSUPPORTED_NON_FIXED_STRING_ARGUMENT.invoke(getLeftJustified(), "leftJustified");
    299         }
    300         if (!func && hasSignificantDigits()) {
    301             getSignificantDigits().markAsStructuralParameter(checkType);
    302             if (!getSignificantDigits().variability().parameterOrLess())
    303                 UNSUPPORTED_NON_FIXED_STRING_ARGUMENT.invoke(getSignificantDigits(), "significantDigits");
    304        }
     290        if (hasFormat()) {
     291            getFormat().markAsStructuralParameter(checkType);
     292            if (!getFormat().variability().parameterOrLess())
     293                UNSUPPORTED_NON_FIXED_STRING_ARGUMENT.invoke(getFormat());
     294        }
    305295    }
    306296
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/jastadd/errorcheck/ContentsCheck.jadd

    r13103 r13943  
    2222import org.jmodelica.common.URIResolver;
    2323import org.jmodelica.common.URIResolver.URIException;
     24import org.jmodelica.util.problemHandling.SimpleErrorOrWarningProducer;
    2425
    2526aspect ContentCheck {
     
    389390            if (!ch.variability().parameterOrLess()) {
    390391                NON_PARAMETER_SAMPLE_ARGUMENTS.invoke(ch);
     392            }
     393        }
     394    }
     395   
     396    public static final SimpleErrorOrWarningProducer ASTNode.INVALID_FORMAT_STRING =
     397            new SimpleErrorOrWarningProducer("INVALID_FORMAT_STRING", ProblemKind.SEMANTIC, "%s");
     398
     399    public void FStringExp.contentCheck(ErrorCheckType checkType) {
     400        if (hasFormat()) {
     401            try {
     402                CFormatSpecifier format = formatSpecifier();
     403                if (format.hasProblem()) {
     404                    INVALID_FORMAT_STRING.invoke(this, format.hasError(), format.errorMessage());
     405                }
     406            } catch (ConstantEvaluationException e) {
     407                // If we can't evaluate it, don't do a static error check of it.
    391408            }
    392409        }
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/jastadd/source/Parser.jrag

    r13600 r13943  
    181181    }
    182182
     183    public short ParserHandler.functionCallListGoal() {
     184        return org.jmodelica.modelica.parser.ModelicaParser.AltGoals.function_call_list;
     185    }
     186
    183187    public SourceRoot ParserHandler.parseFile(UtilInterface uif, LoadInfo loadInfo)
    184188            throws ParserException, beaver.Parser.Exception, FileNotFoundException, IOException {
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalFunctionExecutableGenerated.java

    r13800 r13943  
    1717    @Override
    1818    public void remove() {
    19         new File(executable).delete();
     19        File file = new File(executable);
     20        boolean success = file.delete();
     21        // The first attempt to delete may fail if the process has not terminated yet.
     22        // Possibly not necessary since LiveExternalFunction.destroyProcess() now calls ProcessCommunicator.teardown().
     23        if (!success) {
     24            try {
     25                Thread.sleep(10); // Sleep some arbitrary duration to give the process time to die.
     26            } catch (InterruptedException e) {
     27                // Ignore
     28            }
     29            success = file.delete();
     30        }
    2031    }
    2132}
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ExternalFunctionImpl.java

    r13800 r13943  
    4545            setup(ext, values, timeout, com);
    4646            evaluate(ext, values, timeout, com);
    47             return teardown(timeout, com);
     47            return com.teardown(timeout);
    4848        } finally {
    4949            if (com != null) {
     
    7979        com.accept("READY");
    8080        com.cancelTimer();
    81     }
    82 
    83     public int teardown(int timeout, ProcessCommunicator<V, T> com) throws IOException {
    84         com.startTimer(timeout);
    85         com.check("EXIT");
    86         com.accept("END");
    87         int result = com.end();
    88         com.cancelTimer();
    89         // log().debug("SUCCESS TEARDOWN");
    90         return result;
    9181    }
    9282
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/LiveExternalFunction.java

    r13800 r13943  
    4646            compiler.log().debug("Finished evaluating live external function, time: " + time + "ms");
    4747        } catch (ProcessCommunicator.AbortConstantEvaluationException e) {
    48 
     48            // TODO What does this mean?
    4949        } catch (ConstantEvaluationException e) {
    5050            destroyProcess();
     
    8989        if (com != null) {
    9090            livingCachedExternals.remove(this);
    91             com.destroy();
     91            try {
     92                com.teardown(100); // TODO Should we check the return value?
     93            } catch (IOException e) {
     94                // TODO Do we need to do anything here?
     95            }
     96            com.destroy(); // TODO Do we still need to call destroy() if teardown is successful?
    9297            com = null;
    9398        }
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/evaluation/ProcessCommunicator.java

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

    r9003 r13943  
    66/**
    77 * If you have a error message which only consists of a string and format
    8  * arguments, then this is the right class for you. Simple create a static
     8 * arguments, then this is the right class for you. Simply create a static
    99 * final field instantiating this class and then invoke the error as needed!
    1010 */
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/problemHandling/SimpleWarningProducer.java

    r9003 r13943  
    55
    66/**
    7  * Convenient class which takes a string message on construction, an
     7 * Convenience class which takes a string message on construction, an
    88 * optional list of format arguments when invoked and produces a warning.
    99 */
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/values/ConstantEvaluationException.java

    r9590 r13943  
    1414    public ConstantEvaluationException() {
    1515        super("Unspecified constant evaluation failure");
     16        this.val = null;
     17    }
     18
     19    public ConstantEvaluationException(String msg) {
     20        super(msg);
     21        this.val = null;
     22    }
     23
     24    public ConstantEvaluationException(String msg, Throwable cause) {
     25        super(msg, cause);
    1626        this.val = null;
    1727    }
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/parser/Modelica.parser

    r13600 r13943  
    2323%goal access_scalar;
    2424%goal subscript;
     25%goal function_call_list;
    2526
    2627%header {:
     
    4142
    4243%embed {:
    43 
    4444    /**
    4545     * Error reporting class that creates an error message and delegates reporting the
     
    17001700    :}
    17011701    ;
     1702
     1703//Extension
     1704List function_calls_stmt =
     1705    function_call SEMICOLON                   {: return new List().add(function_call); :}
     1706  | function_calls_stmt function_call SEMICOLON    {: return function_calls_stmt.add(function_call); :}
     1707  ;
     1708
     1709List function_calls_vector =
     1710    function_call                              {: return new List().add(function_call); :}
     1711  | function_calls_vector COMMA function_call  {: return function_calls_vector.add(function_call); :}
     1712  ;
     1713
     1714SrcFunctionCallList function_call_list
     1715    = LBRACE function_calls_vector RBRACE
     1716    {:
     1717        return new SrcFunctionCallList(function_calls_vector);
     1718    :}
     1719    | function_calls_stmt
     1720    {:
     1721        return new SrcFunctionCallList(function_calls_stmt);
     1722    :}
     1723    ;
  • branches/dev-5819/Compiler/ModelicaFrontEnd/src/parser/Modelica_header.beaver

    r5961 r13943  
    2323%left MULT, DIV;
    2424%left PLUS, MINUS;
    25 
  • branches/dev-5819/Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo

    r11639 r13943  
    527527
    528528model StringOperator1
     529    function f
     530        input Real x;
     531        input String f;
     532        output String o;
     533    algorithm
     534        o := String(x, format=f);
     535    end f;
     536   
    529537    Integer len = if time < 0 then 4 else 3;
    530538    Integer digits = if time < 0 then 5 else 2;
     539    String s1 = String(time, format = fmt1);
     540    String s2 = String(time, format = fmt2);
     541    String s3 = f(time, "g");
     542    parameter String fmt1 = if selFmt1 == 1 then "u" else "g";
     543    parameter String fmt2 = "f";
     544    parameter Integer selFmt1(fixed = false);
     545initial equation
     546    selFmt1 = if len == 4 then 1 else 2;
    531547equation
    532548    assert(time>2.0, String(time, significantDigits=digits, minimumLength=len, leftJustified=time<1));
    533     annotation(__JModelica(UnitTesting(tests={
    534         ComplianceErrorTestCase(
    535             name="StringOperator1",
    536             description="Test compliance warnings for non fixed string operator arguments (significantDigits, minimumLength, leftJustified)",
    537             errorMessage="
    538 3 errors found:
    539 
    540 Compliance error at line 5, column 53, in file 'Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo', UNSUPPORTED_NON_FIXED_STRING_ARGUMENT:
    541   significantDigits with higher than parameter variability is not supported
    542 
    543 Compliance error at line 5, column 75, in file 'Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo', UNSUPPORTED_NON_FIXED_STRING_ARGUMENT:
    544   minimumLength with higher than parameter variability is not supported
    545 
    546 Compliance error at line 5, column 94, in file 'Compiler/ModelicaFrontEnd/test/modelica/ComplianceTests.mo', UNSUPPORTED_NON_FIXED_STRING_ARGUMENT:
    547   leftJustified with higher than parameter variability is not supported
     549    assert(time>2.0, String(time, format=String(len)+"."+String(digits)+"f"));
     550annotation(__JModelica(UnitTesting(tests={
     551    ComplianceErrorTestCase(
     552        name="StringOperator1",
     553        description="Test compliance warnings for non fixed string operator format argument",
     554        errorMessage="
     555
     556
     557Compliance error at line 7, column 31, in file '...', UNSUPPORTED_NON_FIXED_STRING_ARGUMENT:
     558  Argument format of String operator is only supported as a fixed parameter expression.
     559
     560Compliance error at line 15, column 5, in file '...':
     561  Parameters with fixed=false can not be used as structural parameters
     562
     563Compliance error at line 22, column 42, in file '...', UNSUPPORTED_NON_FIXED_STRING_ARGUMENT:
     564  Argument format of String operator is only supported as a fixed parameter expression.
    548565")})));
    549566end StringOperator1;
    550567
     568
     569model StringOperator2
     570    String s = String(time, format="%f");
     571
     572annotation(__JModelica(UnitTesting(tests={
     573    WarningTestCase(
     574        name="StringOperator2",
     575        description="Test warning for supplying the initial % of format specifier",
     576        errorMessage="
     577
     578
     579Warning at line 2, column 16, in file '...', INVALID_FORMAT_STRING:
     580  The format string argument should not include the initial '%': \"%f\".
     581")})));
     582end StringOperator2;
    551583
    552584
  • branches/dev-5819/Compiler/ModelicaMiddleEnd/src/jastadd/optimizations/VariabilityPropagation.jrag

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

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

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

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

    r13600 r13943  
    6868        return org.jmodelica.optimica.parser.ModelicaParser.AltGoals.subscript;
    6969    }
     70   
     71    refine Parsers public short ParserHandler.functionCallListGoal() {
     72        return org.jmodelica.optimica.parser.ModelicaParser.AltGoals.function_call_list;
     73    }
     74
    7075
    7176    public beaver.Parser ParserHandler.createOptimicaParser(AbstractModelicaScanner<ASTNode<?>> scanner, LoadInfo loadInfo) {
  • branches/dev-5819/Python/src/tests_jmodelica/files/Modelica/ExtFunctionTests.mo

    r13800 r13943  
    11851185end MultiUse1;
    11861186
     1187model GlobalExtFunctionDestruction
     1188    package P
     1189    record R1
     1190        R2 r2;
     1191    end R1;
     1192    record R2
     1193        Real x;
     1194    end R2;
     1195   
     1196    model EO
     1197        extends ExternalObject;
     1198        function constructor
     1199            input R1 r1;
     1200            output EO eo;
     1201            external "C" eo=eo_constructor_record(r1) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
     1202        end constructor;
     1203        function destructor
     1204            input EO eo;
     1205            external "C" eo_destructor_record(eo) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
     1206        end destructor;
     1207    end EO;
     1208   
     1209    function f
     1210        input EO eo;
     1211        output Real y;
     1212        external "C" y=eo_use_record(eo) annotation(Library="extObjects", Include="#include \"extObjects.h\"");
     1213    end f;
     1214   
     1215    constant EO eo = EO(R1(R2(3)));
     1216    end P;
     1217   
     1218    function f
     1219        input Real x;
     1220        output Real y = x + P.f(P.eo);
     1221    algorithm
     1222    end f;
     1223
     1224    Real y = f(time);
     1225end GlobalExtFunctionDestruction;
     1226
    11871227end ExtFunctionTests;
  • branches/dev-5819/Python/src/tests_jmodelica/general/test_extfunctions.py

    r13800 r13943  
    312312    def setUpClass(cls):
    313313        SimulationTest.setup_class_base('ExtFunctionTests.mo',
     314            'ExtFunctionTests.GlobalExtFunctionDestruction')
     315
     316    @testattr(stddist_full = True)
     317    def setUp(self):
     318        self.setup_base(start_time=0.0, final_time=0.1, time_step=0.01)
     319        self.run()
     320
     321    @testattr(stddist_full = True)
     322    def test_result(self):
     323        pass #We test that there is no segfault when destroying the FMU object
     324
     325class TestGlobalExternalRecordObj(SimulationTest):
     326    @classmethod
     327    def setUpClass(cls):
     328        SimulationTest.setup_class_base('ExtFunctionTests.mo',
    314329            'ExtFunctionTests.ExtFunctionRecordObj')
    315330
  • branches/dev-5819/RuntimeLibrary/src

  • branches/dev-5819/RuntimeLibrary/src/jmi/jmi.c

    r12796 r13943  
    607607
    608608int jmi_destruct_external_objects(jmi_t* jmi) {
    609     return jmi_generic_func(jmi, jmi_destruct_external_objs);
     609    return jmi_generic_func(jmi, model_destruct_external_objects);
    610610}
    611611
  • branches/dev-5819/RuntimeLibrary/src/jmi/jmi.h

    r11759 r13943  
    512512 * @return Error code.
    513513 */
    514 int jmi_destruct_external_objs(jmi_t* jmi);
     514int model_destruct_external_objects(jmi_t* jmi);
    515515
    516516/**
Note: See TracChangeset for help on using the changeset viewer.