Changeset 13431


Ignore:
Timestamp:
Sep 9, 2019 3:24:05 PM (3 months ago)
Author:
Jesper Mattsson
Message:

Fixed constant evaluation of String() operator, and added missing tests. (#5835)

Location:
trunk/Compiler
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/Compiler/ModelicaCBackEnd/src/jastadd/CCodeGen/CCodeGenExpressions.jrag

    r12838 r13431  
    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    /**
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/ConstantEvaluation/ConstantEvaluation.jrag

    r13314 r13431  
    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
  • trunk/Compiler/ModelicaFlatTree/src/jastadd/TypeAnalysis.jrag

    r13396 r13431  
    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;
  • trunk/Compiler/ModelicaFlatTree/test/modelica/EvaluationTests.mo

    r13017 r13431  
    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;
  • trunk/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/TestAnnotationizer.java

    r12940 r13431  
    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();
Note: See TracChangeset for help on using the changeset viewer.