diff options
Diffstat (limited to 'dice-lang/src/main/java')
12 files changed, 249 insertions, 137 deletions
diff --git a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java index 05e8942..8a8ded3 100644 --- a/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/DiceExpressionParser.java @@ -5,8 +5,8 @@ import java.util.Stack; import org.apache.commons.lang3.StringUtils; -import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IFunctionalList; import bjc.utils.parserutils.ShuntingYard; /** @@ -25,7 +25,7 @@ public class DiceExpressionParser { * The enviroment to use when parsing expressions * @return The parsed dice expression */ - public IDiceExpression parse(String exp, + public static IDiceExpression parse(String exp, Map<String, IDiceExpression> env) { /* * Create a tokenizer over the strings @@ -50,8 +50,8 @@ public class DiceExpressionParser { /* * Shunt the expression to postfix form */ - FunctionalList<String> ls = - yard.postfix(fst.toList(s -> s), s -> s); + IFunctionalList<String> ls = yard.postfix(fst.toList(s -> s), + s -> s); /* * Create a stack for building an expression from parts @@ -82,8 +82,8 @@ public class DiceExpressionParser { * Handle scalar numbers */ dexps.push(new ScalarDie(Integer.parseInt(tok))); - } catch (NumberFormatException nfex) { - + } catch (@SuppressWarnings("unused") NumberFormatException nfex) { + // We don't care about details, just that it failed if (dexps.size() >= 2) { /* * Apply an operation to two dice diff --git a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java index e0bef64..9f609b4 100644 --- a/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java +++ b/dice-lang/src/main/java/bjc/dicelang/PolyhedralDice.java @@ -19,6 +19,15 @@ public class PolyhedralDice { } /** + * Produce a single d10 + * + * @return A single d10 + */ + public static IDiceExpression d10() { + return d10(1); + } + + /** * Produce the specified number of 100-sided dice * * @param nDice @@ -30,6 +39,15 @@ public class PolyhedralDice { } /** + * Produce a single d100 + * + * @return A single d100 + */ + public static IDiceExpression d100() { + return d100(1); + } + + /** * Produce the specified number of 12-sided dice * * @param nDice @@ -41,6 +59,15 @@ public class PolyhedralDice { } /** + * Produce a single d12 + * + * @return A single d12 + */ + public static IDiceExpression d12() { + return d12(1); + } + + /** * Produce the specified number of 20-sided dice * * @param nDice @@ -52,6 +79,15 @@ public class PolyhedralDice { } /** + * Produce a single d20 + * + * @return A single d20 + */ + public static IDiceExpression d20() { + return d20(1); + } + + /** * Produce the specified number of 4-sided dice * * @param nDice @@ -63,6 +99,15 @@ public class PolyhedralDice { } /** + * Produce a single d4 + * + * @return A single d4 + */ + public static IDiceExpression d4() { + return d4(1); + } + + /** * Produce the specified number of 6-sided dice * * @param nDice @@ -74,6 +119,15 @@ public class PolyhedralDice { } /** + * Produce a single d6 + * + * @return A single d6 + */ + public static IDiceExpression d6() { + return d6(1); + } + + /** * Produce the specified number of 8-sided dice * * @param nDice @@ -83,4 +137,13 @@ public class PolyhedralDice { public static IDiceExpression d8(int nDice) { return new ComplexDice(nDice, 8); } + + /** + * Produce a single d8 + * + * @return A single d8 + */ + public static IDiceExpression d8() { + return d8(1); + } } diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/LiteralDiceNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/LiteralDiceNode.java index e689c7f..1a6d2bf 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/LiteralDiceNode.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/LiteralDiceNode.java @@ -38,7 +38,9 @@ public class LiteralDiceNode implements IDiceASTNode { /** * Create a new node with the given value - * @param val The value for this node + * + * @param val + * The value for this node */ public LiteralDiceNode(int val) { this(Integer.toString(val)); @@ -126,8 +128,12 @@ public class LiteralDiceNode implements IDiceASTNode { try { return new ScalarDie(Integer.parseInt(literalData)); } catch (NumberFormatException nfex) { - throw new UnsupportedOperationException( + UnsupportedOperationException usex = new UnsupportedOperationException( "Found malformed leaf token " + this); + + usex.initCause(nfex); + + throw usex; } } } @@ -165,7 +171,8 @@ public class LiteralDiceNode implements IDiceASTNode { try { Integer.parseInt(value); return true; - } catch (NumberFormatException nfex) { + } catch (@SuppressWarnings("unused") NumberFormatException nfex) { + // We don't care about details return false; } } 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 e1eb316..2820cfb 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 @@ -38,7 +38,11 @@ public enum OperatorDiceNode implements IDiceASTNode { /** * Represents subtracting two nodes */ - SUBTRACT; + SUBTRACT, + /** + * Represents executing one statement in the context of the other + */ + LET; /** * Create a operator node from a string @@ -63,6 +67,8 @@ public enum OperatorDiceNode implements IDiceASTNode { return GROUP; case "c": return COMPOUND; + case "->": + return LET; default: throw new IllegalArgumentException( s + " is not a valid operator node"); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/DiceASTOptimizer.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/DiceASTOptimizer.java index e6c62ee..f6be7ab 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/DiceASTOptimizer.java +++ b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/DiceASTOptimizer.java @@ -36,26 +36,26 @@ public class DiceASTOptimizer { @Override public AST<IDiceASTNode> apply(AST<IDiceASTNode> leftAST, AST<IDiceASTNode> rightAST) { - AST<IDiceASTNode> rightBranchOfLeftAST = - leftAST.applyToRight((rightSideAST) -> rightSideAST); - AST<IDiceASTNode> leftBranchOfLeftAST = - leftAST.applyToRight((rightSideAST) -> rightSideAST); + AST<IDiceASTNode> rightBranchOfLeftAST = leftAST + .applyToRight((rightSideAST) -> rightSideAST); + AST<IDiceASTNode> leftBranchOfLeftAST = leftAST + .applyToRight((rightSideAST) -> rightSideAST); boolean leftContainsNestedConstant = DiceASTOptimizer .checkNodeType(rightBranchOfLeftAST, LITERAL) && DiceASTOptimizer.isNodeConstant(leftAST); - boolean isRightConstant = - DiceASTOptimizer.checkNodeType(rightAST, LITERAL) - && DiceASTOptimizer.isNodeConstant(leftAST); + boolean isRightConstant = DiceASTOptimizer + .checkNodeType(rightAST, LITERAL) + && DiceASTOptimizer.isNodeConstant(leftAST); if (leftContainsNestedConstant && isRightConstant) { int combinedValue = valueCollapser.apply( getNodeValue(rightBranchOfLeftAST), getNodeValue(rightAST)); - AST<IDiceASTNode> newRightBranch = - new AST<>(new LiteralDiceNode(combinedValue)); + AST<IDiceASTNode> newRightBranch = new AST<>( + new LiteralDiceNode(combinedValue)); return new AST<>(type, leftBranchOfLeftAST, newRightBranch); @@ -82,13 +82,13 @@ public class DiceASTOptimizer { @Override public AST<IDiceASTNode> apply(AST<IDiceASTNode> leftAST, AST<IDiceASTNode> rightAST) { - boolean isLeftConstant = - DiceASTOptimizer.checkNodeType(leftAST, LITERAL) - && DiceASTOptimizer.isNodeConstant(leftAST); + boolean isLeftConstant = DiceASTOptimizer + .checkNodeType(leftAST, LITERAL) + && DiceASTOptimizer.isNodeConstant(leftAST); - boolean isRightConstant = - DiceASTOptimizer.checkNodeType(rightAST, LITERAL) - && DiceASTOptimizer.isNodeConstant(leftAST); + boolean isRightConstant = DiceASTOptimizer + .checkNodeType(rightAST, LITERAL) + && DiceASTOptimizer.isNodeConstant(leftAST); if (isLeftConstant) { if (isRightConstant) { @@ -107,10 +107,8 @@ public class DiceASTOptimizer { } } - private static Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> - buildConstantCollapsers() { - Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> operatorCollapsers = - new HashMap<>(); + private static Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> buildConstantCollapsers() { + Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> operatorCollapsers = new HashMap<>(); operatorCollapsers.put(OperatorDiceNode.ADD, new ArithmeticOperationCollapser(OperatorDiceNode.ADD, @@ -131,10 +129,8 @@ public class DiceASTOptimizer { return operatorCollapsers; } - private static Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> - buildNestedConstantCollapsers() { - Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> operatorCollapsers = - new HashMap<>(); + private static Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> buildNestedConstantCollapsers() { + Map<IDiceASTNode, BinaryOperator<AST<IDiceASTNode>>> operatorCollapsers = new HashMap<>(); operatorCollapsers.put(OperatorDiceNode.ADD, new NestedArithmeticOperationCollapser( @@ -167,9 +163,9 @@ public class DiceASTOptimizer { IDiceExpression leaf) { if (leaf.canOptimize()) { return new LiteralDiceNode(Integer.toString(leaf.optimize())); - } else { - return node; } + + return node; } private static AST<IDiceASTNode> finishTree(AST<IDiceASTNode> tree) { @@ -184,14 +180,13 @@ public class DiceASTOptimizer { * @return The optimized tree */ public static AST<IDiceASTNode> optimizeTree(AST<IDiceASTNode> tree) { - AST<IDiceASTNode> astWithConstantsFolded = - tree.collapse(DiceASTOptimizer::collapseLeaf, - buildConstantCollapsers()::get, - DiceASTOptimizer::finishTree); + AST<IDiceASTNode> astWithConstantsFolded = tree.collapse( + DiceASTOptimizer::collapseLeaf, + buildConstantCollapsers()::get, + DiceASTOptimizer::finishTree); - AST<IDiceASTNode> astWithNestedConstantsFolded = - astWithConstantsFolded.collapse( - DiceASTOptimizer::collapseLeaf, + AST<IDiceASTNode> astWithNestedConstantsFolded = astWithConstantsFolded + .collapse(DiceASTOptimizer::collapseLeaf, buildNestedConstantCollapsers()::get, DiceASTOptimizer::finishTree); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTDefinedChecker.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTDefinedChecker.java index c26098c..4a20a82 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTDefinedChecker.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTDefinedChecker.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.Map; import java.util.function.Consumer; diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTExpression.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTExpression.java index 3552926..7651093 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTExpression.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTExpression.java @@ -1,7 +1,8 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.HashMap; import java.util.Map; +import java.util.function.BinaryOperator; import java.util.function.Function; import bjc.dicelang.ComplexDice; @@ -24,6 +25,37 @@ import bjc.utils.parserutils.AST; * */ public class DiceASTExpression implements IDiceExpression { + private static final class ArithmeticCollapser + implements IOperatorCollapser { + private OperatorDiceNode type; + + private BinaryOperator<Integer> valueOp; + + public ArithmeticCollapser(OperatorDiceNode type, + BinaryOperator<Integer> valueOp) { + this.type = type; + this.valueOp = valueOp; + } + + @Override + public Pair<Integer, AST<IDiceASTNode>> apply( + Pair<Integer, AST<IDiceASTNode>> leftNode, + Pair<Integer, AST<IDiceASTNode>> rightNode) { + return leftNode.merge((leftValue, leftAST) -> { + return rightNode.merge((rightValue, rightAST) -> { + if (type == OperatorDiceNode.DIVIDE + && rightValue == 0) { + throw new ArithmeticException( + "Attempted to divide by zero. The AST of the problem expression is " + + rightAST); + } + + return new Pair<>(valueOp.apply(leftValue, rightValue), + new AST<>(type, leftAST, rightAST)); + }); + }); + } + } private static final class VariableRetriever implements Function<IDiceASTNode, String> { @@ -47,59 +79,26 @@ public class DiceASTExpression implements IDiceExpression { * The enviroment to evaluate bindings and such against * @return The operations to use when collapsing the AST */ - private static Map<IDiceASTNode, IOperatorCollapser> buildOperations( - Map<String, DiceASTExpression> enviroment) { - Map<IDiceASTNode, IOperatorCollapser> operatorCollapsers = new HashMap<>(); + private static Map<IDiceASTNode, IOperatorCollapser> + buildOperations(Map<String, DiceASTExpression> enviroment) { + Map<IDiceASTNode, IOperatorCollapser> operatorCollapsers = + new HashMap<>(); operatorCollapsers.put(OperatorDiceNode.ADD, - (leftNode, rightNode) -> { - return leftNode.merge((leftValue, leftAST) -> { - return rightNode.merge((rightValue, rightAST) -> { - return new Pair<>(leftValue + rightValue, - new AST<>(OperatorDiceNode.ADD, - leftAST, rightAST)); - }); - }); + new ArithmeticCollapser(OperatorDiceNode.ADD, + (left, right) -> left + right)); - }); operatorCollapsers.put(OperatorDiceNode.SUBTRACT, - (leftNode, rightNode) -> { - return leftNode.merge((leftValue, leftAST) -> { - return rightNode.merge((rightValue, rightAST) -> { - return new Pair<>(leftValue - rightValue, - new AST<>(OperatorDiceNode.SUBTRACT, - leftAST, rightAST)); - }); - }); - }); + new ArithmeticCollapser(OperatorDiceNode.SUBTRACT, + (left, right) -> left - right)); operatorCollapsers.put(OperatorDiceNode.MULTIPLY, - (leftNode, rightNode) -> { - return leftNode.merge((leftValue, leftAST) -> { - return rightNode.merge((rightValue, rightAST) -> { - return new Pair<>(leftValue * rightValue, - new AST<>(OperatorDiceNode.MULTIPLY, - leftAST, rightAST)); - }); - }); + new ArithmeticCollapser(OperatorDiceNode.MULTIPLY, + (left, right) -> left * right)); - }); operatorCollapsers.put(OperatorDiceNode.DIVIDE, - (leftNode, rightNode) -> { - return leftNode.merge((leftValue, leftAST) -> { - return rightNode.merge((rightValue, rightAST) -> { - if (rightValue == 0) { - throw new ArithmeticException( - "Attempted to divide by zero. The AST of the problem expression is " - + rightAST); - } - - return new Pair<>(leftValue / rightValue, - new AST<>(OperatorDiceNode.DIVIDE, - leftAST, rightAST)); - }); - }); - }); + new ArithmeticCollapser(OperatorDiceNode.DIVIDE, + (left, right) -> left / right)); operatorCollapsers.put(OperatorDiceNode.ASSIGN, (left, right) -> { return parseBinding(enviroment, left, right); @@ -111,9 +110,46 @@ public class DiceASTExpression implements IDiceExpression { operatorCollapsers.put(OperatorDiceNode.GROUP, DiceASTExpression::parseGroup); + operatorCollapsers.put(OperatorDiceNode.LET, (left, right) -> { + return doLet(enviroment, left, right); + }); + return operatorCollapsers; } + private static Pair<Integer, AST<IDiceASTNode>> doLet( + Map<String, DiceASTExpression> enviroment, + Pair<Integer, AST<IDiceASTNode>> left, + Pair<Integer, AST<IDiceASTNode>> right) { + return left.merge((leftValue, leftAST) -> { + return right.merge((rightValue, rightAST) -> { + if (!leftAST + .applyToHead(DiceASTExpression::isAssignNode)) { + // Just ignore the left block then + return new Pair<>(rightValue, rightAST); + } else { + // Left block has an assignment to handle + String varName = leftAST.applyToLeft((leftBranch) -> { + return getAssignmentVar(leftBranch); + }); + + return null; + } + }); + }); + } + + private static String getAssignmentVar(AST<IDiceASTNode> leftBranch) { + return leftBranch.applyToHead((node) -> { + return ((VariableDiceNode) node).getVariable(); + }); + } + + private static Boolean isAssignNode(IDiceASTNode node) { + return node.getType() == DiceASTType.OPERATOR + && node == OperatorDiceNode.ASSIGN; + } + private static Pair<Integer, AST<IDiceASTNode>> parseBinding( Map<String, DiceASTExpression> enviroment, Pair<Integer, AST<IDiceASTNode>> left, @@ -129,8 +165,9 @@ public class DiceASTExpression implements IDiceExpression { GenHolder<Boolean> selfReference = new GenHolder<>(false); - DiceASTReferenceChecker refChecker = new DiceASTReferenceChecker( - selfReference, variableName); + DiceASTReferenceChecker refChecker = + new DiceASTReferenceChecker(selfReference, + variableName); rightAST.traverse(TreeLinearizationMethod.PREORDER, refChecker); @@ -163,8 +200,8 @@ public class DiceASTExpression implements IDiceExpression { Pair<Integer, AST<IDiceASTNode>> rightNode) { return leftNode.merge((leftValue, leftAST) -> { return rightNode.merge((rightValue, rightAST) -> { - int compoundValue = Integer - .parseInt(Integer.toString(leftValue) + int compoundValue = + Integer.parseInt(Integer.toString(leftValue) + Integer.toString(rightValue)); return new Pair<>(compoundValue, new AST<>( @@ -190,8 +227,8 @@ public class DiceASTExpression implements IDiceExpression { + rightAST); } - int rolledValue = new ComplexDice(leftValue, rightValue) - .roll(); + int rolledValue = + new ComplexDice(leftValue, rightValue).roll(); return new Pair<>(rolledValue, new AST<>( OperatorDiceNode.GROUP, leftAST, rightAST)); @@ -231,8 +268,8 @@ public class DiceASTExpression implements IDiceExpression { * @return A pair consisting of the token's value and the AST it * represents */ - private Pair<Integer, AST<IDiceASTNode>> evaluateLeaf( - IDiceASTNode leafNode) { + private Pair<Integer, AST<IDiceASTNode>> + evaluateLeaf(IDiceASTNode leafNode) { if (leafNode.getType() == DiceASTType.VARIABLE) { VariableDiceNode node = (VariableDiceNode) leafNode; @@ -247,8 +284,8 @@ public class DiceASTExpression implements IDiceExpression { } } - private Pair<Integer, AST<IDiceASTNode>> parseVariable( - VariableDiceNode leafNode) { + private Pair<Integer, AST<IDiceASTNode>> + parseVariable(VariableDiceNode leafNode) { String varName = leafNode.getVariable(); if (env.containsKey(varName)) { @@ -276,8 +313,8 @@ public class DiceASTExpression implements IDiceExpression { */ @Override public int roll() { - Map<IDiceASTNode, IOperatorCollapser> operations = buildOperations( - env); + Map<IDiceASTNode, IOperatorCollapser> operations = + buildOperations(env); return ast.collapse(this::evaluateLeaf, operations::get, (returnedValue) -> returnedValue diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTFlattener.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTFlattener.java index a54a088..a7500a8 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTFlattener.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTFlattener.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.HashMap; import java.util.Map; diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTInliner.java index ef4a904..3a8e796 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTInliner.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.function.Function; @@ -7,6 +7,8 @@ import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.VariableDiceNode; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.FunctionalMap; +import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.IFunctionalMap; import bjc.utils.parserutils.AST; /** @@ -19,9 +21,9 @@ import bjc.utils.parserutils.AST; public class DiceASTInliner { private static class NodeInliner implements Function<IDiceASTNode, AST<IDiceASTNode>> { - private FunctionalMap<String, AST<IDiceASTNode>> enviroment; + private IFunctionalMap<String, AST<IDiceASTNode>> enviroment; - public NodeInliner(FunctionalMap<String, AST<IDiceASTNode>> env) { + public NodeInliner(IFunctionalMap<String, AST<IDiceASTNode>> env) { enviroment = env; } @@ -29,13 +31,13 @@ public class DiceASTInliner { public AST<IDiceASTNode> apply(IDiceASTNode nod) { if (nod.getType() == DiceASTType.VARIABLE) { return expandNode((VariableDiceNode) nod); - } else { - return new AST<>(nod); } + + return new AST<>(nod); } - protected AST<IDiceASTNode> - expandNode(VariableDiceNode variableNode) { + protected AST<IDiceASTNode> expandNode( + VariableDiceNode variableNode) { String varName = variableNode.getVariable(); if (!enviroment.containsKey(varName)) { @@ -50,24 +52,24 @@ public class DiceASTInliner { private static final class SelectiveInliner extends NodeInliner { - private FunctionalList<String> variableNames; + private IFunctionalList<String> variableNames; public SelectiveInliner( - FunctionalMap<String, AST<IDiceASTNode>> env, - FunctionalList<String> varNames) { + IFunctionalMap<String, AST<IDiceASTNode>> env, + IFunctionalList<String> varNames) { super(env); variableNames = varNames; } @Override - protected AST<IDiceASTNode> - expandNode(VariableDiceNode variableNode) { + protected AST<IDiceASTNode> expandNode( + VariableDiceNode variableNode) { if (variableNames.contains(variableNode.getVariable())) { return super.expandNode(variableNode); - } else { - return new AST<>(variableNode); } + + return new AST<>(variableNode); } } @@ -81,7 +83,7 @@ public class DiceASTInliner { * @return The tree with references inlined */ public static AST<IDiceASTNode> inlineAST(AST<IDiceASTNode> tree, - FunctionalMap<String, AST<IDiceASTNode>> env) { + IFunctionalMap<String, AST<IDiceASTNode>> env) { return selectiveInline(tree, env); } @@ -112,7 +114,7 @@ public class DiceASTInliner { * @return An AST with the specified variables inlined */ public static AST<IDiceASTNode> selectiveInline(AST<IDiceASTNode> tree, - FunctionalMap<String, AST<IDiceASTNode>> env, + IFunctionalMap<String, AST<IDiceASTNode>> env, String... varNames) { return selectiveInline(tree, env, new FunctionalList<>(varNames)); } @@ -129,8 +131,8 @@ public class DiceASTInliner { * @return An AST with the specified variables inline */ public static AST<IDiceASTNode> selectiveInline(AST<IDiceASTNode> tree, - FunctionalMap<String, AST<IDiceASTNode>> env, - FunctionalList<String> varNames) { - return tree.expand(new SelectiveInliner(env, varNames)); + IFunctionalMap<String, AST<IDiceASTNode>> env, + IFunctionalList<String> varNames) { + return tree.flatMapTree(new SelectiveInliner(env, varNames)); } }
\ No newline at end of file diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTParser.java index fb77ad5..d8e13f7 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTParser.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTParser.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.Deque; import java.util.LinkedList; @@ -10,9 +10,10 @@ import bjc.dicelang.ast.nodes.IDiceASTNode; import bjc.dicelang.ast.nodes.LiteralDiceNode; import bjc.dicelang.ast.nodes.OperatorDiceNode; import bjc.dicelang.ast.nodes.VariableDiceNode; +import bjc.utils.data.IPair; import bjc.utils.data.Pair; -import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcdata.IFunctionalList; import bjc.utils.funcutils.ListUtils; import bjc.utils.parserutils.AST; import bjc.utils.parserutils.ShuntingYard; @@ -56,7 +57,8 @@ public class DiceASTParser { try { Integer.parseInt(tok); return true; - } catch (NumberFormatException nfx) { + } catch (@SuppressWarnings("unused") NumberFormatException nfex) { + // We don't care about details return false; } } @@ -86,11 +88,11 @@ public class DiceASTParser { * The string to build from * @return An AST built from the passed in string */ - public AST<IDiceASTNode> buildAST(String exp) { - FunctionalList<String> tokens = - FunctionalStringTokenizer.fromString(exp).toList(); + public static AST<IDiceASTNode> buildAST(String exp) { + IFunctionalList<String> tokens = FunctionalStringTokenizer + .fromString(exp).toList(); - Deque<Pair<String, String>> ops = new LinkedList<>(); + Deque<IPair<String, String>> ops = new LinkedList<>(); ops.add(new Pair<>("+", "\\+")); ops.add(new Pair<>("-", "-")); @@ -98,19 +100,19 @@ public class DiceASTParser { ops.add(new Pair<>("/", "/")); ops.add(new Pair<>(":=", ":=")); - FunctionalList<String> semiExpandedTokens = - ListUtils.splitTokens(tokens, ops); + IFunctionalList<String> semiExpandedTokens = ListUtils + .splitTokens(tokens, ops); ops = new LinkedList<>(); ops.add(new Pair<>("(", "\\(")); ops.add(new Pair<>(")", "\\)")); - FunctionalList<String> fullyExpandedTokens = - ListUtils.deAffixTokens(semiExpandedTokens, ops); + IFunctionalList<String> fullyExpandedTokens = ListUtils + .deAffixTokens(semiExpandedTokens, ops); - FunctionalList<String> shunted = - yard.postfix(fullyExpandedTokens, (s) -> s); + IFunctionalList<String> shunted = yard.postfix(fullyExpandedTokens, + (s) -> s); AST<String> rawAST = TreeConstructor.constructTree(shunted, DiceASTParser::isOperator); diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTReferenceChecker.java index 8fa4d55..e526ee9 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTReferenceChecker.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/DiceASTReferenceChecker.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.function.Consumer; diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java b/dice-lang/src/main/java/bjc/dicelang/old/ast/IOperatorCollapser.java index c872583..65cb264 100644 --- a/dice-lang/src/main/java/bjc/dicelang/ast/IOperatorCollapser.java +++ b/dice-lang/src/main/java/bjc/dicelang/old/ast/IOperatorCollapser.java @@ -1,4 +1,4 @@ -package bjc.dicelang.ast; +package bjc.dicelang.old.ast; import java.util.function.BinaryOperator; @@ -14,5 +14,5 @@ import bjc.utils.parserutils.AST; */ public interface IOperatorCollapser extends BinaryOperator<Pair<Integer, AST<IDiceASTNode>>> { - + // Just an alias } |