Changeset 13433

Timestamp:

Sep 9, 2019 8:27:35 PM (3 months ago)

Author:

amartensen

Message:

merged to stable

Location:

branches/stable

Files:

• . (modified) (1 prop)
• Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag (modified) (3 diffs)
• Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag (modified) (4 diffs)
• Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag (modified) (3 diffs)
• Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo (modified) (1 diff)
• Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/TestAnnotationizer.java (modified) (4 diffs)
• Compiler/ModelicaFrontEnd/test/modelica/OperatorRecordTests.mo (modified) (3 diffs)

branches/stable/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

@@ -890 +890 @@
                     p.print(getSignificantDigits(), str, indent);
                 } else {
-                    str.print(significantDigits());
+                    str.print(DEFAULT_PRECISION);
                 }
             }
@@ -973 +973 @@
                     p.print(getSignificantDigits(), str, indent);
                 } else {
-                    str.print(significantDigits());
+                    str.print(DEFAULT_PRECISION);
                 }
             }
@@ -1073 +1073 @@
     syn lazy int FStringAddExp.maxStringLength_C() = Math.min(getLeft().maxStringLength_C() + getRight().maxStringLength_C(), MAX_STRING_LENGTH_C);
     eq FStringLitExp.maxStringLength_C()           = stringUtf8().length;
-    eq FStringExp.maxStringLength_C()              =
-            hasFormat() ? type().maxNumericStringLength_C(significantDigits()) :
-            Math.max(getValue().type().maxStringLength_C(significantDigits()), minimumLength());
+    eq FStringExp.maxStringLength_C() {
+        // TODO: if there is a format arg, there is no significantDigits
+        // TODO: handle case where arguments are variables (use MAX_STRING_LENGTH_C?)
+        VariableEvaluator ev = defaultVariableEvaluator();
+        if (hasFormat()) {
+            return type().maxNumericStringLength_C(significantDigits(ev));
+        } else {
+            return Math.max(getValue().type().maxStringLength_C(significantDigits(ev)), minimumLength(ev));
+        }
+    }
     
     /**

branches/stable/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

@@ -1669 +1669 @@
 
         @Override
+        public String objectValue() {
+            return value;
+        }
+
+        @Override
         public String toString() {
             return type.getName() + "." + value;
@@ -2784 +2789 @@
     eq FEnumIntegerExp.cevalCalc(VariableEvaluator evaluator) = getFExp().ceval(evaluator).convertInteger();
     eq FStringExp.cevalCalc(VariableEvaluator evaluator) {
-        Object value;
-        if (getValue().type().isReal())
-          value = getValue().ceval(evaluator).realValue();
-        else if (getValue().type().isInteger())
-          value = getValue().ceval(evaluator).intValue();
-        else if (getValue().type().isBoolean() || getValue().type().isEnum())
-          value = getValue().ceval(evaluator).stringExpValue();
-        else
-          return CValue.UNKNOWN;
-        return new CValueString(String.format((Locale) null, formatString(), value));
+        if (getValue().isArray() || !getValue().type().isPrimitive()) {
+            return CValue.UNKNOWN;
+        }
+        CValue cval = getValue().ceval(evaluator);
+        if (getValue().type().isReal()) {
+            cval = cval.convertReal();
+        }
+        Object value = cval.objectValue();
+        String format = formatString(evaluator);
+        return new CValueString(String.format((Locale) null, format, value));
     }
     eq FGetInstanceName.cevalCalc(VariableEvaluator evaluator) = new CValueString(calcInstanceName());
@@ -2805 +2810 @@
     }
 
-    // TODO: support format args
-    syn String FStringExp.formatString() = "%" + formatFlags() + formatWidth() + formatPrecision() + formatSpecifier();
-
-    syn String FStringExp.formatWidth()     = minimumLength() > 0 ? String.valueOf(minimumLength()) : "";
-    syn String FStringExp.formatFlags()     = leftJustified() && minimumLength() > 0 ? "-" : "";
-    syn String FStringExp.formatPrecision() = getValue().type().isReal() ? "." + significantDigits() : "";
-    syn String FStringExp.formatSpecifier() = getValue().type().formatSpecifier();
-    syn int FStringExp.minimumLength()     = hasMinimumLength() ? getMinimumLength().ceval().intValue() : 0;
-    syn boolean FStringExp.leftJustified() = hasLeftJustified() ? getLeftJustified().ceval().booleanValue() : true;
-    syn int FStringExp.significantDigits() = hasSignificantDigits() ? getSignificantDigits().ceval().intValue() : DEFAULT_PRECISION;
+    syn String FStringExp.formatString(VariableEvaluator evaluator) {
+        StringBuilder buf = new StringBuilder("%");
+        if (hasFormat()) {
+            buf.append(getFormat().ceval(evaluator).stringValue());
+        } else {
+            int minLength = minimumLength(evaluator);
+            if (minLength > 0) {
+                if (leftJustified(evaluator)) {
+                    buf.append('-');
+                }
+                buf.append(minLength);
+            }
+            if (getValue().type().isReal()) {
+                buf.append('.');
+                buf.append(significantDigits(evaluator));
+            }
+            buf.append(getValue().type().formatSpecifier());
+        }
+        return buf.toString();
+    }
+
+    syn int FStringExp.minimumLength(VariableEvaluator evaluator)     = 
+        hasMinimumLength() ? getMinimumLength().ceval(evaluator).intValue() : 0;
+    syn boolean FStringExp.leftJustified(VariableEvaluator evaluator) = 
+        hasLeftJustified() ? getLeftJustified().ceval(evaluator).booleanValue() : true;
+    syn int FStringExp.significantDigits(VariableEvaluator evaluator) = 
+        hasSignificantDigits() ? getSignificantDigits().ceval(evaluator).intValue() : DEFAULT_PRECISION;
     syn String FType.formatSpecifier() {
         throw new UnsupportedOperationException();
@@ -2822 +2844 @@
     eq FBooleanType.formatSpecifier() = "s";
     eq FEnumType.formatSpecifier()    = "s";
+    eq FStringType.formatSpecifier()  = "s";
     public static final int FStringExp.DEFAULT_PRECISION = 6;
 

branches/stable/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

@@ -52 +52 @@
         public boolean isFunction();
         public boolean isExternalObject();
+        public boolean isPrimitiveType();
     }
     
@@ -157 +158 @@
         };
         
-        public boolean isBoolean() { return scalarType().isBoolean(); }
-        public boolean isInteger() { return scalarType().isInteger(); }
-        public boolean isReal() { return scalarType().isReal(); }
-        public boolean isNumeric() { return scalarType().isNumeric(); }
-        public boolean isString() { return scalarType().isString(); }
-        public boolean isEnum() { return scalarType().isEnum(); }
-        public boolean isRecord() { return scalarType().isRecord(); }
-        public boolean isFunction() { return scalarType().isFunction(); }
+        public boolean isBoolean()        { return scalarType().isBoolean();        }
+        public boolean isInteger()        { return scalarType().isInteger();        }
+        public boolean isReal()           { return scalarType().isReal();           }
+        public boolean isNumeric()        { return scalarType().isNumeric();        }
+        public boolean isString()         { return scalarType().isString();         }
+        public boolean isEnum()           { return scalarType().isEnum();           }
+        public boolean isRecord()         { return scalarType().isRecord();         }
+        public boolean isFunction()       { return scalarType().isFunction();       }
         public boolean isExternalObject() { return scalarType().isExternalObject(); }
+        public boolean isPrimitiveType()  { return scalarType().isPrimitiveType();  }
     }
 
@@ -1257 +1259 @@
     syn boolean FType.isFunction()              = false;
     eq FFunctionType.isFunction()               = true;
+    syn boolean FType.isPrimitiveType()         = false;
+    eq FRealType   .isPrimitiveType()           = true;
+    eq FIntegerType.isPrimitiveType()           = true;
+    eq FBooleanType.isPrimitiveType()           = true;
+    eq FStringType .isPrimitiveType()           = true;
+    eq FEnumType   .isPrimitiveType()           = true;
 
     syn boolean FType.isArray()  = getSize() != Size.SCALAR;

branches/stable/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

@@ -4357 +4357 @@
 end EvaluatePartialFunction1;
 
+
+package StringConvert "Test String conversion operator"
+
+model StringConvertReal1
+    constant Real x = 1.23456789;
+    constant String s = String(x);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal1",
+        description="String() operator, Real, no options",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal1
+ constant Real x = 1.23456789;
+ constant String s = \"1.23457\";
+end EvaluationTests.StringConvert.StringConvertReal1;
+")})));
+end StringConvertReal1;
+
+
+model StringConvertReal2
+    constant Real x = 1.23456789;
+    constant String s = String(x, minimumLength = 10);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal2",
+        description="String() operator, Real, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal2
+ constant Real x = 1.23456789;
+ constant String s = \"1.23457   \";
+end EvaluationTests.StringConvert.StringConvertReal2;
+")})));
+end StringConvertReal2;
+
+
+model StringConvertReal3
+    constant Real x = 1.23456789;
+    constant String s = String(x, minimumLength = 2);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal3",
+        description="String() operator, Real, minimumLength < needed length",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal3
+ constant Real x = 1.23456789;
+ constant String s = \"1.23457\";
+end EvaluationTests.StringConvert.StringConvertReal3;
+")})));
+end StringConvertReal3;
+
+
+model StringConvertReal4
+    constant Real x = 1.23456789;
+    constant String s = String(x, leftJustified = false);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal4",
+        description="String() operator, Real, leftJustified",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal4
+ constant Real x = 1.23456789;
+ constant String s = \"1.23457\";
+end EvaluationTests.StringConvert.StringConvertReal4;
+")})));
+end StringConvertReal4;
+
+
+model StringConvertReal5
+    constant Real x = 1.23456789;
+    constant String s = String(x, leftJustified = false, minimumLength = 10);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal5",
+        description="String() operator, Real, leftJustified, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal5
+ constant Real x = 1.23456789;
+ constant String s = \"   1.23457\";
+end EvaluationTests.StringConvert.StringConvertReal5;
+")})));
+end StringConvertReal5;
+
+
+model StringConvertReal6
+    constant Real x = 1.23456789;
+    constant String s = String(x, significantDigits = 4);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal6",
+        description="String() operator, Real, significantDigits",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal6
+ constant Real x = 1.23456789;
+ constant String s = \"1.235\";
+end EvaluationTests.StringConvert.StringConvertReal6;
+")})));
+end StringConvertReal6;
+
+
+model StringConvertReal7
+    constant Real x = 1.23456789;
+    constant String s = String(x, significantDigits = 4, leftJustified = false, minimumLength = 8);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal7",
+        description="String() operator, Real, significantDigits, leftJustified, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal7
+ constant Real x = 1.23456789;
+ constant String s = \"   1.235\";
+end EvaluationTests.StringConvert.StringConvertReal7;
+")})));
+end StringConvertReal7;
+
+
+model StringConvertReal8
+    constant Real x = 1.23456789;
+    constant String s = String(x, format = "10.4E");
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertReal8",
+        description="String() operator, Real, format",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertReal8
+ constant Real x = 1.23456789;
+ constant String s = \"1.2346E+00\";
+end EvaluationTests.StringConvert.StringConvertReal8;
+")})));
+end StringConvertReal8;
+
+
+model StringConvertInteger1
+    constant Integer x = 12;
+    constant String s = String(x);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertInteger1",
+        description="String() operator, Integer, no options",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertInteger1
+ constant Integer x = 12;
+ constant String s = \"12\";
+end EvaluationTests.StringConvert.StringConvertInteger1;
+")})));
+end StringConvertInteger1;
+
+
+model StringConvertInteger2
+    constant Integer x = 12;
+    constant String s = String(x, minimumLength = 3);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertInteger2",
+        description="String() operator, Integer, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertInteger2
+ constant Integer x = 12;
+ constant String s = \"12 \";
+end EvaluationTests.StringConvert.StringConvertInteger2;
+")})));
+end StringConvertInteger2;
+
+
+model StringConvertInteger3
+    constant Integer x = 12;
+    constant String s = String(x, leftJustified = false, minimumLength = 3);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertInteger3",
+        description="String() operator, Integer, leftJustified, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertInteger3
+ constant Integer x = 12;
+ constant String s = \" 12\";
+end EvaluationTests.StringConvert.StringConvertInteger3;
+")})));
+end StringConvertInteger3;
+
+
+model StringConvertBoolean1
+    constant Boolean x = true;
+    constant String s = String(x);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertBoolean1",
+        description="String() operator, Boolean true, no options",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertBoolean1
+ constant Boolean x = true;
+ constant String s = \"true\";
+end EvaluationTests.StringConvert.StringConvertBoolean1;
+")})));
+end StringConvertBoolean1;
+
+
+model StringConvertBoolean2
+    constant Boolean x = false;
+    constant String s = String(x);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertBoolean2",
+        description="String() operator, Boolean false, no options",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertBoolean2
+ constant Boolean x = false;
+ constant String s = \"false\";
+end EvaluationTests.StringConvert.StringConvertBoolean2;
+")})));
+end StringConvertBoolean2;
+
+
+model StringConvertBoolean3
+    constant Boolean x = true;
+    constant String s = String(x, minimumLength = 5);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertBoolean3",
+        description="String() operator, Boolean, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertBoolean3
+ constant Boolean x = true;
+ constant String s = \"true \";
+end EvaluationTests.StringConvert.StringConvertBoolean3;
+")})));
+end StringConvertBoolean3;
+
+
+model StringConvertBoolean4
+    constant Boolean x = true;
+    constant String s = String(x, leftJustified = false, minimumLength = 5);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertBoolean4",
+        description="String() operator, Boolean, leftJustified, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertBoolean4
+ constant Boolean x = true;
+ constant String s = \" true\";
+end EvaluationTests.StringConvert.StringConvertBoolean4;
+")})));
+end StringConvertBoolean4;
+
+
+model StringConvertEnumeration1
+    type E = enumeration(Alpha, Beta, Gamma);
+    constant E x = E.Beta;
+    constant String s = String(x);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertEnumeration1",
+        description="String() operator, Enumeration, no options",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertEnumeration1
+ constant EvaluationTests.StringConvert.StringConvertEnumeration1.E x = EvaluationTests.StringConvert.StringConvertEnumeration1.E.Beta;
+ constant String s = \"Beta\";
+
+public
+ type EvaluationTests.StringConvert.StringConvertEnumeration1.E = enumeration(Alpha, Beta, Gamma);
+
+end EvaluationTests.StringConvert.StringConvertEnumeration1;
+")})));
+end StringConvertEnumeration1;
+
+
+model StringConvertEnumeration2
+    type E = enumeration(Alpha, Beta, Gamma);
+    constant E x = E.Beta;
+    constant String s = String(x, minimumLength = 5);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertEnumeration2",
+        description="String() operator, Enumeration, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertEnumeration2
+ constant EvaluationTests.StringConvert.StringConvertEnumeration2.E x = EvaluationTests.StringConvert.StringConvertEnumeration2.E.Beta;
+ constant String s = \"Beta \";
+
+public
+ type EvaluationTests.StringConvert.StringConvertEnumeration2.E = enumeration(Alpha, Beta, Gamma);
+
+end EvaluationTests.StringConvert.StringConvertEnumeration2;
+")})));
+end StringConvertEnumeration2;
+
+
+model StringConvertEnumeration3
+    type E = enumeration(Alpha, Beta, Gamma);
+    constant E x = E.Beta;
+    constant String s = String(x, leftJustified = false, minimumLength = 5);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertEnumeration3",
+        description="String() operator, Enumeration, leftJustified, minimumLength",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertEnumeration3
+ constant EvaluationTests.StringConvert.StringConvertEnumeration3.E x = EvaluationTests.StringConvert.StringConvertEnumeration3.E.Beta;
+ constant String s = \" Beta\";
+
+public
+ type EvaluationTests.StringConvert.StringConvertEnumeration3.E = enumeration(Alpha, Beta, Gamma);
+
+end EvaluationTests.StringConvert.StringConvertEnumeration3;
+")})));
+end StringConvertEnumeration3;
+
+
+model StringConvertWithParam1
+    parameter Integer len = 8;
+    parameter Boolean left = false;
+    parameter Integer dig = 4;
+    constant Real x = 1.23456789;
+    constant String s = String(x, significantDigits = dig - 1, leftJustified = left, minimumLength = len - 1);
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertWithParam1",
+        description="String() operator, Real, all options given as parameter expressions",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertWithParam1
+ structural parameter Integer len = 8 /* 8 */;
+ structural parameter Boolean left = false /* false */;
+ structural parameter Integer dig = 4 /* 4 */;
+ constant Real x = 1.23456789;
+ constant String s = \"   1.23\";
+end EvaluationTests.StringConvert.StringConvertWithParam1;
+")})));
+end StringConvertWithParam1;
+
+
+model StringConvertWithParam2
+    parameter String fmtSize = "10.4";
+    constant Real x = 1.23456789;
+    constant String s = String(x, format = fmtSize + "E");
+
+annotation(__JModelica(UnitTesting(tests={
+    FlatteningTestCase(
+        name="StringConvert_StringConvertWithParam2",
+        description="String() operator, Real, format given as parameter expressions",
+        flatModel="
+fclass EvaluationTests.StringConvert.StringConvertWithParam2
+ parameter String fmtSize = \"10.4\" /* \"10.4\" */;
+ constant Real x = 1.23456789;
+ constant String s = \"1.2346E+00\";
+end EvaluationTests.StringConvert.StringConvertWithParam2;
+")})));
+end StringConvertWithParam2;
+
+end StringConvert;
+
 end EvaluationTests;

branches/stable/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/TestAnnotationizer.java

@@ -139 +139 @@
         
         if (filePath == null && !hasInputFilePath) {
-            System.err.println("No input file specified. give path as argument or use -file");
+            System.err.println("No input file specified. give path as argument or use -f");
         }
 
         if (all_models && hasInputFilePath) {
-            System.err.println("Cannot use -a and -file at the same time");
+            System.err.println("Cannot use -a and -f at the same time");
         }
         
@@ -157 +157 @@
             cont = inputFileScanner.hasNextLine();
         }
+        @SuppressWarnings("resource")
+        BufferedReader in = cont ? new BufferedReader(new InputStreamReader(System.in)) : null;
+        String packageName = getPackageName(filePath);
         while (cont) {
-            BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
-            if(hasInputFilePath) {
+            if (hasInputFilePath) {
                 String line = inputFileScanner.nextLine();
                 String[] parts = line.split(",");
                 filePath = parts[0];
-                modelName = parts[1];
-            }
-            String packageName = null;
-            if(!(all_models || hasInputFilePath)) {
                 packageName = getPackageName(filePath);
-                modelName = composeModelName(packageName, modelName);
-            } else if (hasInputFilePath) {
-                packageName = getPackageName(filePath);
-                modelName = packageName + "." + modelName;
-            }
-            if (all_models) {
+                modelName = packageName + "." + parts[1];
+            } else if (all_models) {
                 modelName = allModelsIterator.next();
-            } else if (!modelName.contains(".")) {
+            } else if (modelName == null) {
                 System.out.print("Enter class name: ");
                 System.out.flush();
@@ -183 +177 @@
                     System.exit(0);
                 }
-                modelName = composeModelName(modelName, given);
+                modelName = composeModelName(packageName, given);
             }
             
@@ -205 +199 @@
             
             if (repeat) {
-                modelName = packageName;
+                modelName = null;
             } else if (all_models) {
                 cont = allModelsIterator.hasNext();

branches/stable/Compiler/ModelicaFrontEnd/test/modelica/OperatorRecordTests.mo

@@ -708 +708 @@
 ")})));
     end OperatorOverload13;
-
-
-    model OperatorOverload14
-        operator record Cplx2 = Cplx;
-        Cplx c1 = Cplx(1, 2);
-        Cplx2 c2 = Cplx2(3, 4);
-        Cplx c3 = c1 + c2;
-
-    annotation(__JModelica(UnitTesting(tests={
-        FlatteningTestCase(
-            name="OperatorOverload14",
-            description="Short class decls of operator records",
-            flatModel="
-fclass OperatorRecordTests.OperatorOverload14
- OperatorRecordTests.Cplx c1 = OperatorRecordTests.Cplx.'constructor'(1, 2);
- OperatorRecordTests.OperatorOverload14.Cplx2 c2 = OperatorRecordTests.Cplx.'constructor'(3, 4);
- OperatorRecordTests.Cplx c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
-
-public
- function OperatorRecordTests.Cplx.'constructor'
-  input Real re;
-  input Real im;
-  output OperatorRecordTests.Cplx c;
- algorithm
-  c.re := re;
-  c.im := im;
-  return;
- end OperatorRecordTests.Cplx.'constructor';
-
- function OperatorRecordTests.Cplx.'+'
-  input OperatorRecordTests.Cplx a;
-  input OperatorRecordTests.Cplx b;
-  output OperatorRecordTests.Cplx c;
- algorithm
-  (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
-  return;
- end OperatorRecordTests.Cplx.'+';
-
- record OperatorRecordTests.Cplx
-  Real re;
-  Real im;
- end OperatorRecordTests.Cplx;
-
- record OperatorRecordTests.OperatorOverload14.Cplx2
-  Real re;
-  Real im;
- end OperatorRecordTests.OperatorOverload14.Cplx2;
-
-end OperatorRecordTests.OperatorOverload14;
-")})));
-    end OperatorOverload14;
 
 
@@ -1642 +1591 @@
 
 
-    model OperatorRecordConnect3
-        connector C = Cplx;
-
-        C c1, c2, c3;
-    equation
-        connect(c1, c2);
-        c3 = c1 + c2;
-
-    annotation(__JModelica(UnitTesting(tests={
-        FlatteningTestCase(
-            name="OperatorRecordConnect3",
-            description="Connectors that are operator records",
-            flatModel="
-fclass OperatorRecordTests.OperatorRecordConnect3
- OperatorRecordTests.OperatorRecordConnect3.C c1;
- OperatorRecordTests.OperatorRecordConnect3.C c2;
- OperatorRecordTests.OperatorRecordConnect3.C c3;
-equation
- c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
- c1 = c2;
-
-public
- function OperatorRecordTests.Cplx.'+'
-  input OperatorRecordTests.Cplx a;
-  input OperatorRecordTests.Cplx b;
-  output OperatorRecordTests.Cplx c;
- algorithm
-  (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
-  return;
- end OperatorRecordTests.Cplx.'+';
-
- function OperatorRecordTests.Cplx.'constructor'
-  input Real re;
-  input Real im;
-  output OperatorRecordTests.Cplx c;
- algorithm
-  c.re := re;
-  c.im := im;
-  return;
- end OperatorRecordTests.Cplx.'constructor';
-
- record OperatorRecordTests.OperatorRecordConnect3.C
-  Real re;
-  Real im;
- end OperatorRecordTests.OperatorRecordConnect3.C;
-
- record OperatorRecordTests.Cplx
-  Real re;
-  Real im;
- end OperatorRecordTests.Cplx;
-
-end OperatorRecordTests.OperatorRecordConnect3;
-")})));
-    end OperatorRecordConnect3;
-
 
     model OperatorRecordConnect4
@@ -1742 +1636 @@
     end OperatorRecordConnect4;
 
-
-    model OperatorRecordConnect5
-        connector C = Cplx;
-        
-        model A
-            C c;
-        end A;
-        
-        A a[2];
-        C c[2];
-    equation
-        connect(a.c, c);
-
-    annotation(__JModelica(UnitTesting(tests={
-        FlatteningTestCase(
-            name="OperatorRecordConnect5",
-            description="Test connecting to array of operator record",
-            flatModel="
-fclass OperatorRecordTests.OperatorRecordConnect5
- OperatorRecordTests.OperatorRecordConnect5.C a[1].c;
- OperatorRecordTests.OperatorRecordConnect5.C a[2].c;
- OperatorRecordTests.OperatorRecordConnect5.C c[2];
-equation
- a[1].c = c[1];
- a[2].c = c[2];
-
-public
- record OperatorRecordTests.OperatorRecordConnect5.C
-  Real re;
-  Real im;
- end OperatorRecordTests.OperatorRecordConnect5.C;
-
-end OperatorRecordTests.OperatorRecordConnect5;
-")})));
-    end OperatorRecordConnect5;