diff --git a/src/main/java/org/ntlab/rdlworkbench/Main.java b/src/main/java/org/ntlab/rdlworkbench/Main.java index 48adc9a..56afc33 100644 --- a/src/main/java/org/ntlab/rdlworkbench/Main.java +++ b/src/main/java/org/ntlab/rdlworkbench/Main.java @@ -1,8 +1,5 @@ package org.ntlab.rdlworkbench; -import org.ntlab.rdl.applicationruntime.ApplicationRuntime; -import org.ntlab.rdl.swingadapter.SwingAdapter; - public class Main { public static void main(String[] args) { diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java new file mode 100644 index 0000000..d3496e0 --- /dev/null +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java @@ -0,0 +1,41 @@ +package org.ntlab.rdlworkbench.models; + +import java.util.*; + +public class RDLSpec { + Map resourceMap = new TreeMap<>(); + List rdlSpecStatements = new ArrayList<>(); + + public void putResourceMap(String name, int order, StructuralType structuralType, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, structuralType, valueType)); + } + + public RDLSpecResourceDeclaration getRDLSpecResourceDeclaration(String name) { + if (!resourceMap.containsKey(name)) { + return null; + } + return resourceMap.get(name); + } + + public void addRDLSpecStatement(RDLSpecStatement rdlSpecStatement) { + rdlSpecStatements.add(rdlSpecStatement); + rdlSpecStatements.sort(Comparator.comparing(obj -> { + if (obj.isRDLSpecResourceDeclaration()) { + return 1; + } + if (obj.isRDLSpecInitialization()) { + return 2; + } + return 3; + })); + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (int i = 0; i < rdlSpecStatements.size(); i++) { + sb.append(rdlSpecStatements.get(i)).append("\n"); + } + return sb.toString(); + } +} diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependency.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependency.java index 1890648..1855017 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependency.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependency.java @@ -4,7 +4,6 @@ import models.terms.EvaluatableTerm; import models.terms.RDLTerm; -import java.util.ArrayList; import java.util.List; public class RDLSpecDependency extends Dependency { @@ -16,4 +15,5 @@ public RDLSpecDependency(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms) { super((RDLTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList()); } + } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyFormula.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyFormula.java index aa7d0ef..08029d3 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyFormula.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyFormula.java @@ -2,7 +2,7 @@ import models.formulas.DependencyFormula; -public class RDLSpecDependencyFormula extends DependencyFormula implements RDLSpecStatement{ +public class RDLSpecDependencyFormula extends DependencyFormula implements RDLSpecStatement { public RDLSpecDependencyFormula(RDLSpecDependency dependency) { super(dependency); diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java index d70f617..00ea7af 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java @@ -1,43 +1,42 @@ package org.ntlab.rdlworkbench.models; import exceptions.SyntaxException; -import models.algebra.Type; import models.terms.DependencyTerm; import models.terms.EvaluatableTerm; import java.util.List; public class RDLSpecDependencyTerm extends DependencyTerm implements Typable, RDLSpecEvaluatableTerm { - private Type structuralType; - private Type valuableType; + private StructuralType structuralType; + private ValueType valuableType; public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List terms) { super((EvaluatableTerm) dependingTerm, terms.stream().map(item -> (EvaluatableTerm) item).toList()); - this.structuralType = ((Typable)dependingTerm).getStructuralType(); - this.valuableType = ((Typable)dependingTerm).getValuableType(); + this.structuralType = ((Typable) dependingTerm).getStructuralType(); + this.valuableType = ((Typable) dependingTerm).getValueType(); for (int i = 0; i < terms.size(); i += 2) { - if (!typeChecker(terms.get(i), terms.get(i+1))) { + if (!typeChecker(terms.get(i), terms.get(i + 1))) { throw new SyntaxException("the type is different"); } } } private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { - String leftStructuralType = ((Typable)left).getStructuralType().getTypeName(); - String rightStructuralType = ((Typable)right).getStructuralType().getTypeName(); + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); - if (leftStructuralType.equals("struct") || leftStructuralType.equals("map")) { - if (leftStructuralType.equals(rightStructuralType)) { + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { return true; } else { return false; } } else { - String leftValuableType = ((Typable)left).getValuableType().getTypeName(); - String rightValuableType = ((Typable)right).getValuableType().getTypeName(); + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); - if (leftValuableType.equals(rightValuableType)) { + if (leftValueType.equals(rightValueType)) { return true; } else { return false; @@ -46,12 +45,12 @@ } @Override - public Type getStructuralType() { + public StructuralType getStructuralType() { return structuralType; } @Override - public Type getValuableType() { + public ValueType getValueType() { return valuableType; } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecEquationFormula.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecEquationFormula.java index c4c01b6..ab3fbbb 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecEquationFormula.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecEquationFormula.java @@ -4,7 +4,7 @@ import models.formulas.EquationFormula; import models.terms.EvaluatableTerm; -public class RDLSpecEquationFormula extends EquationFormula implements RDLSpecStatement{ +public class RDLSpecEquationFormula extends EquationFormula implements RDLSpecStatement { public RDLSpecEquationFormula(RDLSpecEvaluatableTerm leftSideHand, RDLSpecEvaluatableTerm rightSideHand) { super((EvaluatableTerm) leftSideHand, (EvaluatableTerm) rightSideHand); @@ -14,20 +14,20 @@ } private boolean typeChecker(RDLSpecEvaluatableTerm left, RDLSpecEvaluatableTerm right) { - String leftStructuralType = ((Typable)left).getStructuralType().getTypeName(); - String rightStructuralType = ((Typable)right).getStructuralType().getTypeName(); + StructuralType leftStructuralType = ((Typable) left).getStructuralType(); + StructuralType rightStructuralType = ((Typable) right).getStructuralType(); - if (leftStructuralType.equals("struct") || leftStructuralType.equals("map")) { - if (leftStructuralType.equals(rightStructuralType)) { + if (leftStructuralType == StructuralType.structure || leftStructuralType == StructuralType.map) { + if (leftStructuralType == rightStructuralType) { return true; } else { return false; } } else { - String leftValuableType = ((Typable)left).getValuableType().getTypeName(); - String rightValuableType = ((Typable)right).getValuableType().getTypeName(); + ValueType leftValueType = ((Typable) left).getValueType(); + ValueType rightValueType = ((Typable) right).getValueType(); - if (leftValuableType.equals(rightValuableType)) { + if (leftValueType.equals(rightValueType)) { return true; } else { return false; diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecInitialization.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecInitialization.java index 81dc3e7..cb1f48c 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecInitialization.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecInitialization.java @@ -1,6 +1,6 @@ package org.ntlab.rdlworkbench.models; -public class RDLSpecInitialization implements RDLSpecStatement{ +public class RDLSpecInitialization implements RDLSpecStatement { RDLSpecEvaluatableTerm leftSideHand; RDLSpecEvaluatableTerm rightSideHand; @@ -34,7 +34,7 @@ @Override public boolean equals(Object another) { - if(!(another instanceof RDLSpecInitialization anotherInitialization)) { + if (!(another instanceof RDLSpecInitialization anotherInitialization)) { return false; } return leftSideHand.equals(anotherInitialization.getLeftSideHand()) && rightSideHand.equals(anotherInitialization.getRightSideHand()); diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java new file mode 100644 index 0000000..2e55e70 --- /dev/null +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java @@ -0,0 +1,8 @@ +package org.ntlab.rdlworkbench.models; + +public class RDLSpecLang { + public static ValueType typeString = new ValueType("string"); + public static ValueType typeInt = new ValueType("int"); + public static ValueType typeBoolean = new ValueType("boolean"); + public static ValueType typeDouble = new ValueType("double"); +} diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResource.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResource.java index 4aeb70d..c81e648 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResource.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResource.java @@ -1,40 +1,39 @@ package org.ntlab.rdlworkbench.models; -import models.algebra.Type; import models.terms.Resource; public class RDLSpecResource extends Resource implements Typable, RDLSpecEvaluatableTerm { - private Type structuralType; - private Type valuableType; + private StructuralType structuralType; + private ValueType valueType; - public RDLSpecResource(String name, int order, Type structuralType, Type valuableType) { + public RDLSpecResource(String name, int order, StructuralType structuralType, ValueType valueType) { super(name, order); - if (!(structuralType.getTypeName().equals("struct") || structuralType.getTypeName().equals("id") || structuralType.getTypeName().equals("primitive") || structuralType.getTypeName().equals("map") || structuralType.getTypeName().equals("value"))) { - throw new IllegalArgumentException(structuralType.getTypeName() + " is not expected structural type."); + if (!(structuralType == StructuralType.structure || structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.map || structuralType == StructuralType.value)) { + throw new IllegalArgumentException(structuralType + " is not expected structural type."); } - if (structuralType.getTypeName().equals("id") || structuralType.getTypeName().equals("primitive") || structuralType.getTypeName().equals("value")) { - if (!(valuableType.getTypeName().equals("int") || valuableType.getTypeName().equals("double") || valuableType.getTypeName().equals("string") || valuableType.getTypeName().equals("boolean"))) { - throw new IllegalArgumentException(structuralType.getTypeName() + " is not expected valuable Type."); + if (structuralType == StructuralType.id || structuralType == StructuralType.primitive || structuralType == StructuralType.value) { + if (!(valueType.equals(RDLSpecLang.typeInt) || valueType.equals(RDLSpecLang.typeDouble) || valueType.equals(RDLSpecLang.typeString) || valueType.equals(RDLSpecLang.typeBoolean))) { + throw new IllegalArgumentException(structuralType + " is not expected valuable Type."); } } else { - if (valuableType != null) { + if (valueType != null) { throw new IllegalArgumentException("It does not have a type"); } } this.structuralType = structuralType; - this.valuableType = valuableType; + this.valueType = valueType; } @Override - public Type getStructuralType() { + public StructuralType getStructuralType() { return structuralType; } @Override - public Type getValuableType() { - return valuableType; + public ValueType getValueType() { + return valueType; } @Override diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java index 37819f5..70197dc 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java @@ -1,26 +1,25 @@ package org.ntlab.rdlworkbench.models; -import models.algebra.Type; import models.terms.ResourceConstant; public class RDLSpecResourceConstant extends ResourceConstant implements Typable, RDLSpecEvaluatableTerm { - private Type structuralType; - private Type valuableType; + private StructuralType structuralType; + private ValueType valueType; - public RDLSpecResourceConstant(String name, Type structuralType, Type valuableType) { + public RDLSpecResourceConstant(String name, StructuralType structuralType, ValueType valueType) { super(name); this.structuralType = structuralType; - this.valuableType = valuableType; + this.valueType = valueType; } @Override - public Type getStructuralType() { + public StructuralType getStructuralType() { return structuralType; } @Override - public Type getValuableType() { - return valuableType; + public ValueType getValueType() { + return valueType; } @Override @@ -30,7 +29,7 @@ @Override public String toString() { - if (valuableType.getTypeName().equals("string")) { + if (valueType.getName().equals("string")) { return "\"" + getName() + "\""; } else { return getName(); diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java index ccb6ab4..732db28 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java @@ -1,41 +1,26 @@ package org.ntlab.rdlworkbench.models; -import models.algebra.Type; - import java.util.*; -public class RDLSpecResourceDeclaration implements RDLSpecStatement{ - private Map resourceMap = new TreeMap<>(); - private Map primeResourceMap = new TreeMap<>(); +public class RDLSpecResourceDeclaration implements RDLSpecStatement { + private RDLSpecResource resource; + private RDLSpecResource primedResource; - public boolean containsResource(String name) { - return resourceMap.containsKey(name); - } - - public void putRDLSpecResource(String name, int order, Type structuralType, Type valuableType) { - resourceMap.put(name, new RDLSpecResource(name, order, structuralType, valuableType)); - if (structuralType.getTypeName().equals("id")) { - primeResourceMap.put(name, new RDLSpecResource(name + "'", order, structuralType, valuableType)); - } - } - - public RDLSpecResource getRDLSpecResource(String name, boolean isPrime) { - if (isPrime) { - if (!resourceMap.get(name).getStructuralType().getTypeName().equals("id")) { - throw new IllegalArgumentException("prime is only id type : " + name); - } - return primeResourceMap.get(name); + public RDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + resource = new RDLSpecResource(name, order, structuralType, valueType); + if (structuralType == StructuralType.id) { + primedResource = new RDLSpecResource(name + "'", order, structuralType, valueType); } else { - return resourceMap.get(name); + primedResource = null; } } - public Map getResourceMap() { - return resourceMap; + public RDLSpecResource getResource() { + return resource; } - public Map getPrimeResourceMap() { - return primeResourceMap; + public RDLSpecResource getPrimedResource() { + return primedResource; } @Override @@ -54,7 +39,11 @@ return false; } - return resourceMap.equals(rdlSpecResourceDeclaration.getResourceMap()) && primeResourceMap.equals(rdlSpecResourceDeclaration.getPrimeResourceMap()); + if (rdlSpecResourceDeclaration.getResource().equals(resource) && ((rdlSpecResourceDeclaration.getPrimedResource() == null && primedResource == null) || rdlSpecResourceDeclaration.getPrimedResource().equals(primedResource))) { + return true; + } else { + return false; + } } @Override @@ -65,16 +54,20 @@ @Override public String toString() { StringBuilder sb = new StringBuilder(); - for (String key : resourceMap.keySet()) { - RDLSpecResource resource = resourceMap.get(key); - sb.append(resource).append("(").append(resource.getOrder()).append("):: "); - sb.append(resource.getStructuralType().getTypeName()); - if (resource.getValuableType() != null) { - sb.append(", ").append(resource.getValuableType().getTypeName()).append("\n"); - } else { - sb.append("\n"); - } + sb.append(resource).append("(").append(resource.getOrder()).append("):: "); + + if (resource.getStructuralType() == StructuralType.primitive) { + sb.append(resource.getValueType().getName()); + return sb.toString(); } - return sb.toString(); + + if (resource.getValueType() == null) { + sb.append(resource.getStructuralType()); + return sb.toString(); + } else { + sb.append(resource.getStructuralType()); + sb.append(", ").append(resource.getValueType().getName()); + return sb.toString(); + } } } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/StructuralType.java b/src/main/java/org/ntlab/rdlworkbench/models/StructuralType.java new file mode 100644 index 0000000..0dee3e4 --- /dev/null +++ b/src/main/java/org/ntlab/rdlworkbench/models/StructuralType.java @@ -0,0 +1,26 @@ +package org.ntlab.rdlworkbench.models; + +public enum StructuralType { + id, + value, + structure, + map, + primitive; + + @Override + public String toString() { + switch (this) { + case id: + return "id"; + case value: + return "value"; + case structure: + return "struct"; + case map: + return "map"; + case primitive: + default: + return ""; + } + } +} diff --git a/src/main/java/org/ntlab/rdlworkbench/models/Typable.java b/src/main/java/org/ntlab/rdlworkbench/models/Typable.java index 2ca26c0..f7dbbb8 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/Typable.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/Typable.java @@ -1,8 +1,7 @@ package org.ntlab.rdlworkbench.models; -import models.algebra.Type; public interface Typable { - Type getStructuralType(); - Type getValuableType(); + StructuralType getStructuralType(); + ValueType getValueType(); } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java b/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java new file mode 100644 index 0000000..f989e11 --- /dev/null +++ b/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java @@ -0,0 +1,21 @@ +package org.ntlab.rdlworkbench.models; + +public class ValueType { + private String name; + + public ValueType(String name) { + this.name = name; + } + + public String getName() { + return name; + } + + @Override + public boolean equals(Object obj) { + if (!(obj instanceof ValueType)) { + return false; + } + return name.equals(((ValueType) obj).name); + } +} diff --git a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java index 26c6eaf..3c13192 100644 --- a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java +++ b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java @@ -1,16 +1,12 @@ package org.ntlab.rdlworkbench.rdlparser; import exceptions.SyntaxException; -import models.algebra.Type; -import models.formulas.*; import models.terms.*; import org.ntlab.rdlworkbench.models.*; import java.util.*; public class RDLParser { - static RDLSpecResourceDeclaration resourceDeclaration = new RDLSpecResourceDeclaration(); - static List statements = new ArrayList<>(); public static TokenStream tokenStream; public static final String LEFT_SQUARE_BRACKET = "["; public static final String RIGHT_SQUARE_BRACKET = "]"; @@ -29,53 +25,49 @@ public static final String PRIME = "'"; public static final String ARROW = "->"; - public static void main(String[] args) { + public static void rdlParser() { Scanner sc = new Scanner(System.in); + RDLSpec rdlSpec = new RDLSpec(); while (true) { String S = sc.nextLine(); if (S.equals("")) { break; } + tokenStream = new TokenStream(); tokenStream.addLine(S); + if (S.contains(LEFT_BRACKET)) { - RDLSpecResource resource = parseResourceDeclaration(); + RDLSpecResourceDeclaration resourceDeclaration = parseResourceDeclaration(rdlSpec); + rdlSpec.addRDLSpecStatement(resourceDeclaration); } else if (S.contains(COLON_EQUAL)) { - RDLSpecInitialization initialization = parseRDLSpecInitialization(); - statements.add(initialization); + RDLSpecInitialization initialization = parseRDLSpecInitialization(rdlSpec); + rdlSpec.addRDLSpecStatement(initialization); } else if (S.contains(EQUAL)) { - RDLSpecEquationFormula equationFormula = parseEquationFormula(); - statements.add(equationFormula); + RDLSpecEquationFormula equationFormula = parseEquationFormula(rdlSpec); + rdlSpec.addRDLSpecStatement(equationFormula); } else { - RDLSpecDependency dependency = parseDependency(); + RDLSpecDependency dependency = parseDependency(rdlSpec); RDLSpecDependencyFormula dependencyFormula = new RDLSpecDependencyFormula(dependency); - statements.add(dependencyFormula); + rdlSpec.addRDLSpecStatement(dependencyFormula); } } - statements.add(resourceDeclaration); - statements.sort(Comparator.comparing(obj -> { - if (obj.isRDLSpecResourceDeclaration()) { - return 1; - } - if (obj.isRDLSpecInitialization()) { - return 2; - } - return 3; - })); - for (int i = 0; i < statements.size(); i++) { - System.out.println(statements.get(i)); - } + System.out.println(rdlSpec); } - private static RDLSpecInitialization parseRDLSpecInitialization() { + public static void main(String[] args) { + rdlParser(); + } + + private static RDLSpecInitialization parseRDLSpecInitialization(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm leftSideHand; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - leftSideHand = parseDependencyTerm(); + leftSideHand = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - leftSideHand = parseResource(); + leftSideHand = parseResource(rdlSpec); } expect(COLON_EQUAL); @@ -83,26 +75,26 @@ if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - rightSideHand = parseDependencyTerm(); + rightSideHand = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - rightSideHand = parseResource(); + rightSideHand = parseResource(rdlSpec); } return new RDLSpecInitialization(leftSideHand, rightSideHand); } - private static RDLSpecEquationFormula parseEquationFormula() { + private static RDLSpecEquationFormula parseEquationFormula(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm leftEvaluatableTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - leftEvaluatableTerm = parseDependencyTerm(); + leftEvaluatableTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - leftEvaluatableTerm = parseResource(); + leftEvaluatableTerm = parseResource(rdlSpec); } - if(!(tokenStream.checkNext().equals(EQUAL))) { + if (!(tokenStream.checkNext().equals(EQUAL))) { throw new RuntimeException("Syntax Error"); } else { expect(EQUAL); @@ -111,16 +103,16 @@ RDLSpecEvaluatableTerm rightEvaluatableTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - rightEvaluatableTerm = parseDependencyTerm(); + rightEvaluatableTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - rightEvaluatableTerm = parseResource(); + rightEvaluatableTerm = parseResource(rdlSpec); } - return new RDLSpecEquationFormula(leftEvaluatableTerm,rightEvaluatableTerm); + return new RDLSpecEquationFormula(leftEvaluatableTerm, rightEvaluatableTerm); } - private static RDLSpecDependency parseDependency() { + private static RDLSpecDependency parseDependency(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm dependingTerm = null; RDLSpecDependency dependingTermDependency = null; @@ -128,28 +120,28 @@ expect(LEFT_SQUARE_BRACKET); tokenStream.markLine(); try { - dependingTerm = parseDependencyTerm(); + dependingTerm = parseDependencyTerm(rdlSpec); } catch (RuntimeException e) { - tokenStream.backLastLine(); - dependingTermDependency = parseDependency(); + tokenStream.recoverLastLine(); + dependingTermDependency = parseDependency(rdlSpec); } expect(RIGHT_SQUARE_BRACKET); } else { - dependingTerm = parseResource(); + dependingTerm = parseResource(rdlSpec); } expect(COLON); List dependedTerms = new ArrayList<>(); - while(true) { + while (true) { RDLSpecEvaluatableTerm dependedTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - dependedTerm = parseDependencyTerm(); + dependedTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - dependedTerm = parseResource(); + dependedTerm = parseResource(rdlSpec); } dependedTerms.add(dependedTerm); @@ -168,15 +160,15 @@ } } - private static RDLTerm parseRDLTerm() { + private static RDLTerm parseRDLTerm(RDLSpec rdlSpec) { RDLTerm leftEvaluatableTerm; boolean isDependency = false; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - leftEvaluatableTerm = parseRDLTerm(); + leftEvaluatableTerm = parseRDLTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - leftEvaluatableTerm = (RDLTerm) parseResource(); + leftEvaluatableTerm = (RDLTerm) parseResource(rdlSpec); } expect(COLON); @@ -186,10 +178,10 @@ RDLSpecEvaluatableTerm dependedTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - dependedTerm = parseDependencyTerm(); + dependedTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - dependedTerm = parseResource(); + dependedTerm = parseResource(rdlSpec); } if (tokenStream.checkNext().equals(ARROW)) { @@ -198,10 +190,10 @@ if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - argTerm = parseDependencyTerm(); + argTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - argTerm = parseResource(); + argTerm = parseResource(rdlSpec); } terms.add(dependedTerm); @@ -231,15 +223,15 @@ } } - private static RDLSpecEvaluatableTerm parseDependencyTerm() { + private static RDLSpecEvaluatableTerm parseDependencyTerm(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm leftEvaluatableTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - leftEvaluatableTerm = parseDependencyTerm(); + leftEvaluatableTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - leftEvaluatableTerm = parseResource(); + leftEvaluatableTerm = parseResource(rdlSpec); } expect(COLON); @@ -249,10 +241,10 @@ RDLSpecEvaluatableTerm dependedTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - dependedTerm = parseDependencyTerm(); + dependedTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - dependedTerm = parseResource(); + dependedTerm = parseResource(rdlSpec); } expect(ARROW); @@ -260,10 +252,10 @@ RDLSpecEvaluatableTerm argTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { expect(LEFT_SQUARE_BRACKET); - argTerm = parseDependencyTerm(); + argTerm = parseDependencyTerm(rdlSpec); expect(RIGHT_SQUARE_BRACKET); } else { - argTerm = parseResource(); + argTerm = parseResource(rdlSpec); } terms.add(dependedTerm); @@ -278,7 +270,7 @@ return new RDLSpecDependencyTerm(leftEvaluatableTerm, terms); } - private static RDLSpecEvaluatableTerm parseResource() { + private static RDLSpecEvaluatableTerm parseResource(RDLSpec rdlSpec) { if (tokenStream.checkNext().equals(DOUBLE_QUOT)) { expect(DOUBLE_QUOT); String name; @@ -289,7 +281,7 @@ name = tokenStream.next(); } - RDLSpecResourceConstant resourceConstant = new RDLSpecResourceConstant(name, new Type("primitive","primitive"), new Type("string","string")); + RDLSpecResourceConstant resourceConstant = new RDLSpecResourceConstant(name, StructuralType.primitive, RDLSpecLang.typeString); expect(DOUBLE_QUOT); return resourceConstant; } @@ -303,34 +295,33 @@ RDLSpecResource resource; if (resourceName.equals("true") || resourceName.equals("false")) { - return new RDLSpecResourceConstant(resourceName, new Type("primitive","primitive"), new Type("boolean","boolean")); + return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeBoolean); } if (isInt(resourceName)) { - return new RDLSpecResourceConstant(resourceName, new Type("primitive","primitive"), new Type("int","int")); + return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeInt); } if (!isInt(resourceName) && isDouble(resourceName)) { - return new RDLSpecResourceConstant(resourceName, new Type("primitive","primitive"), new Type("double","double")); + return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeDouble); } - if (!resourceDeclaration.containsResource(resourceName)) { + if (rdlSpec.getRDLSpecResourceDeclaration(resourceName) == null) { throw new RuntimeException("resourceが存在しません : " + resourceName); } if (tokenStream.checkNext() != null && tokenStream.checkNext().equals(PRIME)) { //id型判定はresourceDeclarationクラスに書いた expect(PRIME); - resource = resourceDeclaration.getRDLSpecResource(resourceName, true); + resource = rdlSpec.getRDLSpecResourceDeclaration(resourceName).getPrimedResource(); } else { - resource = resourceDeclaration.getRDLSpecResource(resourceName, false); + resource = rdlSpec.getRDLSpecResourceDeclaration(resourceName).getResource(); } return resource; } - //TODO staticは後で消す. - private static RDLSpecResource parseResourceDeclaration() { + private static RDLSpecResourceDeclaration parseResourceDeclaration(RDLSpec rdlSpec) { String resourceName = tokenStream.next(); if (resourceName == null) { @@ -350,23 +341,23 @@ if (tokenStream.checkNext().equals("id")) { String structuralType = tokenStream.next(); expect(COMMA); - String valuableType = tokenStream.next(); - resourceDeclaration.putRDLSpecResource(resourceName, order, new Type(structuralType, structuralType), new Type(valuableType, valuableType)); - return resourceDeclaration.getRDLSpecResource(resourceName, false); + String valueType = tokenStream.next(); + rdlSpec.putResourceMap(resourceName, order, StructuralType.id, new ValueType(valueType)); + return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } else if (tokenStream.checkNext().equals("struct")) { String structuralType = tokenStream.next(); - resourceDeclaration.putRDLSpecResource(resourceName, order, new Type(structuralType, structuralType), null); - return resourceDeclaration.getRDLSpecResource(resourceName, false); + rdlSpec.putResourceMap(resourceName, order, StructuralType.structure, null); + return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } else { String structuralType = "primitive"; - String valuableType = tokenStream.next(); + String valueType = tokenStream.next(); - if (valuableType == null) { - throw new NullPointerException("need valuableType"); + if (valueType == null) { + throw new NullPointerException("need valueType"); } - resourceDeclaration.putRDLSpecResource(resourceName, order, new Type(structuralType, structuralType), new Type(valuableType, valuableType)); - return resourceDeclaration.getRDLSpecResource(resourceName, false); + rdlSpec.putResourceMap(resourceName, order, StructuralType.primitive, new ValueType(valueType)); + return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } } @@ -397,7 +388,7 @@ } private static void expect(String expect) { - if (tokenStream.checkNext() == null||!tokenStream.checkNext().equals(expect)) { + if (tokenStream.checkNext() == null || !tokenStream.checkNext().equals(expect)) { throw new RuntimeException("expect : " + expect + " but : " + tokenStream.checkNext() + "."); } else { tokenStream.next(); @@ -464,6 +455,7 @@ private ArrayList splitByDoubleQuotation(String line) { ArrayList newTokens = new ArrayList<>(); String[] tokens = line.split(DOUBLE_QUOT); + System.out.println(line); boolean fFirstToken = true; for (int i = 0; i < tokens.length; i++) { String token = tokens[i]; @@ -483,7 +475,19 @@ fFirstToken = false; } if (line.endsWith(DOUBLE_QUOT)) { - newTokens.add(new Token(DOUBLE_QUOT, true)); + int pos = line.length() - 1; + for (int i = line.length() - 1; i >= 0; i--) { + if (!(line.charAt(i) == '\"')) { + pos = i + 1; + break; + } + } + for (int i = pos; i < line.length(); i++) { + newTokens.add(new Token(DOUBLE_QUOT, true)); + if (i != line.length() - 1) { + newTokens.add(new Token("", true)); + } + } } return newTokens; } @@ -537,8 +541,8 @@ markNs.add(n); } - public void backLastLine() { - if (markLines.isEmpty()){ + public void recoverLastLine() { + if (markLines.isEmpty()) { throw new NullPointerException("mark is empty"); } line = markLines.pollLast();