Changeset 13433


Ignore:
Timestamp:
Sep 9, 2019 8:27:35 PM (3 months ago)
Author:
amartensen
Message:

merged to stable

Location:
branches/stable
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • branches/stable

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

    r12838 r13433  
    890890                    p.print(getSignificantDigits(), str, indent);
    891891                } else {
    892                     str.print(significantDigits());
     892                    str.print(DEFAULT_PRECISION);
    893893                }
    894894            }
     
    973973                    p.print(getSignificantDigits(), str, indent);
    974974                } else {
    975                     str.print(significantDigits());
     975                    str.print(DEFAULT_PRECISION);
    976976                }
    977977            }
     
    10731073    syn lazy int FStringAddExp.maxStringLength_C() = Math.min(getLeft().maxStringLength_C() + getRight().maxStringLength_C(), MAX_STRING_LENGTH_C);
    10741074    eq FStringLitExp.maxStringLength_C()           = stringUtf8().length;
    1075     eq FStringExp.maxStringLength_C()              =
    1076             hasFormat() ? type().maxNumericStringLength_C(significantDigits()) :
    1077             Math.max(getValue().type().maxStringLength_C(significantDigits()), minimumLength());
     1075    eq FStringExp.maxStringLength_C() {
     1076        // TODO: if there is a format arg, there is no significantDigits
     1077        // TODO: handle case where arguments are variables (use MAX_STRING_LENGTH_C?)
     1078        VariableEvaluator ev = defaultVariableEvaluator();
     1079        if (hasFormat()) {
     1080            return type().maxNumericStringLength_C(significantDigits(ev));
     1081        } else {
     1082            return Math.max(getValue().type().maxStringLength_C(significantDigits(ev)), minimumLength(ev));
     1083        }
     1084    }
    10781085   
    10791086    /**
  • branches/stable/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13314 r13433  
    16691669
    16701670        @Override
     1671        public String objectValue() {
     1672            return value;
     1673        }
     1674
     1675        @Override
    16711676        public String toString() {
    16721677            return type.getName() + "." + value;
     
    27842789    eq FEnumIntegerExp.cevalCalc(VariableEvaluator evaluator) = getFExp().ceval(evaluator).convertInteger();
    27852790    eq FStringExp.cevalCalc(VariableEvaluator evaluator) {
    2786         Object value;
    2787         if (getValue().type().isReal())
    2788           value = getValue().ceval(evaluator).realValue();
    2789         else if (getValue().type().isInteger())
    2790           value = getValue().ceval(evaluator).intValue();
    2791         else if (getValue().type().isBoolean() || getValue().type().isEnum())
    2792           value = getValue().ceval(evaluator).stringExpValue();
    2793         else
    2794           return CValue.UNKNOWN;
    2795         return new CValueString(String.format((Locale) null, formatString(), value));
     2791        if (getValue().isArray() || !getValue().type().isPrimitive()) {
     2792            return CValue.UNKNOWN;
     2793        }
     2794        CValue cval = getValue().ceval(evaluator);
     2795        if (getValue().type().isReal()) {
     2796            cval = cval.convertReal();
     2797        }
     2798        Object value = cval.objectValue();
     2799        String format = formatString(evaluator);
     2800        return new CValueString(String.format((Locale) null, format, value));
    27962801    }
    27972802    eq FGetInstanceName.cevalCalc(VariableEvaluator evaluator) = new CValueString(calcInstanceName());
     
    28052810    }
    28062811
    2807     // TODO: support format args
    2808     syn String FStringExp.formatString() = "%" + formatFlags() + formatWidth() + formatPrecision() + formatSpecifier();
    2809 
    2810     syn String FStringExp.formatWidth()     = minimumLength() > 0 ? String.valueOf(minimumLength()) : "";
    2811     syn String FStringExp.formatFlags()     = leftJustified() && minimumLength() > 0 ? "-" : "";
    2812     syn String FStringExp.formatPrecision() = getValue().type().isReal() ? "." + significantDigits() : "";
    2813     syn String FStringExp.formatSpecifier() = getValue().type().formatSpecifier();
    2814     syn int FStringExp.minimumLength()     = hasMinimumLength() ? getMinimumLength().ceval().intValue() : 0;
    2815     syn boolean FStringExp.leftJustified() = hasLeftJustified() ? getLeftJustified().ceval().booleanValue() : true;
    2816     syn int FStringExp.significantDigits() = hasSignificantDigits() ? getSignificantDigits().ceval().intValue() : DEFAULT_PRECISION;
     2812    syn String FStringExp.formatString(VariableEvaluator evaluator) {
     2813        StringBuilder buf = new StringBuilder("%");
     2814        if (hasFormat()) {
     2815            buf.append(getFormat().ceval(evaluator).stringValue());
     2816        } else {
     2817            int minLength = minimumLength(evaluator);
     2818            if (minLength > 0) {
     2819                if (leftJustified(evaluator)) {
     2820                    buf.append('-');
     2821                }
     2822                buf.append(minLength);
     2823            }
     2824            if (getValue().type().isReal()) {
     2825                buf.append('.');
     2826                buf.append(significantDigits(evaluator));
     2827            }
     2828            buf.append(getValue().type().formatSpecifier());
     2829        }
     2830        return buf.toString();
     2831    }
     2832
     2833    syn int FStringExp.minimumLength(VariableEvaluator evaluator)     =
     2834        hasMinimumLength() ? getMinimumLength().ceval(evaluator).intValue() : 0;
     2835    syn boolean FStringExp.leftJustified(VariableEvaluator evaluator) =
     2836        hasLeftJustified() ? getLeftJustified().ceval(evaluator).booleanValue() : true;
     2837    syn int FStringExp.significantDigits(VariableEvaluator evaluator) =
     2838        hasSignificantDigits() ? getSignificantDigits().ceval(evaluator).intValue() : DEFAULT_PRECISION;
    28172839    syn String FType.formatSpecifier() {
    28182840        throw new UnsupportedOperationException();
     
    28222844    eq FBooleanType.formatSpecifier() = "s";
    28232845    eq FEnumType.formatSpecifier()    = "s";
     2846    eq FStringType.formatSpecifier()  = "s";
    28242847    public static final int FStringExp.DEFAULT_PRECISION = 6;
    28252848
  • branches/stable/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r13396 r13433  
    5252        public boolean isFunction();
    5353        public boolean isExternalObject();
     54        public boolean isPrimitiveType();
    5455    }
    5556   
     
    157158        };
    158159       
    159         public boolean isBoolean() { return scalarType().isBoolean(); }
    160         public boolean isInteger() { return scalarType().isInteger(); }
    161         public boolean isReal() { return scalarType().isReal(); }
    162         public boolean isNumeric() { return scalarType().isNumeric(); }
    163         public boolean isString() { return scalarType().isString(); }
    164         public boolean isEnum() { return scalarType().isEnum(); }
    165         public boolean isRecord() { return scalarType().isRecord(); }
    166         public boolean isFunction() { return scalarType().isFunction(); }
     160        public boolean isBoolean()        { return scalarType().isBoolean();        }
     161        public boolean isInteger()        { return scalarType().isInteger();        }
     162        public boolean isReal()           { return scalarType().isReal();          }
     163        public boolean isNumeric()        { return scalarType().isNumeric();        }
     164        public boolean isString()         { return scalarType().isString();        }
     165        public boolean isEnum()           { return scalarType().isEnum();          }
     166        public boolean isRecord()         { return scalarType().isRecord();        }
     167        public boolean isFunction()       { return scalarType().isFunction();      }
    167168        public boolean isExternalObject() { return scalarType().isExternalObject(); }
     169        public boolean isPrimitiveType()  { return scalarType().isPrimitiveType();  }
    168170    }
    169171
     
    12571259    syn boolean FType.isFunction()              = false;
    12581260    eq FFunctionType.isFunction()               = true;
     1261    syn boolean FType.isPrimitiveType()         = false;
     1262    eq FRealType   .isPrimitiveType()           = true;
     1263    eq FIntegerType.isPrimitiveType()           = true;
     1264    eq FBooleanType.isPrimitiveType()           = true;
     1265    eq FStringType .isPrimitiveType()           = true;
     1266    eq FEnumType   .isPrimitiveType()           = true;
    12591267
    12601268    syn boolean FType.isArray()  = getSize() != Size.SCALAR;
  • branches/stable/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r13017 r13433  
    43574357end EvaluatePartialFunction1;
    43584358
     4359
     4360package StringConvert "Test String conversion operator"
     4361
     4362model StringConvertReal1
     4363    constant Real x = 1.23456789;
     4364    constant String s = String(x);
     4365
     4366annotation(__JModelica(UnitTesting(tests={
     4367    FlatteningTestCase(
     4368        name="StringConvert_StringConvertReal1",
     4369        description="String() operator, Real, no options",
     4370        flatModel="
     4371fclass EvaluationTests.StringConvert.StringConvertReal1
     4372 constant Real x = 1.23456789;
     4373 constant String s = \"1.23457\";
     4374end EvaluationTests.StringConvert.StringConvertReal1;
     4375")})));
     4376end StringConvertReal1;
     4377
     4378
     4379model StringConvertReal2
     4380    constant Real x = 1.23456789;
     4381    constant String s = String(x, minimumLength = 10);
     4382
     4383annotation(__JModelica(UnitTesting(tests={
     4384    FlatteningTestCase(
     4385        name="StringConvert_StringConvertReal2",
     4386        description="String() operator, Real, minimumLength",
     4387        flatModel="
     4388fclass EvaluationTests.StringConvert.StringConvertReal2
     4389 constant Real x = 1.23456789;
     4390 constant String s = \"1.23457   \";
     4391end EvaluationTests.StringConvert.StringConvertReal2;
     4392")})));
     4393end StringConvertReal2;
     4394
     4395
     4396model StringConvertReal3
     4397    constant Real x = 1.23456789;
     4398    constant String s = String(x, minimumLength = 2);
     4399
     4400annotation(__JModelica(UnitTesting(tests={
     4401    FlatteningTestCase(
     4402        name="StringConvert_StringConvertReal3",
     4403        description="String() operator, Real, minimumLength < needed length",
     4404        flatModel="
     4405fclass EvaluationTests.StringConvert.StringConvertReal3
     4406 constant Real x = 1.23456789;
     4407 constant String s = \"1.23457\";
     4408end EvaluationTests.StringConvert.StringConvertReal3;
     4409")})));
     4410end StringConvertReal3;
     4411
     4412
     4413model StringConvertReal4
     4414    constant Real x = 1.23456789;
     4415    constant String s = String(x, leftJustified = false);
     4416
     4417annotation(__JModelica(UnitTesting(tests={
     4418    FlatteningTestCase(
     4419        name="StringConvert_StringConvertReal4",
     4420        description="String() operator, Real, leftJustified",
     4421        flatModel="
     4422fclass EvaluationTests.StringConvert.StringConvertReal4
     4423 constant Real x = 1.23456789;
     4424 constant String s = \"1.23457\";
     4425end EvaluationTests.StringConvert.StringConvertReal4;
     4426")})));
     4427end StringConvertReal4;
     4428
     4429
     4430model StringConvertReal5
     4431    constant Real x = 1.23456789;
     4432    constant String s = String(x, leftJustified = false, minimumLength = 10);
     4433
     4434annotation(__JModelica(UnitTesting(tests={
     4435    FlatteningTestCase(
     4436        name="StringConvert_StringConvertReal5",
     4437        description="String() operator, Real, leftJustified, minimumLength",
     4438        flatModel="
     4439fclass EvaluationTests.StringConvert.StringConvertReal5
     4440 constant Real x = 1.23456789;
     4441 constant String s = \"   1.23457\";
     4442end EvaluationTests.StringConvert.StringConvertReal5;
     4443")})));
     4444end StringConvertReal5;
     4445
     4446
     4447model StringConvertReal6
     4448    constant Real x = 1.23456789;
     4449    constant String s = String(x, significantDigits = 4);
     4450
     4451annotation(__JModelica(UnitTesting(tests={
     4452    FlatteningTestCase(
     4453        name="StringConvert_StringConvertReal6",
     4454        description="String() operator, Real, significantDigits",
     4455        flatModel="
     4456fclass EvaluationTests.StringConvert.StringConvertReal6
     4457 constant Real x = 1.23456789;
     4458 constant String s = \"1.235\";
     4459end EvaluationTests.StringConvert.StringConvertReal6;
     4460")})));
     4461end StringConvertReal6;
     4462
     4463
     4464model StringConvertReal7
     4465    constant Real x = 1.23456789;
     4466    constant String s = String(x, significantDigits = 4, leftJustified = false, minimumLength = 8);
     4467
     4468annotation(__JModelica(UnitTesting(tests={
     4469    FlatteningTestCase(
     4470        name="StringConvert_StringConvertReal7",
     4471        description="String() operator, Real, significantDigits, leftJustified, minimumLength",
     4472        flatModel="
     4473fclass EvaluationTests.StringConvert.StringConvertReal7
     4474 constant Real x = 1.23456789;
     4475 constant String s = \"   1.235\";
     4476end EvaluationTests.StringConvert.StringConvertReal7;
     4477")})));
     4478end StringConvertReal7;
     4479
     4480
     4481model StringConvertReal8
     4482    constant Real x = 1.23456789;
     4483    constant String s = String(x, format = "10.4E");
     4484
     4485annotation(__JModelica(UnitTesting(tests={
     4486    FlatteningTestCase(
     4487        name="StringConvert_StringConvertReal8",
     4488        description="String() operator, Real, format",
     4489        flatModel="
     4490fclass EvaluationTests.StringConvert.StringConvertReal8
     4491 constant Real x = 1.23456789;
     4492 constant String s = \"1.2346E+00\";
     4493end EvaluationTests.StringConvert.StringConvertReal8;
     4494")})));
     4495end StringConvertReal8;
     4496
     4497
     4498model StringConvertInteger1
     4499    constant Integer x = 12;
     4500    constant String s = String(x);
     4501
     4502annotation(__JModelica(UnitTesting(tests={
     4503    FlatteningTestCase(
     4504        name="StringConvert_StringConvertInteger1",
     4505        description="String() operator, Integer, no options",
     4506        flatModel="
     4507fclass EvaluationTests.StringConvert.StringConvertInteger1
     4508 constant Integer x = 12;
     4509 constant String s = \"12\";
     4510end EvaluationTests.StringConvert.StringConvertInteger1;
     4511")})));
     4512end StringConvertInteger1;
     4513
     4514
     4515model StringConvertInteger2
     4516    constant Integer x = 12;
     4517    constant String s = String(x, minimumLength = 3);
     4518
     4519annotation(__JModelica(UnitTesting(tests={
     4520    FlatteningTestCase(
     4521        name="StringConvert_StringConvertInteger2",
     4522        description="String() operator, Integer, minimumLength",
     4523        flatModel="
     4524fclass EvaluationTests.StringConvert.StringConvertInteger2
     4525 constant Integer x = 12;
     4526 constant String s = \"12 \";
     4527end EvaluationTests.StringConvert.StringConvertInteger2;
     4528")})));
     4529end StringConvertInteger2;
     4530
     4531
     4532model StringConvertInteger3
     4533    constant Integer x = 12;
     4534    constant String s = String(x, leftJustified = false, minimumLength = 3);
     4535
     4536annotation(__JModelica(UnitTesting(tests={
     4537    FlatteningTestCase(
     4538        name="StringConvert_StringConvertInteger3",
     4539        description="String() operator, Integer, leftJustified, minimumLength",
     4540        flatModel="
     4541fclass EvaluationTests.StringConvert.StringConvertInteger3
     4542 constant Integer x = 12;
     4543 constant String s = \" 12\";
     4544end EvaluationTests.StringConvert.StringConvertInteger3;
     4545")})));
     4546end StringConvertInteger3;
     4547
     4548
     4549model StringConvertBoolean1
     4550    constant Boolean x = true;
     4551    constant String s = String(x);
     4552
     4553annotation(__JModelica(UnitTesting(tests={
     4554    FlatteningTestCase(
     4555        name="StringConvert_StringConvertBoolean1",
     4556        description="String() operator, Boolean true, no options",
     4557        flatModel="
     4558fclass EvaluationTests.StringConvert.StringConvertBoolean1
     4559 constant Boolean x = true;
     4560 constant String s = \"true\";
     4561end EvaluationTests.StringConvert.StringConvertBoolean1;
     4562")})));
     4563end StringConvertBoolean1;
     4564
     4565
     4566model StringConvertBoolean2
     4567    constant Boolean x = false;
     4568    constant String s = String(x);
     4569
     4570annotation(__JModelica(UnitTesting(tests={
     4571    FlatteningTestCase(
     4572        name="StringConvert_StringConvertBoolean2",
     4573        description="String() operator, Boolean false, no options",
     4574        flatModel="
     4575fclass EvaluationTests.StringConvert.StringConvertBoolean2
     4576 constant Boolean x = false;
     4577 constant String s = \"false\";
     4578end EvaluationTests.StringConvert.StringConvertBoolean2;
     4579")})));
     4580end StringConvertBoolean2;
     4581
     4582
     4583model StringConvertBoolean3
     4584    constant Boolean x = true;
     4585    constant String s = String(x, minimumLength = 5);
     4586
     4587annotation(__JModelica(UnitTesting(tests={
     4588    FlatteningTestCase(
     4589        name="StringConvert_StringConvertBoolean3",
     4590        description="String() operator, Boolean, minimumLength",
     4591        flatModel="
     4592fclass EvaluationTests.StringConvert.StringConvertBoolean3
     4593 constant Boolean x = true;
     4594 constant String s = \"true \";
     4595end EvaluationTests.StringConvert.StringConvertBoolean3;
     4596")})));
     4597end StringConvertBoolean3;
     4598
     4599
     4600model StringConvertBoolean4
     4601    constant Boolean x = true;
     4602    constant String s = String(x, leftJustified = false, minimumLength = 5);
     4603
     4604annotation(__JModelica(UnitTesting(tests={
     4605    FlatteningTestCase(
     4606        name="StringConvert_StringConvertBoolean4",
     4607        description="String() operator, Boolean, leftJustified, minimumLength",
     4608        flatModel="
     4609fclass EvaluationTests.StringConvert.StringConvertBoolean4
     4610 constant Boolean x = true;
     4611 constant String s = \" true\";
     4612end EvaluationTests.StringConvert.StringConvertBoolean4;
     4613")})));
     4614end StringConvertBoolean4;
     4615
     4616
     4617model StringConvertEnumeration1
     4618    type E = enumeration(Alpha, Beta, Gamma);
     4619    constant E x = E.Beta;
     4620    constant String s = String(x);
     4621
     4622annotation(__JModelica(UnitTesting(tests={
     4623    FlatteningTestCase(
     4624        name="StringConvert_StringConvertEnumeration1",
     4625        description="String() operator, Enumeration, no options",
     4626        flatModel="
     4627fclass EvaluationTests.StringConvert.StringConvertEnumeration1
     4628 constant EvaluationTests.StringConvert.StringConvertEnumeration1.E x = EvaluationTests.StringConvert.StringConvertEnumeration1.E.Beta;
     4629 constant String s = \"Beta\";
     4630
     4631public
     4632 type EvaluationTests.StringConvert.StringConvertEnumeration1.E = enumeration(Alpha, Beta, Gamma);
     4633
     4634end EvaluationTests.StringConvert.StringConvertEnumeration1;
     4635")})));
     4636end StringConvertEnumeration1;
     4637
     4638
     4639model StringConvertEnumeration2
     4640    type E = enumeration(Alpha, Beta, Gamma);
     4641    constant E x = E.Beta;
     4642    constant String s = String(x, minimumLength = 5);
     4643
     4644annotation(__JModelica(UnitTesting(tests={
     4645    FlatteningTestCase(
     4646        name="StringConvert_StringConvertEnumeration2",
     4647        description="String() operator, Enumeration, minimumLength",
     4648        flatModel="
     4649fclass EvaluationTests.StringConvert.StringConvertEnumeration2
     4650 constant EvaluationTests.StringConvert.StringConvertEnumeration2.E x = EvaluationTests.StringConvert.StringConvertEnumeration2.E.Beta;
     4651 constant String s = \"Beta \";
     4652
     4653public
     4654 type EvaluationTests.StringConvert.StringConvertEnumeration2.E = enumeration(Alpha, Beta, Gamma);
     4655
     4656end EvaluationTests.StringConvert.StringConvertEnumeration2;
     4657")})));
     4658end StringConvertEnumeration2;
     4659
     4660
     4661model StringConvertEnumeration3
     4662    type E = enumeration(Alpha, Beta, Gamma);
     4663    constant E x = E.Beta;
     4664    constant String s = String(x, leftJustified = false, minimumLength = 5);
     4665
     4666annotation(__JModelica(UnitTesting(tests={
     4667    FlatteningTestCase(
     4668        name="StringConvert_StringConvertEnumeration3",
     4669        description="String() operator, Enumeration, leftJustified, minimumLength",
     4670        flatModel="
     4671fclass EvaluationTests.StringConvert.StringConvertEnumeration3
     4672 constant EvaluationTests.StringConvert.StringConvertEnumeration3.E x = EvaluationTests.StringConvert.StringConvertEnumeration3.E.Beta;
     4673 constant String s = \" Beta\";
     4674
     4675public
     4676 type EvaluationTests.StringConvert.StringConvertEnumeration3.E = enumeration(Alpha, Beta, Gamma);
     4677
     4678end EvaluationTests.StringConvert.StringConvertEnumeration3;
     4679")})));
     4680end StringConvertEnumeration3;
     4681
     4682
     4683model StringConvertWithParam1
     4684    parameter Integer len = 8;
     4685    parameter Boolean left = false;
     4686    parameter Integer dig = 4;
     4687    constant Real x = 1.23456789;
     4688    constant String s = String(x, significantDigits = dig - 1, leftJustified = left, minimumLength = len - 1);
     4689
     4690annotation(__JModelica(UnitTesting(tests={
     4691    FlatteningTestCase(
     4692        name="StringConvert_StringConvertWithParam1",
     4693        description="String() operator, Real, all options given as parameter expressions",
     4694        flatModel="
     4695fclass EvaluationTests.StringConvert.StringConvertWithParam1
     4696 structural parameter Integer len = 8 /* 8 */;
     4697 structural parameter Boolean left = false /* false */;
     4698 structural parameter Integer dig = 4 /* 4 */;
     4699 constant Real x = 1.23456789;
     4700 constant String s = \"   1.23\";
     4701end EvaluationTests.StringConvert.StringConvertWithParam1;
     4702")})));
     4703end StringConvertWithParam1;
     4704
     4705
     4706model StringConvertWithParam2
     4707    parameter String fmtSize = "10.4";
     4708    constant Real x = 1.23456789;
     4709    constant String s = String(x, format = fmtSize + "E");
     4710
     4711annotation(__JModelica(UnitTesting(tests={
     4712    FlatteningTestCase(
     4713        name="StringConvert_StringConvertWithParam2",
     4714        description="String() operator, Real, format given as parameter expressions",
     4715        flatModel="
     4716fclass EvaluationTests.StringConvert.StringConvertWithParam2
     4717 parameter String fmtSize = \"10.4\" /* \"10.4\" */;
     4718 constant Real x = 1.23456789;
     4719 constant String s = \"1.2346E+00\";
     4720end EvaluationTests.StringConvert.StringConvertWithParam2;
     4721")})));
     4722end StringConvertWithParam2;
     4723
     4724end StringConvert;
     4725
    43594726end EvaluationTests;
  • branches/stable/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/TestAnnotationizer.java

    r12940 r13433  
    139139       
    140140        if (filePath == null && !hasInputFilePath) {
    141             System.err.println("No input file specified. give path as argument or use -file");
     141            System.err.println("No input file specified. give path as argument or use -f");
    142142        }
    143143
    144144        if (all_models && hasInputFilePath) {
    145             System.err.println("Cannot use -a and -file at the same time");
     145            System.err.println("Cannot use -a and -f at the same time");
    146146        }
    147147       
     
    157157            cont = inputFileScanner.hasNextLine();
    158158        }
     159        @SuppressWarnings("resource")
     160        BufferedReader in = cont ? new BufferedReader(new InputStreamReader(System.in)) : null;
     161        String packageName = getPackageName(filePath);
    159162        while (cont) {
    160             BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    161             if(hasInputFilePath) {
     163            if (hasInputFilePath) {
    162164                String line = inputFileScanner.nextLine();
    163165                String[] parts = line.split(",");
    164166                filePath = parts[0];
    165                 modelName = parts[1];
    166             }
    167             String packageName = null;
    168             if(!(all_models || hasInputFilePath)) {
    169167                packageName = getPackageName(filePath);
    170                 modelName = composeModelName(packageName, modelName);
    171             } else if (hasInputFilePath) {
    172                 packageName = getPackageName(filePath);
    173                 modelName = packageName + "." + modelName;
    174             }
    175             if (all_models) {
     168                modelName = packageName + "." + parts[1];
     169            } else if (all_models) {
    176170                modelName = allModelsIterator.next();
    177             } else if (!modelName.contains(".")) {
     171            } else if (modelName == null) {
    178172                System.out.print("Enter class name: ");
    179173                System.out.flush();
     
    183177                    System.exit(0);
    184178                }
    185                 modelName = composeModelName(modelName, given);
     179                modelName = composeModelName(packageName, given);
    186180            }
    187181           
     
    205199           
    206200            if (repeat) {
    207                 modelName = packageName;
     201                modelName = null;
    208202            } else if (all_models) {
    209203                cont = allModelsIterator.hasNext();
  • branches/stable/Compiler/ModelicaFrontEnd/test/modelica/OperatorRecordTests.mo

    r13103 r13433  
    708708")})));
    709709    end OperatorOverload13;
    710 
    711 
    712     model OperatorOverload14
    713         operator record Cplx2 = Cplx;
    714         Cplx c1 = Cplx(1, 2);
    715         Cplx2 c2 = Cplx2(3, 4);
    716         Cplx c3 = c1 + c2;
    717 
    718     annotation(__JModelica(UnitTesting(tests={
    719         FlatteningTestCase(
    720             name="OperatorOverload14",
    721             description="Short class decls of operator records",
    722             flatModel="
    723 fclass OperatorRecordTests.OperatorOverload14
    724  OperatorRecordTests.Cplx c1 = OperatorRecordTests.Cplx.'constructor'(1, 2);
    725  OperatorRecordTests.OperatorOverload14.Cplx2 c2 = OperatorRecordTests.Cplx.'constructor'(3, 4);
    726  OperatorRecordTests.Cplx c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
    727 
    728 public
    729  function OperatorRecordTests.Cplx.'constructor'
    730   input Real re;
    731   input Real im;
    732   output OperatorRecordTests.Cplx c;
    733  algorithm
    734   c.re := re;
    735   c.im := im;
    736   return;
    737  end OperatorRecordTests.Cplx.'constructor';
    738 
    739  function OperatorRecordTests.Cplx.'+'
    740   input OperatorRecordTests.Cplx a;
    741   input OperatorRecordTests.Cplx b;
    742   output OperatorRecordTests.Cplx c;
    743  algorithm
    744   (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
    745   return;
    746  end OperatorRecordTests.Cplx.'+';
    747 
    748  record OperatorRecordTests.Cplx
    749   Real re;
    750   Real im;
    751  end OperatorRecordTests.Cplx;
    752 
    753  record OperatorRecordTests.OperatorOverload14.Cplx2
    754   Real re;
    755   Real im;
    756  end OperatorRecordTests.OperatorOverload14.Cplx2;
    757 
    758 end OperatorRecordTests.OperatorOverload14;
    759 ")})));
    760     end OperatorOverload14;
    761710
    762711
     
    16421591
    16431592
    1644     model OperatorRecordConnect3
    1645         connector C = Cplx;
    1646 
    1647         C c1, c2, c3;
    1648     equation
    1649         connect(c1, c2);
    1650         c3 = c1 + c2;
    1651 
    1652     annotation(__JModelica(UnitTesting(tests={
    1653         FlatteningTestCase(
    1654             name="OperatorRecordConnect3",
    1655             description="Connectors that are operator records",
    1656             flatModel="
    1657 fclass OperatorRecordTests.OperatorRecordConnect3
    1658  OperatorRecordTests.OperatorRecordConnect3.C c1;
    1659  OperatorRecordTests.OperatorRecordConnect3.C c2;
    1660  OperatorRecordTests.OperatorRecordConnect3.C c3;
    1661 equation
    1662  c3 = OperatorRecordTests.Cplx.'+'(c1, c2);
    1663  c1 = c2;
    1664 
    1665 public
    1666  function OperatorRecordTests.Cplx.'+'
    1667   input OperatorRecordTests.Cplx a;
    1668   input OperatorRecordTests.Cplx b;
    1669   output OperatorRecordTests.Cplx c;
    1670  algorithm
    1671   (c) := OperatorRecordTests.Cplx.'constructor'(a.re + b.re, a.im + b.im);
    1672   return;
    1673  end OperatorRecordTests.Cplx.'+';
    1674 
    1675  function OperatorRecordTests.Cplx.'constructor'
    1676   input Real re;
    1677   input Real im;
    1678   output OperatorRecordTests.Cplx c;
    1679  algorithm
    1680   c.re := re;
    1681   c.im := im;
    1682   return;
    1683  end OperatorRecordTests.Cplx.'constructor';
    1684 
    1685  record OperatorRecordTests.OperatorRecordConnect3.C
    1686   Real re;
    1687   Real im;
    1688  end OperatorRecordTests.OperatorRecordConnect3.C;
    1689 
    1690  record OperatorRecordTests.Cplx
    1691   Real re;
    1692   Real im;
    1693  end OperatorRecordTests.Cplx;
    1694 
    1695 end OperatorRecordTests.OperatorRecordConnect3;
    1696 ")})));
    1697     end OperatorRecordConnect3;
    1698 
    16991593
    17001594    model OperatorRecordConnect4
     
    17421636    end OperatorRecordConnect4;
    17431637
    1744 
    1745     model OperatorRecordConnect5
    1746         connector C = Cplx;
    1747        
    1748         model A
    1749             C c;
    1750         end A;
    1751        
    1752         A a[2];
    1753         C c[2];
    1754     equation
    1755         connect(a.c, c);
    1756 
    1757     annotation(__JModelica(UnitTesting(tests={
    1758         FlatteningTestCase(
    1759             name="OperatorRecordConnect5",
    1760             description="Test connecting to array of operator record",
    1761             flatModel="
    1762 fclass OperatorRecordTests.OperatorRecordConnect5
    1763  OperatorRecordTests.OperatorRecordConnect5.C a[1].c;
    1764  OperatorRecordTests.OperatorRecordConnect5.C a[2].c;
    1765  OperatorRecordTests.OperatorRecordConnect5.C c[2];
    1766 equation
    1767  a[1].c = c[1];
    1768  a[2].c = c[2];
    1769 
    1770 public
    1771  record OperatorRecordTests.OperatorRecordConnect5.C
    1772   Real re;
    1773   Real im;
    1774  end OperatorRecordTests.OperatorRecordConnect5.C;
    1775 
    1776 end OperatorRecordTests.OperatorRecordConnect5;
    1777 ")})));
    1778     end OperatorRecordConnect5;
    17791638
    17801639
Note: See TracChangeset for help on using the changeset viewer.