diff options
Diffstat (limited to 'dice-lang/src/main/java')
5 files changed, 147 insertions, 22 deletions
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 5ad0a0f..5c00fe2 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/ArithmeticCollapser.java @@ -16,8 +16,7 @@ import bjc.utils.funcdata.Tree; * @author ben * */ -final class ArithmeticCollapser - implements IOperatorCollapser { +final class ArithmeticCollapser implements IOperatorCollapser { private OperatorDiceNode type; private BinaryOperator<Integer> valueOp; @@ -35,12 +34,18 @@ final class ArithmeticCollapser new Pair<>(0, new Tree<>(type)); BinaryOperator<IPair<Integer, ITree<IDiceASTNode>>> reducer = - (accumulatedState, currentState) -> { - return reduceStates(accumulatedState, - currentState); + (currentState, accumulatedState) -> { + // Force evaluation of accumulated state to prevent + // certain bugs from occuring + accumulatedState.merge((l, r) -> null); + + return reduceStates(accumulatedState, currentState); }; - return nodes.reduceAux(initState, reducer, (state) -> state); + IPair<Integer, ITree<IDiceASTNode>> reducedState = + nodes.reduceAux(initState, reducer, (state) -> state); + + return reducedState; } private IPair<Integer, ITree<IDiceASTNode>> reduceStates( @@ -52,9 +57,8 @@ final class ArithmeticCollapser .bind((currentValue, currentTree) -> { accumulatedTree.addChild(currentTree); - Integer combinedValue = - valueOp.apply(accumulatedValue, - currentValue); + Integer combinedValue = valueOp.apply( + accumulatedValue, currentValue); return new Pair<>(combinedValue, accumulatedTree); 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 e934b9f..016fa8a 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java @@ -112,7 +112,10 @@ public class DiceASTEvaluator { String variableName = ((VariableDiceNode) leafNode).getVariable(); if (enviroment.containsKey(variableName)) { - return evaluateAST(enviroment.get(variableName), enviroment); + int result = + evaluateAST(enviroment.get(variableName), enviroment); + + return result; } // Value to allow for assignments @@ -148,6 +151,9 @@ public class DiceASTEvaluator { IPair<Integer, ITree<IDiceASTNode>> valueNode = nodes.getByIndex(1); + // Force valueNode to materialize for debugging purposes + valueNode.merge((l, r) -> null); + return nameNode.bindRight((nameTree) -> { return valueNode.bind((valueValue, valueTree) -> { if (containsSimpleVariable(nameTree)) { diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java new file mode 100644 index 0000000..6091cc3 --- /dev/null +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java @@ -0,0 +1,115 @@ +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; + +/** + * Inline variables in a dice AST + * + * @author ben + * + */ +public class DiceASTInliner { + /** + * Inline all the variables in the AST + * + * @param ast + * The AST to inline variables into + * @param enviroment + * The enviroment to inline from + * @return The inlined AST + */ + public static ITree<IDiceASTNode> inlineAll(ITree<IDiceASTNode> ast, + IFunctionalMap<String, ITree<IDiceASTNode>> enviroment) { + // Tell the compiler that the null is for the entire varargs + // parameter, not a single one with a null value + return selectiveInline(ast, enviroment, (String[]) null); + } + + private static ITree<IDiceASTNode> inlineNode(IDiceASTNode node, + IFunctionalMap<String, ITree<IDiceASTNode>> enviroment, + boolean specificInline, + IFunctionalList<String> variableNames) { + if (node.getType() != DiceASTType.VARIABLE) { + return new Tree<>(node); + } + + String variableName = ((VariableDiceNode) node).getVariable(); + + if (specificInline) { + if (variableNames.contains(variableName)) { + if (!enviroment.containsKey(variableName)) { + throw new UnsupportedOperationException( + "Attempted to inline non-existant variable " + + variableName); + } + + return enviroment.get(variableName); + } + } else { + if (!enviroment.containsKey(variableName)) { + throw new UnsupportedOperationException( + "Attempted to inline non-existant variable " + + variableName); + } + + return enviroment.get(variableName); + } + + return new Tree<>(node); + } + + /** + * Inline the specified variables in the AST + * + * @param ast + * The AST to inline variables into + * @param enviroment + * The enviroment to inline from + * @param variables + * The variables to inline + * @return The inlined AST + */ + public static ITree<IDiceASTNode> selectiveInline( + ITree<IDiceASTNode> ast, + IFunctionalMap<String, ITree<IDiceASTNode>> enviroment, + String... variables) { + if (variables != null && variables.length > 0) { + IFunctionalList<String> variableNames = + new FunctionalList<>(variables); + + return ast.flatMapTree((node) -> { + return inlineNode(node, enviroment, true, variableNames); + }); + } + + return ast.flatMapTree((node) -> { + return inlineNode(node, enviroment, false, null); + }); + } + + /** + * Inline the specified variables in the AST + * + * @param ast + * The AST to inline variables into + * @param enviroment + * The enviroment to inline from + * @param variables + * The variables to inline + * @return The inlined AST + */ + public static ITree<IDiceASTNode> selectiveInline( + ITree<IDiceASTNode> ast, + IFunctionalMap<String, ITree<IDiceASTNode>> enviroment, + IFunctionalList<String> variables) { + return selectiveInline(ast, enviroment, + variables.toArray(new String[0])); + } +} 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 95495bd..d8c94dc 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java @@ -28,17 +28,21 @@ public class DiceASTParser { * The list of tokens to convert * @return An AST built from the tokens */ - public static ITree<IDiceASTNode> createFromString( - IFunctionalList<String> tokens) { - ITree<String> rawTokens = TreeConstructor.constructTree(tokens, - (token) -> { + public static ITree<IDiceASTNode> + createFromString(IFunctionalList<String> tokens) { + ITree<String> rawTokens = + TreeConstructor.constructTree(tokens, (token) -> { return isOperatorNode(token); }, (operator) -> false, null); + // The last argument is valid because there are no special // operators yet, so it'll never get called - return rawTokens.rebuildTree(DiceASTParser::convertLeafNode, - DiceASTParser::convertOperatorNode); + ITree<IDiceASTNode> tokenizedTree = + rawTokens.rebuildTree(DiceASTParser::convertLeafNode, + DiceASTParser::convertOperatorNode); + + return tokenizedTree; } private static boolean isOperatorNode(String token) { @@ -52,8 +56,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/nodes/OperatorDiceNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/OperatorDiceNode.java index d034943..ab47b56 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 @@ -2,10 +2,6 @@ package bjc.dicelang.ast.nodes; import static bjc.dicelang.ast.nodes.DiceOperatorType.*; -// The following classes need to be changed upon addition of a new operator -// 1. DiceASTExpression -// 2. DiceASTFlattener -// 3. DiceASTParser /** * A node that represents an operator * |