diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java index 89a2ac1..7a71c09 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpec.java @@ -5,16 +5,22 @@ public class RDLSpec { private Map resourceMap; private List rdlSpecStatements; + private Map> rdlSpecResourceConstantMap; public RDLSpec() { resourceMap = new HashMap<>(); rdlSpecStatements = new ArrayList<>(); + rdlSpecResourceConstantMap = new HashMap<>(); } - public void putRDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { + public void addRDLSpecResourceDeclaration(String name, int order, StructuralType structuralType, ValueType valueType) { resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, structuralType, valueType)); } + public void addRDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resourceMap.put(name, new RDLSpecResourceDeclaration(name, order, valueType)); + } + public RDLSpecResourceDeclaration getRDLSpecResourceDeclaration(String name) { if (!resourceMap.containsKey(name)) { return null; @@ -22,6 +28,40 @@ return resourceMap.get(name); } + public RDLSpecResourceConstant getConstant(String value, ValueType valueType) { + if (rdlSpecResourceConstantMap.containsKey(value)) { + if (rdlSpecResourceConstantMap.get(value).containsKey(valueType)) { + return rdlSpecResourceConstantMap.get(value).get(valueType); + } else { + rdlSpecResourceConstantMap.get(value).put(valueType,new RDLSpecResourceConstant(value, valueType)); + } + } else { + rdlSpecResourceConstantMap.put(value, new HashMap<>()); + rdlSpecResourceConstantMap.get(value).put(valueType, new RDLSpecResourceConstant(value, valueType)); + } + return rdlSpecResourceConstantMap.get(value).get(valueType); + } + + public RDLSpecResourceConstant getTrue() { + if (!rdlSpecResourceConstantMap.containsKey("true")) { + rdlSpecResourceConstantMap.put("true", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("true").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("true").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("true", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("true").get(RDLSpecLang.typeBoolean); + } + + public RDLSpecResourceConstant getFalse() { + if (!rdlSpecResourceConstantMap.containsKey("false")) { + rdlSpecResourceConstantMap.put("false", new HashMap<>()); + if (!rdlSpecResourceConstantMap.get("false").containsKey(RDLSpecLang.typeBoolean)) { + rdlSpecResourceConstantMap.get("false").put(RDLSpecLang.typeBoolean, new RDLSpecResourceConstant("false", RDLSpecLang.typeBoolean)); + } + } + return rdlSpecResourceConstantMap.get("false").get(RDLSpecLang.typeBoolean); + } + public void addRDLSpecStatement(RDLSpecStatement rdlSpecStatement) { rdlSpecStatements.add(rdlSpecStatement); rdlSpecStatements.sort(Comparator.comparing(obj -> { diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java index 00ea7af..363a328 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecDependencyTerm.java @@ -10,13 +10,13 @@ private StructuralType structuralType; private ValueType valuableType; - public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List terms) { - super((EvaluatableTerm) dependingTerm, terms.stream().map(item -> (EvaluatableTerm) item).toList()); + public RDLSpecDependencyTerm(RDLSpecEvaluatableTerm dependingTerm, List dependedTerms, List argumentTerms) { + super((EvaluatableTerm) dependingTerm, dependedTerms.stream().map(item -> (EvaluatableTerm) item).toList(), argumentTerms.stream().map(item -> (EvaluatableTerm) item).toList()); 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))) { + for (int i = 0; i < dependedTerms.size(); i ++) { + if (!typeChecker(dependedTerms.get(i), argumentTerms.get(i))) { throw new SyntaxException("the type is different"); } } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java index 2e55e70..230176d 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecLang.java @@ -1,8 +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"); + public static final ValueType typeString = new ValueType("string"); + public static final ValueType typeInt = new ValueType("int"); + public static final ValueType typeBoolean = new ValueType("boolean"); + public static final ValueType typeDouble = new ValueType("double"); } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java index 70197dc..b682ba2 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceConstant.java @@ -6,9 +6,9 @@ private StructuralType structuralType; private ValueType valueType; - public RDLSpecResourceConstant(String name, StructuralType structuralType, ValueType valueType) { - super(name); - this.structuralType = structuralType; + public RDLSpecResourceConstant(String value, ValueType valueType) { + super(value); + this.structuralType = StructuralType.primitive; this.valueType = valueType; } diff --git a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java index 732db28..c488099 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/RDLSpecResourceDeclaration.java @@ -15,6 +15,11 @@ } } + public RDLSpecResourceDeclaration(String name, int order, ValueType valueType) { + resource = new RDLSpecResource(name, order, valueType); + primedResource = null; + } + public RDLSpecResource getResource() { return resource; } diff --git a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java index 2e0ce42..d2f0689 100644 --- a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java +++ b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java @@ -1,9 +1,9 @@ package org.ntlab.rdlworkbench.rdlparser; -import exceptions.SyntaxException; -import models.terms.*; import org.ntlab.rdlworkbench.models.*; +import java.io.BufferedReader; +import java.io.IOException; import java.util.*; public class RDLParser { @@ -25,7 +25,36 @@ public static final String PRIME = "'"; public static final String ARROW = "->"; - public static void rdlParser() { + public RDLSpec parseRDL(final BufferedReader reader) { + RDLSpec rdlSpec = new RDLSpec(); + try { + String line; + while ((line = reader.readLine()) != null) { + tokenStream = new TokenStream(); + tokenStream.addLine(line); + if (line.contains(LEFT_BRACKET)) { + RDLSpecResourceDeclaration resourceDeclaration = parseResourceDeclaration(rdlSpec); + rdlSpec.addRDLSpecStatement(resourceDeclaration); + } else if (line.contains(COLON_EQUAL)) { + RDLSpecInitialization initialization = parseRDLSpecInitialization(rdlSpec); + rdlSpec.addRDLSpecStatement(initialization); + } else if (line.contains(EQUAL)) { + RDLSpecEquationFormula equationFormula = parseEquationFormula(rdlSpec); + rdlSpec.addRDLSpecStatement(equationFormula); + } else { + RDLSpecDependency dependency = parseDependency(rdlSpec); + RDLSpecDependencyFormula dependencyFormula = new RDLSpecDependencyFormula(dependency); + rdlSpec.addRDLSpecStatement(dependencyFormula); + } + } + reader.close(); + } catch (IOException e) { + e.printStackTrace(); + } + return rdlSpec; + } + + public RDLSpec parseRDL() { Scanner sc = new Scanner(System.in); RDLSpec rdlSpec = new RDLSpec(); while (true) { @@ -52,11 +81,7 @@ rdlSpec.addRDLSpecStatement(dependencyFormula); } } - System.out.println(rdlSpec); - } - - public static void main(String[] args) { - rdlParser(); + return rdlSpec; } private static RDLSpecInitialization parseRDLSpecInitialization(RDLSpec rdlSpec) { @@ -160,69 +185,6 @@ } } - private static RDLTerm parseRDLTerm(RDLSpec rdlSpec) { - RDLTerm leftEvaluatableTerm; - boolean isDependency = false; - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - leftEvaluatableTerm = parseRDLTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - leftEvaluatableTerm = (RDLTerm) parseResource(rdlSpec); - } - - expect(COLON); - List terms = new ArrayList<>(); - - while (true) { - RDLSpecEvaluatableTerm dependedTerm; - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - dependedTerm = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - dependedTerm = parseResource(rdlSpec); - } - - if (tokenStream.checkNext().equals(ARROW)) { - expect(ARROW); - RDLSpecEvaluatableTerm argTerm; - - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - argTerm = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - argTerm = parseResource(rdlSpec); - } - - terms.add(dependedTerm); - terms.add(argTerm); - } else { - isDependency = true; - terms.add(dependedTerm); - } - - if (!tokenStream.checkNext().equals(COMMA)) { - break; - } else { - expect(COMMA); - } - } - - if (isDependency) { - if (leftEvaluatableTerm instanceof RDLSpecEvaluatableTerm) { - return new RDLSpecDependency((RDLSpecEvaluatableTerm) leftEvaluatableTerm, terms); - } - if (leftEvaluatableTerm instanceof RDLSpecDependency) { - return new RDLSpecDependency((RDLSpecDependency) leftEvaluatableTerm, terms); - } - throw new SyntaxException(); - } else { - return new RDLSpecDependencyTerm((RDLSpecEvaluatableTerm) leftEvaluatableTerm, terms); - } - } - private static RDLSpecEvaluatableTerm parseDependencyTerm(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm leftEvaluatableTerm; @@ -235,8 +197,8 @@ } expect(COLON); - List terms = new ArrayList<>(); - + List dependedTerms = new ArrayList<>(); + List argumentTerms = new ArrayList<>(); while (true) { RDLSpecEvaluatableTerm dependedTerm; if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { @@ -258,8 +220,8 @@ argTerm = parseResource(rdlSpec); } - terms.add(dependedTerm); - terms.add(argTerm); + dependedTerms.add(dependedTerm); + argumentTerms.add(argTerm); if (!tokenStream.checkNext().equals(COMMA)) { break; @@ -267,7 +229,7 @@ expect(COMMA); } } - return new RDLSpecDependencyTerm(leftEvaluatableTerm, terms); + return new RDLSpecDependencyTerm(leftEvaluatableTerm, dependedTerms, argumentTerms); } private static RDLSpecEvaluatableTerm parseResource(RDLSpec rdlSpec) { @@ -281,9 +243,8 @@ name = tokenStream.next(); } - RDLSpecResourceConstant resourceConstant = new RDLSpecResourceConstant(name, StructuralType.primitive, RDLSpecLang.typeString); expect(DOUBLE_QUOT); - return resourceConstant; + return rdlSpec.getConstant(name, RDLSpecLang.typeString); } String resourceName = tokenStream.next(); @@ -294,16 +255,20 @@ RDLSpecResource resource; - if (resourceName.equals("true") || resourceName.equals("false")) { - return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeBoolean); + if (resourceName.equals("true")) { + return rdlSpec.getTrue(); + } + + if (resourceName.equals("false")) { + return rdlSpec.getFalse(); } if (isInt(resourceName)) { - return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeInt); + return rdlSpec.getConstant(resourceName, RDLSpecLang.typeInt); } if (!isInt(resourceName) && isDouble(resourceName)) { - return new RDLSpecResourceConstant(resourceName, StructuralType.primitive, RDLSpecLang.typeDouble); + return rdlSpec.getConstant(resourceName, RDLSpecLang.typeDouble); } if (rdlSpec.getRDLSpecResourceDeclaration(resourceName) == null) { @@ -342,11 +307,11 @@ String structuralType = tokenStream.next(); expect(COMMA); String valueType = tokenStream.next(); - rdlSpec.putRDLSpecResourceDeclaration(resourceName, order, StructuralType.id, new ValueType(valueType)); + rdlSpec.addRDLSpecResourceDeclaration(resourceName, order, StructuralType.id, new ValueType(valueType)); return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } else if (tokenStream.checkNext().equals("struct")) { String structuralType = tokenStream.next(); - rdlSpec.putRDLSpecResourceDeclaration(resourceName, order, StructuralType.structure, null); + rdlSpec.addRDLSpecResourceDeclaration(resourceName, order, StructuralType.structure, null); return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } else { String structuralType = "primitive"; @@ -356,7 +321,7 @@ throw new NullPointerException("need valueType"); } - rdlSpec.putRDLSpecResourceDeclaration(resourceName, order, StructuralType.primitive, new ValueType(valueType)); + rdlSpec.addRDLSpecResourceDeclaration(resourceName, order, new ValueType(valueType)); return rdlSpec.getRDLSpecResourceDeclaration(resourceName); } }