From a3e0b3da5d7b0ec8dcae92a428f8e3f1c6cd6e8e Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Fri, 22 Apr 2016 14:29:19 -0400 Subject: Formatting changes --- .../bjc/dicelang/examples/DiceASTLanguageTest.java | 40 ++++++++-------- .../java/bjc/dicelang/examples/DiceASTPragma.java | 3 +- .../dicelang/examples/DiceExpressionPreparer.java | 12 ++--- .../bjc/dicelang/examples/DiceLanguageState.java | 3 +- .../bjc/dicelang/examples/DiceLanguageTest.java | 4 +- .../java/bjc/dicelang/DiceExpressionBuilder.java | 5 +- .../java/bjc/dicelang/DiceExpressionParser.java | 16 +++---- .../main/java/bjc/dicelang/IDiceExpression.java | 6 +-- .../java/bjc/dicelang/OperatorDiceExpression.java | 9 ++-- .../java/bjc/dicelang/ReferenceDiceExpression.java | 3 +- .../java/bjc/dicelang/ScalarDiceExpression.java | 5 +- .../java/bjc/dicelang/ast/ArithmeticCollapser.java | 55 +++++++++++----------- .../java/bjc/dicelang/ast/DiceASTEvaluator.java | 19 ++++---- .../main/java/bjc/dicelang/ast/DiceASTInliner.java | 11 +++-- .../java/bjc/dicelang/ast/DiceASTOptimizer.java | 9 ++-- .../main/java/bjc/dicelang/ast/DiceASTParser.java | 50 ++++++++++---------- .../bjc/dicelang/ast/DiceASTReferenceChecker.java | 3 +- .../dicelang/ast/DiceASTReferenceSanitizer.java | 8 ++-- .../main/java/bjc/dicelang/ast/DiceASTUtils.java | 7 +-- .../java/bjc/dicelang/ast/IOperatorCollapser.java | 6 +-- .../bjc/dicelang/ast/nodes/DiceOperatorType.java | 4 ++ .../bjc/dicelang/ast/nodes/OperatorDiceNode.java | 12 ++++- .../java/bjc/dicelang/ast/nodes/package-info.java | 1 + .../ast/optimization/ArithmeticCollapser.java | 11 +++-- .../ast/optimization/ConstantCollapser.java | 36 +++++++------- .../ast/optimization/IOptimizationPass.java | 3 +- .../ast/optimization/OperationCondenser.java | 19 ++++---- .../dicelang/ast/optimization/package-info.java | 1 + .../main/java/bjc/dicelang/ast/package-info.java | 1 + 29 files changed, 193 insertions(+), 169 deletions(-) diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java index fb4b086..c52445d 100644 --- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java @@ -2,6 +2,12 @@ package bjc.dicelang.examples; import java.util.Scanner; +import bjc.utils.funcdata.FunctionalMap; +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.IFunctionalMap; +import bjc.utils.funcdata.ITree; + import bjc.dicelang.ast.DiceASTEvaluator; import bjc.dicelang.ast.DiceASTInliner; import bjc.dicelang.ast.DiceASTOptimizer; @@ -11,11 +17,6 @@ import bjc.dicelang.ast.IResult; import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.optimization.ConstantCollapser; import bjc.dicelang.ast.optimization.OperationCondenser; -import bjc.utils.funcdata.FunctionalMap; -import bjc.utils.funcdata.FunctionalStringTokenizer; -import bjc.utils.funcdata.IFunctionalList; -import bjc.utils.funcdata.IFunctionalMap; -import bjc.utils.funcdata.ITree; /** * Test interface for AST-based dice language @@ -62,8 +63,8 @@ public class DiceASTLanguageTest { String inlineExpression = pragmaArgs.getByIndex(0); String variableName = pragmaArgs.getByIndex(1); - IFunctionalList inlinedVariables = - pragmaArgs.tail().tail(); + IFunctionalList inlinedVariables = pragmaArgs.tail() + .tail(); ITree inlinedExpression = DiceASTInliner .selectiveInline(enviroment.get(inlineExpression), @@ -87,8 +88,7 @@ public class DiceASTLanguageTest { String currentLine = inputSource.nextLine(); // The enviroment for variables - IFunctionalMap> enviroment = - new FunctionalMap<>(); + IFunctionalMap> enviroment = new FunctionalMap<>(); while (!currentLine.equalsIgnoreCase("quit")) { String possibleActionName = currentLine.split(" ")[0]; @@ -99,8 +99,8 @@ public class DiceASTLanguageTest { + " with line " + currentLine + "\n"); // Execute action - FunctionalStringTokenizer tokenizer = - new FunctionalStringTokenizer(currentLine); + FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer( + currentLine); actions.get(possibleActionName).accept(tokenizer, enviroment); @@ -113,9 +113,9 @@ public class DiceASTLanguageTest { // Build an AST from the string expression ITree builtAST; - IFunctionalList preparedTokens = - DiceExpressionPreparer.prepareCommand(currentLine); - + IFunctionalList preparedTokens = DiceExpressionPreparer + .prepareCommand(currentLine); + try { builtAST = DiceASTParser.createFromString(preparedTokens); } catch (IllegalStateException isex) { @@ -129,8 +129,8 @@ public class DiceASTLanguageTest { // Print out results System.out.println("\tParsed: " + builtAST.toString()); - ITree transformedAST = - transformAST(builtAST, enviroment); + ITree transformedAST = transformAST(builtAST, + enviroment); System.out .println("\tEvaluated: " + transformedAST.toString()); @@ -167,11 +167,11 @@ public class DiceASTLanguageTest { private static ITree transformAST( ITree builtAST, IFunctionalMap> enviroment) { - ITree optimizedTree = - optimizer.optimizeTree(builtAST, enviroment); + ITree optimizedTree = optimizer + .optimizeTree(builtAST, enviroment); - ITree condensedTree = - OperationCondenser.condense(optimizedTree); + ITree condensedTree = OperationCondenser + .condense(optimizedTree); ITree sanitizedTree = DiceASTReferenceSanitizer .sanitize(condensedTree, enviroment); diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTPragma.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTPragma.java index 67b0adc..4bde0c2 100644 --- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTPragma.java +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTPragma.java @@ -2,11 +2,12 @@ package bjc.dicelang.examples; import java.util.function.BiConsumer; -import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.utils.funcdata.FunctionalStringTokenizer; import bjc.utils.funcdata.IFunctionalMap; import bjc.utils.funcdata.ITree; +import bjc.dicelang.ast.nodes.IDiceASTNode; + /** * Alias for the type of a 'pragma' or special language command * diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java index 4524fa0..b281fd8 100644 --- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionPreparer.java @@ -48,8 +48,8 @@ public class DiceExpressionPreparer { } static IFunctionalList prepareCommand(String currentLine) { - IFunctionalList tokens = - FunctionalStringTokenizer.fromString(currentLine).toList(); + IFunctionalList tokens = FunctionalStringTokenizer + .fromString(currentLine).toList(); Deque> ops = new LinkedList<>(); @@ -60,8 +60,8 @@ public class DiceExpressionPreparer { ops.add(new Pair<>(":=", ":=")); ops.add(new Pair<>("=>", "=>")); - IFunctionalList semiExpandedTokens = - ListUtils.splitTokens(tokens, ops); + IFunctionalList semiExpandedTokens = ListUtils + .splitTokens(tokens, ops); ops = new LinkedList<>(); @@ -70,8 +70,8 @@ public class DiceExpressionPreparer { ops.add(new Pair<>("[", "\\[")); ops.add(new Pair<>("]", "\\]")); - IFunctionalList fullyExpandedTokens = - ListUtils.deAffixTokens(semiExpandedTokens, ops); + IFunctionalList fullyExpandedTokens = ListUtils + .deAffixTokens(semiExpandedTokens, ops); fullyExpandedTokens.removeIf((strang) -> strang.equals("")); diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java index 0fb6a0f..fbb103f 100644 --- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java @@ -2,9 +2,10 @@ package bjc.dicelang.examples; import java.util.Map; +import bjc.utils.data.Pair; + import bjc.dicelang.DiceExpressionParser; import bjc.dicelang.IDiceExpression; -import bjc.utils.data.Pair; /** * Internal state of dice language diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java index 8dfaceb..2a9a492 100644 --- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java @@ -43,8 +43,8 @@ public class DiceLanguageTest { int nRolls = Integer.parseInt(strangs[2]); - IDiceExpression dexp = - stat.merge((dep, env) -> env.get(strangs[1])); + IDiceExpression dexp = stat + .merge((dep, env) -> env.get(strangs[1])); for (int i = 1; i <= nRolls; i++) { int roll = dexp.roll(); diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java index 42368e3..e76a23a 100644 --- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java +++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionBuilder.java @@ -1,6 +1,9 @@ package bjc.dicelang; -import static bjc.dicelang.DiceExpressionType.*; +import static bjc.dicelang.DiceExpressionType.ADD; +import static bjc.dicelang.DiceExpressionType.DIVIDE; +import static bjc.dicelang.DiceExpressionType.MULTIPLY; +import static bjc.dicelang.DiceExpressionType.SUBTRACT; /** * Build a dice expression piece by piece diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java index d0e013a..0926147 100644 --- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java @@ -3,12 +3,12 @@ package bjc.dicelang; import java.util.Map; import java.util.Stack; -import org.apache.commons.lang3.StringUtils; - import bjc.utils.funcdata.FunctionalStringTokenizer; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.parserutils.ShuntingYard; +import org.apache.commons.lang3.StringUtils; + /** * Parse a dice expression from a string * @@ -30,8 +30,8 @@ public class DiceExpressionParser { /* * Create a tokenizer over the strings */ - FunctionalStringTokenizer tokenizer = - new FunctionalStringTokenizer(expression); + FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer( + expression); /* * Create a shunter to rewrite the expression @@ -51,8 +51,8 @@ public class DiceExpressionParser { /* * Shunt the expression to postfix form */ - IFunctionalList list = - yard.postfix(tokenizer.toList(), s -> s); + IFunctionalList list = yard.postfix(tokenizer.toList(), + s -> s); /* * Create a stack for building an expression from parts @@ -90,8 +90,8 @@ public class DiceExpressionParser { /* * Apply an operation to two dice */ - IDiceExpression rightExpression = - expressions.pop(); + IDiceExpression rightExpression = expressions + .pop(); IDiceExpression leftExpression = expressions.pop(); switch (expressionPart) { diff --git a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java index 013d69d..474e18c 100644 --- a/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/IDiceExpression.java @@ -64,10 +64,8 @@ public interface IDiceExpression { try { return new ScalarDie(Integer.parseInt(literalData)); } catch (NumberFormatException nfex) { - UnsupportedOperationException usex = - new UnsupportedOperationException( - "Found malformed leaf token " - + expression); + UnsupportedOperationException usex = new UnsupportedOperationException( + "Found malformed leaf token " + expression); usex.initCause(nfex); diff --git a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java index 2d47d85..9230680 100644 --- a/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/OperatorDiceExpression.java @@ -65,11 +65,10 @@ public class OperatorDiceExpression implements IDiceExpression { try { return rightExpression.roll() / leftExpression.roll(); } catch (ArithmeticException aex) { - UnsupportedOperationException usex = - new UnsupportedOperationException( - "Attempted to divide by zero." - + " Problematic expression is " - + leftExpression); + UnsupportedOperationException usex = new UnsupportedOperationException( + "Attempted to divide by zero." + + " Problematic expression is " + + leftExpression); usex.initCause(aex); diff --git a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java index 61be936..483545b 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/ReferenceDiceExpression.java @@ -53,7 +53,8 @@ public class ReferenceDiceExpression implements IDiceExpression { public int roll() { if (!enviroment.containsKey(variableName)) { throw new UnsupportedOperationException( - "Attempted to reference undefined variable " + variableName); + "Attempted to reference undefined variable " + + variableName); } return enviroment.get(variableName).roll(); diff --git a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java index 9c06c31..50315e9 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/ScalarDiceExpression.java @@ -57,9 +57,8 @@ public class ScalarDiceExpression implements IDiceExpression { try { return expression.roll() / scalar; } catch (ArithmeticException aex) { - UnsupportedOperationException usex = - new UnsupportedOperationException( - "Attempted to divide by zero."); + UnsupportedOperationException usex = new UnsupportedOperationException( + "Attempted to divide by zero."); usex.initCause(aex); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java index ad508c8..87cbeb1 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java @@ -2,14 +2,15 @@ package bjc.dicelang.ast; import java.util.function.BinaryOperator; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.OperatorDiceNode; import bjc.utils.data.IPair; import bjc.utils.data.Pair; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcdata.ITree; import bjc.utils.funcdata.Tree; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.OperatorDiceNode; + /** * Responsible for collapsing arithmetic operators * @@ -30,20 +31,20 @@ final class ArithmeticCollapser implements IOperatorCollapser { @Override public IPair> apply( IFunctionalList>> nodes) { - IPair> initState = - new Pair<>(new IntegerResult(0), new Tree<>(type)); + IPair> initState = new Pair<>( + new IntegerResult(0), new Tree<>(type)); - BinaryOperator>> reducer = - (currentState, accumulatedState) -> { - // Force evaluation of accumulated state to prevent - // certain bugs from occuring - accumulatedState.merge((l, r) -> null); + BinaryOperator>> reducer = ( + currentState, accumulatedState) -> { + // Force evaluation of accumulated state to prevent + // certain bugs from occuring + accumulatedState.merge((l, r) -> null); - return reduceStates(accumulatedState, currentState); - }; + return reduceStates(accumulatedState, currentState); + }; - IPair> reducedState = - nodes.reduceAux(initState, reducer, (state) -> state); + IPair> reducedState = nodes + .reduceAux(initState, reducer, (state) -> state); return reducedState; } @@ -67,10 +68,10 @@ final class ArithmeticCollapser implements IOperatorCollapser { private IPair> doArithmeticCollapse( IResult accumulatedValue, ITree accumulatedTree, IResult currentValue) { - boolean currentIsInt = - currentValue.getType() == ResultType.INTEGER; - boolean accumulatedIsInt = - accumulatedValue.getType() == ResultType.INTEGER; + boolean currentIsInt = currentValue + .getType() == ResultType.INTEGER; + boolean accumulatedIsInt = accumulatedValue + .getType() == ResultType.INTEGER; if (!currentIsInt) { if (!accumulatedIsInt) { @@ -107,10 +108,10 @@ final class ArithmeticCollapser implements IOperatorCollapser { private IFunctionalList combineArrayResults( IResult accumulatedValue, IResult currentValue) { - IFunctionalList currentList = - ((ArrayResult) currentValue).getValue(); - IFunctionalList accumulatedList = - ((ArrayResult) accumulatedValue).getValue(); + IFunctionalList currentList = ((ArrayResult) currentValue) + .getValue(); + IFunctionalList accumulatedList = ((ArrayResult) accumulatedValue) + .getValue(); if (currentList.getSize() != accumulatedList.getSize()) { throw new UnsupportedOperationException( @@ -119,8 +120,8 @@ final class ArithmeticCollapser implements IOperatorCollapser { IFunctionalList resultList = currentList.combineWith( accumulatedList, (currentNode, accumulatedNode) -> { - boolean currentNotInt = - currentNode.getType() != ResultType.INTEGER; + boolean currentNotInt = currentNode + .getType() != ResultType.INTEGER; boolean accumulatedNotInt = accumulatedNode .getType() != ResultType.INTEGER; @@ -129,10 +130,10 @@ final class ArithmeticCollapser implements IOperatorCollapser { "Nesting of array operations isn't allowed"); } - int accumulatedInt = - ((IntegerResult) accumulatedNode).getValue(); - int currentInt = - ((IntegerResult) currentNode).getValue(); + int accumulatedInt = ((IntegerResult) accumulatedNode) + .getValue(); + int currentInt = ((IntegerResult) currentNode) + .getValue(); IResult combinedValue = new IntegerResult( valueOp.apply(accumulatedInt, currentInt)); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java index 8ed385e..6044602 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java @@ -2,15 +2,6 @@ package bjc.dicelang.ast; import java.util.function.Supplier; -import bjc.dicelang.ComplexDice; -import bjc.dicelang.ast.nodes.DiceASTType; -import bjc.dicelang.ast.nodes.DiceLiteralNode; -import bjc.dicelang.ast.nodes.DiceLiteralType; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.ILiteralDiceNode; -import bjc.dicelang.ast.nodes.IntegerLiteralNode; -import bjc.dicelang.ast.nodes.OperatorDiceNode; -import bjc.dicelang.ast.nodes.VariableDiceNode; import bjc.utils.data.IHolder; import bjc.utils.data.IPair; import bjc.utils.data.Identity; @@ -23,6 +14,16 @@ import bjc.utils.funcdata.IFunctionalMap; import bjc.utils.funcdata.ITree; import bjc.utils.funcdata.Tree; +import bjc.dicelang.ComplexDice; +import bjc.dicelang.ast.nodes.DiceASTType; +import bjc.dicelang.ast.nodes.DiceLiteralNode; +import bjc.dicelang.ast.nodes.DiceLiteralType; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.ILiteralDiceNode; +import bjc.dicelang.ast.nodes.IntegerLiteralNode; +import bjc.dicelang.ast.nodes.OperatorDiceNode; +import bjc.dicelang.ast.nodes.VariableDiceNode; + /** * Evaluate a dice AST to an integer value * diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java index 6091cc3..114965e 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java @@ -1,14 +1,15 @@ package bjc.dicelang.ast; -import bjc.dicelang.ast.nodes.DiceASTType; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.VariableDiceNode; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcdata.IFunctionalMap; import bjc.utils.funcdata.ITree; import bjc.utils.funcdata.Tree; +import bjc.dicelang.ast.nodes.DiceASTType; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.VariableDiceNode; + /** * Inline variables in a dice AST * @@ -81,8 +82,8 @@ public class DiceASTInliner { IFunctionalMap> enviroment, String... variables) { if (variables != null && variables.length > 0) { - IFunctionalList variableNames = - new FunctionalList<>(variables); + IFunctionalList variableNames = new FunctionalList<>( + variables); return ast.flatMapTree((node) -> { return inlineNode(node, enviroment, true, variableNames); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java index 7676fac..e96c620 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTOptimizer.java @@ -1,12 +1,13 @@ package bjc.dicelang.ast; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.optimization.IOptimizationPass; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcdata.IFunctionalMap; import bjc.utils.funcdata.ITree; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.optimization.IOptimizationPass; + /** * Contains optimizations appliable to a dice AST * @@ -44,8 +45,8 @@ public class DiceASTOptimizer { */ public ITree optimizeTree(ITree ast, IFunctionalMap> enviroment) { - ITree optimizedTree = - passes.reduceAux(ast, (currentPass, currentTree) -> { + ITree optimizedTree = passes.reduceAux(ast, + (currentPass, currentTree) -> { return currentTree.collapse(currentPass::optimizeLeaf, (operator) -> { return (nodes) -> { diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java index c746c8b..3a4bccf 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java @@ -5,14 +5,6 @@ import java.util.InputMismatchException; import java.util.function.Function; import java.util.function.Predicate; -import bjc.dicelang.IDiceExpression; -import bjc.dicelang.ast.nodes.DiceLiteralNode; -import bjc.dicelang.ast.nodes.DiceLiteralType; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.ILiteralDiceNode; -import bjc.dicelang.ast.nodes.IntegerLiteralNode; -import bjc.dicelang.ast.nodes.OperatorDiceNode; -import bjc.dicelang.ast.nodes.VariableDiceNode; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.FunctionalMap; import bjc.utils.funcdata.IFunctionalList; @@ -22,6 +14,15 @@ import bjc.utils.funcdata.Tree; import bjc.utils.funcutils.StringUtils; import bjc.utils.parserutils.TreeConstructor; +import bjc.dicelang.IDiceExpression; +import bjc.dicelang.ast.nodes.DiceLiteralNode; +import bjc.dicelang.ast.nodes.DiceLiteralType; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.ILiteralDiceNode; +import bjc.dicelang.ast.nodes.IntegerLiteralNode; +import bjc.dicelang.ast.nodes.OperatorDiceNode; +import bjc.dicelang.ast.nodes.VariableDiceNode; + /** * Parse a string expression into AST form. Doesn't do anything else * @@ -36,8 +37,8 @@ public class DiceASTParser { * The list of tokens to convert * @return An AST built from the tokens */ - public static ITree - createFromString(IFunctionalList tokens) { + public static ITree createFromString( + IFunctionalList tokens) { Predicate specialPicker = (operator) -> { if (StringUtils.containsOnly(operator, "\\[")) { return true; @@ -48,8 +49,7 @@ public class DiceASTParser { return false; }; - IFunctionalMap>, ITree>> operators = - new FunctionalMap<>(); + IFunctionalMap>, ITree>> operators = new FunctionalMap<>(); operators.put("[", (queuedTrees) -> { Tree openTree = new Tree<>("["); @@ -61,28 +61,28 @@ public class DiceASTParser { return parseCloseArray(queuedTrees); }); - ITree rawTokens = - TreeConstructor.constructTree(tokens, (token) -> { + ITree rawTokens = TreeConstructor.constructTree(tokens, + (token) -> { return isOperatorNode(token); }, specialPicker, operators::get); - ITree tokenizedTree = - rawTokens.rebuildTree(DiceASTParser::convertLeafNode, - DiceASTParser::convertOperatorNode); + ITree tokenizedTree = rawTokens.rebuildTree( + DiceASTParser::convertLeafNode, + DiceASTParser::convertOperatorNode); return tokenizedTree; } - private static ITree - parseCloseArray(Deque> queuedTrees) { + private static ITree parseCloseArray( + Deque> queuedTrees) { IFunctionalList> children = new FunctionalList<>(); while (shouldContinuePopping(queuedTrees)) { children.add(queuedTrees.pop()); } - + queuedTrees.pop(); - + children.reverse(); ITree arrayTree = new Tree<>("[]", children); @@ -90,8 +90,8 @@ public class DiceASTParser { return arrayTree; } - private static boolean - shouldContinuePopping(Deque> queuedTrees) { + private static boolean shouldContinuePopping( + Deque> queuedTrees) { String peekToken = queuedTrees.peek().getHead(); return !peekToken.equals("["); @@ -119,8 +119,8 @@ public class DiceASTParser { } private static IDiceASTNode convertLeafNode(String leafNode) { - DiceLiteralType literalType = - ILiteralDiceNode.getLiteralType(leafNode); + DiceLiteralType literalType = ILiteralDiceNode + .getLiteralType(leafNode); if (literalType != null) { switch (literalType) { diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java index 809243a..34414c5 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java @@ -2,10 +2,11 @@ package bjc.dicelang.ast; import java.util.function.Consumer; +import bjc.utils.data.IHolder; + import bjc.dicelang.ast.nodes.DiceASTType; import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.VariableDiceNode; -import bjc.utils.data.IHolder; /** * Check if the specified node references a particular variable diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java index 9ace97f..3079bca 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceSanitizer.java @@ -1,8 +1,5 @@ package bjc.dicelang.ast; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.OperatorDiceNode; -import bjc.dicelang.ast.nodes.VariableDiceNode; import bjc.utils.data.IHolder; import bjc.utils.data.Identity; import bjc.utils.funcdata.IFunctionalMap; @@ -10,6 +7,10 @@ import bjc.utils.funcdata.ITree; import bjc.utils.funcdata.TopDownTransformResult; import bjc.utils.funcdata.Tree; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.OperatorDiceNode; +import bjc.dicelang.ast.nodes.VariableDiceNode; + /** * Sanitize the references in an AST so that a variable that refers to * itself in its definition has the occurance of it replaced with its @@ -47,6 +48,7 @@ public class DiceASTReferenceSanitizer { case LET: return TopDownTransformResult.PASSTHROUGH; case ADD: + case CALL: case COMPOUND: case DIVIDE: case GROUP: diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java index 20a46c7..a70ee00 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTUtils.java @@ -1,5 +1,7 @@ package bjc.dicelang.ast; +import bjc.utils.funcdata.ITree; + import bjc.dicelang.IDiceExpression; import bjc.dicelang.ScalarDie; import bjc.dicelang.ast.nodes.DiceASTType; @@ -7,7 +9,6 @@ import bjc.dicelang.ast.nodes.DiceLiteralNode; import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.ILiteralDiceNode; import bjc.dicelang.ast.nodes.IntegerLiteralNode; -import bjc.utils.funcdata.ITree; /** * Functions that are useful when dealing with dice ASTs @@ -23,8 +24,8 @@ public class DiceASTUtils { * @return Whether or not a dice AST contains a simple variable * reference */ - public static boolean - containsSimpleVariable(ITree nameTree) { + public static boolean containsSimpleVariable( + ITree nameTree) { return nameTree.transformHead((nameNod) -> { if (nameNod.getType() != DiceASTType.VARIABLE) { return false; diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java index 8fd066d..a3050a1 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java @@ -2,11 +2,12 @@ package bjc.dicelang.ast; import java.util.function.Function; -import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.utils.data.IPair; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcdata.ITree; +import bjc.dicelang.ast.nodes.IDiceASTNode; + /** * Alias for operator collapsers. Because 68-char types are too long * @@ -14,7 +15,6 @@ import bjc.utils.funcdata.ITree; * */ public interface IOperatorCollapser extends - Function>>, - IPair>> { + Function>>, IPair>> { // Just an alias } diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java index 76aa2e3..7cc1e42 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceOperatorType.java @@ -14,6 +14,10 @@ public enum DiceOperatorType { * Represents operators that do math operations */ MATH, + /** + * Represents operators that do things with arrays + */ + ARRAY, /** * Represents operators that do things with dice */ diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java index 18df122..411548a 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java @@ -1,6 +1,8 @@ package bjc.dicelang.ast.nodes; -import static bjc.dicelang.ast.nodes.DiceOperatorType.*; +import static bjc.dicelang.ast.nodes.DiceOperatorType.DICE; +import static bjc.dicelang.ast.nodes.DiceOperatorType.EXPRESSION; +import static bjc.dicelang.ast.nodes.DiceOperatorType.MATH; /** * A node that represents an operator @@ -36,11 +38,15 @@ public enum OperatorDiceNode implements IDiceASTNode { /** * Represents constructing an array from a sequence of expressions */ - ARRAY(EXPRESSION), + ARRAY(DiceOperatorType.ARRAY), /** * Represents assigning one node to another */ ASSIGN(EXPRESSION), + /** + * Represents calling a function + */ + CALL(EXPRESSION), /** * Represents evaluating one expression in the context of another */ @@ -85,6 +91,8 @@ public enum OperatorDiceNode implements IDiceASTNode { return LET; case "[]": return ARRAY; + case "call": + return CALL; default: throw new IllegalArgumentException( s + " is not a valid operator node"); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java index cfa2511..f0f7366 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/package-info.java @@ -1,5 +1,6 @@ /** * Classes for nodes in the dice-lang AST + * * @author ben * */ diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java index 5318119..2b2a9ad 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ArithmeticCollapser.java @@ -2,15 +2,16 @@ package bjc.dicelang.ast.optimization; import java.util.function.BinaryOperator; +import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.ITree; +import bjc.utils.funcdata.Tree; + import bjc.dicelang.ast.DiceASTUtils; import bjc.dicelang.ast.nodes.DiceASTType; import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.ILiteralDiceNode; import bjc.dicelang.ast.nodes.IntegerLiteralNode; import bjc.dicelang.ast.nodes.OperatorDiceNode; -import bjc.utils.funcdata.IFunctionalList; -import bjc.utils.funcdata.ITree; -import bjc.utils.funcdata.Tree; class ArithmeticCollapser { private BinaryOperator reducer; @@ -22,8 +23,8 @@ class ArithmeticCollapser { this.type = typ; } - public ITree - collapse(IFunctionalList> children) { + public ITree collapse( + IFunctionalList> children) { boolean allConstant = children.allMatch((subtree) -> { return subtree.transformHead((node) -> { if (node.getType() == DiceASTType.LITERAL) { diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java index 7b746ac..63c9037 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java @@ -1,13 +1,14 @@ package bjc.dicelang.ast.optimization; +import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.ITree; +import bjc.utils.funcdata.Tree; + import bjc.dicelang.ComplexDice; import bjc.dicelang.ast.DiceASTUtils; import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.IntegerLiteralNode; import bjc.dicelang.ast.nodes.OperatorDiceNode; -import bjc.utils.funcdata.IFunctionalList; -import bjc.utils.funcdata.ITree; -import bjc.utils.funcdata.Tree; /** * Collapses operations with constants to constants @@ -16,27 +17,22 @@ import bjc.utils.funcdata.Tree; * */ public class ConstantCollapser implements IOptimizationPass { - private static final ArithmeticCollapser additionCollapser = - new ArithmeticCollapser((left, right) -> left + right, - OperatorDiceNode.ADD); + private static final ArithmeticCollapser additionCollapser = new ArithmeticCollapser( + (left, right) -> left + right, OperatorDiceNode.ADD); - private static final ArithmeticCollapser divideCollapser = - new ArithmeticCollapser((left, right) -> left / right, - OperatorDiceNode.DIVIDE); + private static final ArithmeticCollapser divideCollapser = new ArithmeticCollapser( + (left, right) -> left / right, OperatorDiceNode.DIVIDE); - private static final ArithmeticCollapser multiplyCollapser = - new ArithmeticCollapser((left, right) -> left * right, - OperatorDiceNode.MULTIPLY); + private static final ArithmeticCollapser multiplyCollapser = new ArithmeticCollapser( + (left, right) -> left * right, OperatorDiceNode.MULTIPLY); - private static final ArithmeticCollapser subtractCollapser = - new ArithmeticCollapser((left, right) -> left - right, - OperatorDiceNode.SUBTRACT); + private static final ArithmeticCollapser subtractCollapser = new ArithmeticCollapser( + (left, right) -> left - right, OperatorDiceNode.SUBTRACT); - private static final ArithmeticCollapser compoundCollapser = - new ArithmeticCollapser((left, - right) -> Integer.parseInt(Integer.toString(left) - + Integer.toString(left)), - OperatorDiceNode.SUBTRACT); + private static final ArithmeticCollapser compoundCollapser = new ArithmeticCollapser( + (left, right) -> Integer.parseInt( + Integer.toString(left) + Integer.toString(left)), + OperatorDiceNode.SUBTRACT); @Override public ITree optimizeLeaf(IDiceASTNode leafNode) { diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java index b631fb5..7dbea18 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/IOptimizationPass.java @@ -1,9 +1,10 @@ package bjc.dicelang.ast.optimization; -import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcdata.ITree; +import bjc.dicelang.ast.nodes.IDiceASTNode; + /** * Represents a pass of optimizations over a dice AST * diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java index 3988d2a..bdf7b04 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/OperationCondenser.java @@ -1,14 +1,15 @@ package bjc.dicelang.ast.optimization; -import bjc.dicelang.ast.nodes.DiceASTType; -import bjc.dicelang.ast.nodes.IDiceASTNode; -import bjc.dicelang.ast.nodes.OperatorDiceNode; import bjc.utils.data.IHolder; import bjc.utils.data.Identity; import bjc.utils.funcdata.ITree; import bjc.utils.funcdata.TopDownTransformResult; import bjc.utils.funcdata.Tree; +import bjc.dicelang.ast.nodes.DiceASTType; +import bjc.dicelang.ast.nodes.IDiceASTNode; +import bjc.dicelang.ast.nodes.OperatorDiceNode; + /** * Condenses chained operations into a single level * @@ -42,8 +43,8 @@ public class OperationCondenser { } } - private static TopDownTransformResult - pickOperator(OperatorDiceNode node) { + private static TopDownTransformResult pickOperator( + OperatorDiceNode node) { switch (node) { case ADD: case MULTIPLY: @@ -62,10 +63,10 @@ public class OperationCondenser { } } - private static ITree - doCondense(ITree ast) { - OperatorDiceNode operation = - ast.transformHead((node) -> (OperatorDiceNode) node); + private static ITree doCondense( + ITree ast) { + OperatorDiceNode operation = ast + .transformHead((node) -> (OperatorDiceNode) node); IHolder canCondense = new Identity<>(true); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java index a3ec93c..6f75bf9 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/package-info.java @@ -1,5 +1,6 @@ /** * Contains optimizations on dice ASTs + * * @author ben * */ diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java b/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java index 105af50..f6352aa 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/package-info.java @@ -1,5 +1,6 @@ /** * New implementation of AST for dice-lang + * * @author ben * */ -- cgit v1.2.3