diff --git a/src/main/java/org/ntlab/rdlworkbench/Main.java b/src/main/java/org/ntlab/rdlworkbench/Main.java index 1e0414e..26abb15 100644 --- a/src/main/java/org/ntlab/rdlworkbench/Main.java +++ b/src/main/java/org/ntlab/rdlworkbench/Main.java @@ -8,6 +8,7 @@ public static void main(String[] args) { RDLParser rdl = new RDLParser(); RDLSpec rdlSpec = rdl.parseRDL(); + System.out.println(rdlSpec); ASTGenerator astGenerator = new ASTGenerator(rdlSpec); System.out.println(astGenerator.generate()); } diff --git a/src/main/java/org/ntlab/rdlworkbench/generator/ASTGenerator.java b/src/main/java/org/ntlab/rdlworkbench/generator/ASTGenerator.java index 8f2e00f..19b6ae4 100644 --- a/src/main/java/org/ntlab/rdlworkbench/generator/ASTGenerator.java +++ b/src/main/java/org/ntlab/rdlworkbench/generator/ASTGenerator.java @@ -7,23 +7,28 @@ import java.util.*; public class ASTGenerator { - private static Annotation override = new Annotation("Override"); + private Annotation override = new Annotation("Override"); private List rdlSpecStatements = new ArrayList<>(); private RDLSpec spec; private static final List getValueArgumentList = List.of("tableId", "key", "columnNo"); - private static final List setWidgetTextArgumentList = List.of("scId", "wId", "wText"); - private static final List setWidgetColorArgumentList = List.of("scId", "wId", "wColor"); - private static final List setWidgetVisibilityArgumentList = List.of("scId", "wId", "wVisible"); - private static final List setWidgetEnabledArgumentList = List.of("scId", "wId", "wEnabled"); + private static final List setWidgetTextArgumentList = List.of("scId", "wId", "value"); + private static final List setWidgetColorArgumentList = List.of("scId", "wId", "value"); + private static final List setWidgetVisibilityArgumentList = List.of("scId", "wId", "value"); + private static final List setWidgetEnabledArgumentList = List.of("scId", "wId", "value"); private static final List changeScreenArgumentList = List.of("curScId"); - private static final List updateValueArgumentList = List.of("tableId", "key", "columnNo", "wText"); + private static final List updateValueArgumentList = List.of("tableId", "key", "columnNo", "value"); private static final List getCurWidgetTextArgumentList = List.of("wId"); private static final List getCurTableKeyArgumentList = List.of("tableId"); private static final List getWidgetTextArgumentList = List.of("scId", "wId"); private static final List getCurWidgetStateArgumentList = List.of("wId"); - private static final List setCurWidgetTextArgumentList = List.of("wId", "wText"); - private static final List setCurWidgetVisibilityArgumentList = List.of("wId", "wVisible"); - private static final List setCurWidgetEnabledArgumentList = List.of("wId", "wEnabled"); + private static final List setCurWidgetTextArgumentList = List.of("wId", "value"); + private static final List setCurWidgetVisibilityArgumentList = List.of("wId", "value"); + private static final List setCurWidgetEnabledArgumentList = List.of("wId", "value"); + private static final List addSignature = List.of("add", "add1", "add2"); + private static final List subSignature = List.of("sub", "sub1", "sub2"); + private static final List mulSignature = List.of("mul", "mul1", "mul2"); + private static final List divSignature = List.of("div", "div1", "div2"); + private static final List minusSignature = List.of("minus", "minus1"); public ASTGenerator (RDLSpec spec) { this.spec = spec; @@ -81,42 +86,54 @@ HashMap argumentsMap = new HashMap<>(); if (mostLeftResourceInLeftSideHand.startsWith("w")) {//left input location, right input content HashMap rightSideHandArgumentsMap = new HashMap<>(); - mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, rightSideHandArgumentsMap, null); - mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, null); + if (!(rightSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, rightSideHandArgumentsMap, null); + } + if (!(leftSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, null); + } if (rightSideHand instanceof RDLSpecResourceConstant) { if (((RDLSpecResourceConstant) rightSideHand).getValueType().getName().equals("string")) { - argumentsMap.put(mostLeftResourceInLeftSideHand, new Constant("\"" + ((RDLSpecResourceConstant) rightSideHand).getName() + "\"")); + argumentsMap.put("value", new Constant("\"" + ((RDLSpecResourceConstant) rightSideHand).getName() + "\"")); } else { - argumentsMap.put(mostLeftResourceInLeftSideHand, new Constant(((RDLSpecResourceConstant) rightSideHand).getName())); + argumentsMap.put("value", new Constant(((RDLSpecResourceConstant) rightSideHand).getName())); } } else { Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(mostLeftResourceInRightSideHand, expression, argumentList, rightSideHandArgumentsMap); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); - argumentsMap.put(mostLeftResourceInLeftSideHand, expression); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } + argumentsMap.put("value", expression); } List arguments = new ArrayList<>(); beforeEventMethodExpression = createSetWidgetMethodExpression(mostLeftResourceInLeftSideHand, beforeEventMethodExpression, arguments, argumentsMap); ((MethodInvocation) beforeEventMethodExpression).setArguments(arguments); } else if (mostLeftResourceInRightSideHand.startsWith("w")) {//right input location, left input content HashMap leftSideHandArgumentsMap = new HashMap<>(); - mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, leftSideHandArgumentsMap, null); - mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, argumentsMap, null); + if (!(leftSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, leftSideHandArgumentsMap, null); + } + if (!(rightSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, argumentsMap, null); + } if (leftSideHand instanceof RDLSpecResourceConstant) { if (((RDLSpecResourceConstant) leftSideHand).getValueType().getName().equals("string")) { - argumentsMap.put(mostLeftResourceInRightSideHand, new Constant("\"" + ((RDLSpecResourceConstant) leftSideHand).getName() + "\"")); + argumentsMap.put("value", new Constant("\"" + ((RDLSpecResourceConstant) leftSideHand).getName() + "\"")); } else { - argumentsMap.put(mostLeftResourceInRightSideHand, new Constant(((RDLSpecResourceConstant) leftSideHand).getName())); + argumentsMap.put("value", new Constant(((RDLSpecResourceConstant) leftSideHand).getName())); } } else { Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(mostLeftResourceInLeftSideHand, expression, argumentList, leftSideHandArgumentsMap); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); - argumentsMap.put(mostLeftResourceInRightSideHand, expression); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } + argumentsMap.put("value", expression); } List arguments = new ArrayList<>(); beforeEventMethodExpression = createSetWidgetMethodExpression(mostLeftResourceInRightSideHand, beforeEventMethodExpression, arguments, argumentsMap); @@ -158,41 +175,53 @@ HashMap argumentsMap = new HashMap<>(); if (mostLeftResourceInLeftSideHand.startsWith("w")) {//left input location, right input content HashMap rightSideHandArgumentsMap = new HashMap<>(); - mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, rightSideHandArgumentsMap, null); - mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, null); + if (!(rightSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, rightSideHandArgumentsMap, null); + } + if (!(leftSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, null); + } if (rightSideHand instanceof RDLSpecResourceConstant) { if (((RDLSpecResourceConstant) rightSideHand).getValueType().getName().equals("string")) { - argumentsMap.put(mostLeftResourceInLeftSideHand, new Constant("\"" + ((RDLSpecResourceConstant) rightSideHand).getName() + "\"")); + argumentsMap.put("value", new Constant("\"" + ((RDLSpecResourceConstant) rightSideHand).getName() + "\"")); } else { - argumentsMap.put(mostLeftResourceInLeftSideHand, new Constant(((RDLSpecResourceConstant) rightSideHand).getName())); + argumentsMap.put("value", new Constant(((RDLSpecResourceConstant) rightSideHand).getName())); } } else { Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(mostLeftResourceInRightSideHand, expression, argumentList, rightSideHandArgumentsMap); - ((MethodInvocation) expression).setArguments(argumentList); - argumentsMap.put(mostLeftResourceInLeftSideHand, expression); + if (!argumentList.isEmpty()) { + ((MethodInvocation) expression).setArguments(argumentList); + } + argumentsMap.put("value", expression); } List arguments = new ArrayList<>(); afterEventMethodExpression = createSetWidgetMethodExpression(mostLeftResourceInLeftSideHand, afterEventMethodExpression, arguments, argumentsMap); ((MethodInvocation) afterEventMethodExpression).setArguments(arguments); } else if (mostLeftResourceInRightSideHand.startsWith("w")) {//right input location, left input content HashMap leftSideHandArgumentsMap = new HashMap<>(); - mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, leftSideHandArgumentsMap, null); - mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, argumentsMap, null); + if (!(leftSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, leftSideHandArgumentsMap, null); + } + if (!(rightSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInRightSideHand = setArguments(rightSideHand, null, argumentsMap, null); + } if (leftSideHand instanceof RDLSpecResourceConstant) { if (((RDLSpecResourceConstant) leftSideHand).getValueType().getName().equals("string")) { - argumentsMap.put(mostLeftResourceInRightSideHand, new Constant("\"" + ((RDLSpecResourceConstant) leftSideHand).getName() + "\"")); + argumentsMap.put("value", new Constant("\"" + ((RDLSpecResourceConstant) leftSideHand).getName() + "\"")); } else { - argumentsMap.put(mostLeftResourceInRightSideHand, new Constant(((RDLSpecResourceConstant) leftSideHand).getName())); + argumentsMap.put("value", new Constant(((RDLSpecResourceConstant) leftSideHand).getName())); } } else { Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(mostLeftResourceInLeftSideHand, expression, argumentList, leftSideHandArgumentsMap); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); - argumentsMap.put(mostLeftResourceInRightSideHand, expression); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } + argumentsMap.put("value", expression); } List arguments = new ArrayList<>(); afterEventMethodExpression = createSetWidgetMethodExpression(mostLeftResourceInRightSideHand, afterEventMethodExpression, arguments, argumentsMap); @@ -239,8 +268,10 @@ Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(argumentTermDependingTermName, expression, argumentList, argumentTermsArguments); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } ifStatement = createConditionalExpression(dependedTermsArguments, dependedTermName, expression, ifStatement); } continue; @@ -258,9 +289,11 @@ Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(argumentLeftResourceName, expression, argumentList, argumentTermsArguments); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); - expressionMap.put(argumentLeftResourceName, expression); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } + expressionMap.put(dependedTermName, expression); } else if (argumentTerms.get(i) instanceof RDLSpecResourceConstant) { if (((RDLSpecResourceConstant) argumentTerms.get(i)).getValueType().getName().equals("string")) { expressionMap.put(dependedTermName, new Constant("\"" + ((RDLSpecResourceConstant) argumentTerms.get(i)).getName() + "\"")); @@ -322,7 +355,10 @@ if (containsDependencyTermOnDependedTerms(leftSideHand)) { IfStatement ifStatement = new IfStatement(); HashMap argumentsMap = new HashMap<>(); - String mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, ifStatement); + String mostLeftResourceInLeftSideHand = getMostLeftResource(leftSideHand); + if (!(leftSideHand instanceof RDLSpecResourceConstant)) { + mostLeftResourceInLeftSideHand = setArguments(leftSideHand, null, argumentsMap, ifStatement); + } List dependedTerms = ((RDLSpecDependencyTerm) leftSideHand).getDependedTerms().stream().map(item -> (RDLSpecEvaluatableTerm) item).toList(); List argumentTerms = ((RDLSpecDependencyTerm) leftSideHand).getArgumentTerms().stream().map(item -> (RDLSpecEvaluatableTerm) item).toList(); String variable = getMostLeftResource(dependedTerms.get(0)).substring(1); @@ -465,6 +501,38 @@ } else { throw new SyntaxException("state is getCurWidgetState only"); } + } else if (variable.equals(addSignature.get(0))) { + Expression left = null; + Expression right = null; + left = argumentsMap.get(addSignature.get(1)); + right = argumentsMap.get(addSignature.get(2)); + method = new InfixExpression("+", left, right); + method = new ParenthesizedExpression(method); + } else if (variable.equals(subSignature.get(0))) { + Expression left = null; + Expression right = null; + left = argumentsMap.get(subSignature.get(1)); + right = argumentsMap.get(subSignature.get(2)); + method = new InfixExpression("-", left, right); + method = new ParenthesizedExpression(method); + } else if (variable.equals(mulSignature.get(0))) { + Expression left = null; + Expression right = null; + left = argumentsMap.get(mulSignature.get(1)); + right = argumentsMap.get(mulSignature.get(2)); + method = new InfixExpression("*", left, right); + method = new ParenthesizedExpression(method); + } else if (variable.equals(divSignature.get(0))) { + Expression left = null; + Expression right = null; + left = argumentsMap.get(divSignature.get(1)); + right = argumentsMap.get(divSignature.get(2)); + method = new InfixExpression("/", left, right); + method = new ParenthesizedExpression(method); + } else if (variable.equals(minusSignature.get(0))) { + Expression minusExpression = argumentsMap.get(minusSignature.get(1)); + method = new InfixExpression("*", new Constant("-1"), minusExpression); + method = new ParenthesizedExpression(method); } return method; } @@ -493,7 +561,7 @@ } } - private static boolean containsDependencyTermOnDependedTerms(RDLSpecEvaluatableTerm evaluatableTerm) { + private boolean containsDependencyTermOnDependedTerms(RDLSpecEvaluatableTerm evaluatableTerm) { if (evaluatableTerm.isDependencyTerm()) { List dependedTerms = ((RDLSpecDependencyTerm) evaluatableTerm).getDependedTerms().stream().map(item -> (RDLSpecEvaluatableTerm) item).toList(); for (RDLSpecEvaluatableTerm terms : dependedTerms) { @@ -605,15 +673,19 @@ Expression expression = new Constant("runtime"); List argumentList = new ArrayList<>(); expression = createGetWidgetMethodExpression(mostLeftResourceInRightSideHand, expression, argumentList, rightSideHandArguments); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(argumentList); - argumentsMap.put(mostLeftResourceInRightSideHand, expression); + if (!argumentList.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(argumentList); + } + argumentsMap.put("value", expression); } List arguments = new ArrayList<>(); Expression expression = new Constant("runtime"); expression = createSetWidgetMethodExpression(mostLeftResourceInLeftSideHand, expression, arguments, argumentsMap); - assert expression instanceof MethodInvocation; - ((MethodInvocation) expression).setArguments(arguments); + if (!arguments.isEmpty()) { + assert expression instanceof MethodInvocation; + ((MethodInvocation) expression).setArguments(arguments); + } ExpressionStatement expressionStatement = new ExpressionStatement(expression); Block block = new Block(); if (ifStatement.getThenStatement() != null) { diff --git a/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java b/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java index f989e11..46dfe4d 100644 --- a/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java +++ b/src/main/java/org/ntlab/rdlworkbench/models/ValueType.java @@ -18,4 +18,9 @@ } return name.equals(((ValueType) obj).name); } + + @Override + public String toString() { + return name; + } } diff --git a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java index f5e3c74..6e48340 100644 --- a/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java +++ b/src/main/java/org/ntlab/rdlworkbench/rdlparser/RDLParser.java @@ -1,5 +1,6 @@ package org.ntlab.rdlworkbench.rdlparser; +import exceptions.SyntaxException; import org.ntlab.rdlworkbench.models.*; import java.io.BufferedReader; @@ -24,6 +25,27 @@ public static final String DOUBLE_QUOT = "\""; public static final String PRIME = "'"; public static final String ARROW = "->"; + public static final String ADD = "+"; + public static final String ADD_REGX = "\\+"; + public static final String MUL = "*"; + public static final String MUL_REGX = "\\*"; + public static final String SUB = "-"; + public static final String SUB_REGX = "\\-"; + public static final String DIV = "/"; + public static final String ADD_RES = "add"; + public static final String ADD_RES1 = "add1"; + public static final String ADD_RES2 = "add2"; + public static final String SUB_RES = "sub"; + public static final String SUB_RES1 = "sub1"; + public static final String SUB_RES2 = "sub2"; + public static final String MUL_RES = "mul"; + public static final String MUL_RES1 = "mul1"; + public static final String MUL_RES2 = "mul2"; + public static final String DIV_RES = "div"; + public static final String DIV_RES1 = "div1"; + public static final String DIV_RES2 = "div2"; + public static final String MINUS = "minus"; + public static final String MINUS1 = "minus1"; public RDLSpec parseRDL(final BufferedReader reader) { RDLSpec rdlSpec = new RDLSpec(); @@ -32,7 +54,7 @@ while ((line = reader.readLine()) != null) { tokenStream = new TokenStream(); tokenStream.addLine(line); - if (line.contains(LEFT_BRACKET)) { + if (line.contains(COLON_COLON)) { RDLSpecResourceDeclaration resourceDeclaration = parseResourceDeclaration(rdlSpec); rdlSpec.addRDLSpecStatement(resourceDeclaration); } else if (line.contains(COLON_EQUAL)) { @@ -66,7 +88,7 @@ tokenStream = new TokenStream(); tokenStream.addLine(S); - if (S.contains(LEFT_BRACKET)) { + if (S.contains(COLON_COLON)) { RDLSpecResourceDeclaration resourceDeclaration = parseResourceDeclaration(rdlSpec); rdlSpec.addRDLSpecStatement(resourceDeclaration); } else if (S.contains(COLON_EQUAL)) { @@ -85,54 +107,23 @@ } private static RDLSpecInitialization parseRDLSpecInitialization(RDLSpec rdlSpec) { - RDLSpecEvaluatableTerm leftSideHand; - - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - leftSideHand = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - leftSideHand = parseResource(rdlSpec); - } + RDLSpecEvaluatableTerm leftSideHand = parsePolynomial(rdlSpec); expect(COLON_EQUAL); - RDLSpecEvaluatableTerm rightSideHand; - - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - rightSideHand = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - rightSideHand = parseResource(rdlSpec); - } + RDLSpecEvaluatableTerm rightSideHand = parsePolynomial(rdlSpec); return new RDLSpecInitialization(leftSideHand, rightSideHand); } private static RDLSpecEquationFormula parseEquationFormula(RDLSpec rdlSpec) { - RDLSpecEvaluatableTerm leftEvaluatableTerm; - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - leftEvaluatableTerm = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - leftEvaluatableTerm = parseResource(rdlSpec); - } - + RDLSpecEvaluatableTerm leftEvaluatableTerm = parsePolynomial(rdlSpec); if (!(tokenStream.checkNext().equals(EQUAL))) { throw new RuntimeException("Syntax Error"); } else { expect(EQUAL); } - RDLSpecEvaluatableTerm rightEvaluatableTerm; - if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { - expect(LEFT_SQUARE_BRACKET); - rightEvaluatableTerm = parseDependencyTerm(rdlSpec); - expect(RIGHT_SQUARE_BRACKET); - } else { - rightEvaluatableTerm = parseResource(rdlSpec); - } + RDLSpecEvaluatableTerm rightEvaluatableTerm = parsePolynomial(rdlSpec); return new RDLSpecEquationFormula(leftEvaluatableTerm, rightEvaluatableTerm); } @@ -185,6 +176,110 @@ } } + //まずこれ + private static RDLSpecEvaluatableTerm parsePolynomial(RDLSpec rdlSpec) { + RDLSpecEvaluatableTerm left = parseMonomial(rdlSpec); + while (true) { + if (tokenStream.checkNext() != null) { + if (tokenStream.checkNext().equals(ADD)) { + expect(ADD); + RDLSpecEvaluatableTerm right = parseMonomial(rdlSpec); + //typeチェック + if (!(((Typable) left).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) left).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("left type is " + ((Typable) left).getValueType().toString()); + } + if (!(((Typable) right).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) right).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("right type is " + ((Typable) right).getValueType().toString()); + } + left = new RDLSpecDependencyTerm(new RDLSpecResource(ADD_RES, 1, ((Typable) left).getValueType()), List.of(new RDLSpecResource(ADD_RES1, 1, ((Typable) left).getValueType()), new RDLSpecResource(ADD_RES2, 1, ((Typable) right).getValueType())), List.of(left, right)); + } else if (tokenStream.checkNext().equals(SUB)) { + expect(SUB); + RDLSpecEvaluatableTerm right = parseMonomial(rdlSpec); + //typeチェック + if (!(((Typable) left).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) left).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("left type is " + ((Typable) left).getValueType().toString()); + } + if (!(((Typable) right).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) right).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("right type is " + ((Typable) right).getValueType().toString()); + } + left = new RDLSpecDependencyTerm(new RDLSpecResource(SUB_RES, 1, ((Typable) left).getValueType()), List.of(new RDLSpecResource(SUB_RES1, 1, ((Typable) left).getValueType()), new RDLSpecResource(SUB_RES2, 1, ((Typable) right).getValueType())), List.of(left, right)); + } else { + break; + } + } else { + break; + } + } + return left; + } + + //次ここ + private static RDLSpecEvaluatableTerm parseMonomial(RDLSpec rdlSpec) { + RDLSpecEvaluatableTerm left = parseParenthesizedExp(rdlSpec); + while (true) { + if (tokenStream.checkNext() != null) { + if (tokenStream.checkNext().equals(MUL)) { + expect(MUL); + RDLSpecEvaluatableTerm right = parseParenthesizedExp(rdlSpec); + //typeチェック + if (!(((Typable) left).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) left).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("left type is " + ((Typable) left).getValueType().toString()); + } + if (!(((Typable) right).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) right).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("right type is " + ((Typable) right).getValueType().toString()); + } + left = new RDLSpecDependencyTerm(new RDLSpecResource(MUL_RES, 1, ((Typable) left).getValueType()), List.of(new RDLSpecResource(MUL_RES1, 1, ((Typable) left).getValueType()), new RDLSpecResource(MUL_RES2, 1, ((Typable) right).getValueType())), List.of(left, right)); + } else if (tokenStream.checkNext().equals(DIV)) { + expect(DIV); + RDLSpecEvaluatableTerm right = parseParenthesizedExp(rdlSpec); + //typeチェック + if (!(((Typable) left).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) left).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("left type is " + ((Typable) left).getValueType().toString()); + } + if (!(((Typable) right).getValueType()).equals(RDLSpecLang.typeInt) && !(((Typable) right).getValueType()).equals(RDLSpecLang.typeDouble)) { + throw new NumberFormatException("right type is " + ((Typable) right).getValueType().toString()); + } + + left = new RDLSpecDependencyTerm(new RDLSpecResource(DIV_RES, 1, ((Typable) left).getValueType()), List.of(new RDLSpecResource(DIV_RES1, 1, ((Typable) left).getValueType()), new RDLSpecResource(DIV_RES2, 1, ((Typable) right).getValueType())), List.of(left, right)); + } else { + break; + } + } else { + break; + } + } + return left; + } + + //最後にここ + private static RDLSpecEvaluatableTerm parseParenthesizedExp(RDLSpec rdlSpec) { + RDLSpecEvaluatableTerm rdlSpecEvaluatableTerm; + if (tokenStream.checkNext().equals(LEFT_BRACKET)) { + expect(LEFT_BRACKET); + rdlSpecEvaluatableTerm = parsePolynomial(rdlSpec); + expect(RIGHT_BRACKET); + } else { + if (tokenStream.checkNext().equals(LEFT_SQUARE_BRACKET)) { + expect(LEFT_SQUARE_BRACKET); + rdlSpecEvaluatableTerm = parseDependencyTerm(rdlSpec); + expect(RIGHT_SQUARE_BRACKET); + } else if (tokenStream.checkNext().equals(SUB)) { + expect(SUB); + rdlSpecEvaluatableTerm = parseParenthesizedExp(rdlSpec); + if (rdlSpecEvaluatableTerm instanceof RDLSpecResourceConstant && (((RDLSpecResourceConstant) rdlSpecEvaluatableTerm).getValueType().equals(RDLSpecLang.typeInt) || ((RDLSpecResourceConstant) rdlSpecEvaluatableTerm).getValueType().equals(RDLSpecLang.typeDouble))) { + return new RDLSpecDependencyTerm(new RDLSpecResource(MINUS, 1, ((RDLSpecResourceConstant)rdlSpecEvaluatableTerm).getValueType()), List.of(new RDLSpecResource(MINUS1, 1, ((RDLSpecResourceConstant)rdlSpecEvaluatableTerm).getValueType())), List.of(rdlSpec.getConstant("-" + ((RDLSpecResourceConstant) rdlSpecEvaluatableTerm).getName(), ((RDLSpecResourceConstant)rdlSpecEvaluatableTerm).getValueType()))); + } else { + if (((Typable)rdlSpecEvaluatableTerm).getValueType().equals(RDLSpecLang.typeDouble) || ((Typable)rdlSpecEvaluatableTerm).getValueType().equals(RDLSpecLang.typeInt)) { + return new RDLSpecDependencyTerm(new RDLSpecResource(MINUS, 1, ((Typable)rdlSpecEvaluatableTerm).getValueType()), List.of(new RDLSpecResource(MINUS1, 1, ((Typable)rdlSpecEvaluatableTerm).getValueType())), List.of(rdlSpecEvaluatableTerm)); + } + } + } else { + rdlSpecEvaluatableTerm = parseResource(rdlSpec); + } + } + return rdlSpecEvaluatableTerm; + } + private static RDLSpecEvaluatableTerm parseDependencyTerm(RDLSpec rdlSpec) { RDLSpecEvaluatableTerm leftEvaluatableTerm; @@ -388,6 +483,10 @@ tokenList = splitBy(tokenList, RIGHT_SQUARE_BRACKET, RIGHT_SQUARE_BRACKET_REGX); tokenList = splitBy(tokenList, PRIME, PRIME); tokenList = splitBy(tokenList, ARROW, ARROW); + tokenList = splitBy(tokenList, ADD, ADD_REGX); + tokenList = splitBy(tokenList, MUL, MUL_REGX); + tokenList = splitBy(tokenList, SUB, SUB_REGX); + tokenList = splitBy(tokenList, DIV, DIV); tokens.add(tokenList); }