diff options
| author | EVE <EVE@EVE-PC> | 2017-03-13 16:41:45 -0400 |
|---|---|---|
| committer | EVE <EVE@EVE-PC> | 2017-03-13 16:41:45 -0400 |
| commit | 01136c6796e21f023713e026674576d8e623462d (patch) | |
| tree | e77886fe0e0adaf3c0430fba9ce248ef83f74fe4 /dice-lang/src/bjc/dicelang/v1 | |
| parent | 870d769cfc152171d27b2331a7c590d0b307ad48 (diff) | |
Formatting
Diffstat (limited to 'dice-lang/src/bjc/dicelang/v1')
40 files changed, 689 insertions, 903 deletions
diff --git a/dice-lang/src/bjc/dicelang/v1/BindingDiceExpression.java b/dice-lang/src/bjc/dicelang/v1/BindingDiceExpression.java index 019f5ee..cce31a2 100644 --- a/dice-lang/src/bjc/dicelang/v1/BindingDiceExpression.java +++ b/dice-lang/src/bjc/dicelang/v1/BindingDiceExpression.java @@ -13,33 +13,32 @@ public class BindingDiceExpression implements IDiceExpression { /* * The expression being bound to a name */ - private IDiceExpression expression; + private IDiceExpression expression; /* * The name to bind the expression to */ - private String name; + private String name; /** * Create a new dice expression binder from two expressions and an * enviroment * * @param left - * The left side expression to get a name from. Must be a - * ReferenceDiceExpression + * The left side expression to get a name from. Must be a + * ReferenceDiceExpression * @param right - * The right side to bind to the name + * The right side to bind to the name * @param enviroment - * The enviroment to bind into + * The enviroment to bind into */ - public BindingDiceExpression(IDiceExpression left, - IDiceExpression right, + public BindingDiceExpression(IDiceExpression left, IDiceExpression right, Map<String, IDiceExpression> enviroment) { if (!(left instanceof ReferenceDiceExpression)) { throw new UnsupportedOperationException( "Error: Binding an expression to something that is not a variable reference," - + " or array thereof. is unsupported." - + " Problematic expression is " + left); + + " or array thereof. is unsupported." + + " Problematic expression is " + left); } String varName = ((ReferenceDiceExpression) left).getName(); @@ -51,19 +50,17 @@ public class BindingDiceExpression implements IDiceExpression { * Create a new dice expression binder * * @param name - * The name of the variable to bind + * The name of the variable to bind * @param expression - * The expression to bind to the variable + * The expression to bind to the variable * @param enviroment - * The enviroment to bind it in + * The enviroment to bind it in */ - public BindingDiceExpression(String name, IDiceExpression expression, - Map<String, IDiceExpression> enviroment) { + public BindingDiceExpression(String name, IDiceExpression expression, Map<String, IDiceExpression> enviroment) { initialize(name, expression, enviroment); } - private void initialize(String name, IDiceExpression expr, - Map<String, IDiceExpression> enviroment) { + private void initialize(String name, IDiceExpression expr, Map<String, IDiceExpression> enviroment) { this.name = name; this.expression = expr; @@ -87,7 +84,6 @@ public class BindingDiceExpression implements IDiceExpression { */ @Override public String toString() { - return "assign[n=" + name + ", exp=" - + expression.toString() + "]"; + return "assign[n=" + name + ", exp=" + expression.toString() + "]"; } } diff --git a/dice-lang/src/bjc/dicelang/v1/ComplexDice.java b/dice-lang/src/bjc/dicelang/v1/ComplexDice.java index 62d59c6..b9796f9 100644 --- a/dice-lang/src/bjc/dicelang/v1/ComplexDice.java +++ b/dice-lang/src/bjc/dicelang/v1/ComplexDice.java @@ -1,8 +1,8 @@ package bjc.dicelang.v1; /** - * Implements a collection of one or more of a particular die, where the - * number of dice in the group is variable. + * Implements a collection of one or more of a particular die, where the number + * of dice in the group is variable. * * @author ben * @@ -12,7 +12,7 @@ public class ComplexDice implements IDiceExpression { * Create a dice from a string expression * * @param expression - * The string to parse the dice from + * The string to parse the dice from * @return A dice group parsed from the string */ public static IDiceExpression fromString(String expression) { @@ -28,38 +28,35 @@ public class ComplexDice implements IDiceExpression { try { // Create the actual group of dice - return new ComplexDice( - new ScalarDie(Integer.parseInt(strangs[0])), + return new ComplexDice(new ScalarDie(Integer.parseInt(strangs[0])), new Die(Integer.parseInt(strangs[1]))); } catch (NumberFormatException nfex) { // We don't care about details // Tell the user the expression is invalid - throw new IllegalArgumentException( - "Attempted to create a set of dice using invalid arguments." - + " They must be integers. " + strangs[0] - + " and " + strangs[1] - + " are likely culprits."); + throw new IllegalArgumentException("Attempted to create a set of dice using invalid arguments." + + " They must be integers. " + strangs[0] + " and " + strangs[1] + + " are likely culprits."); } } /* * The die being rolled */ - private IDiceExpression die; + private IDiceExpression die; /* * The number of the particular die to roll */ - private IDiceExpression nDice; + private IDiceExpression nDice; /** * Create a new collection of dice * * @param nDce - * The number of dice in the collection + * The number of dice in the collection * @param de - * The type of dice the collection is composed of + * The type of dice the collection is composed of */ public ComplexDice(IDiceExpression nDce, IDiceExpression de) { nDice = nDce; @@ -70,9 +67,9 @@ public class ComplexDice implements IDiceExpression { * Create a new collection of dice * * @param nSides - * The number of dice in the collection + * The number of dice in the collection * @param de - * The type of dice the collection is composed of + * The type of dice the collection is composed of */ public ComplexDice(int nSides, int de) { nDice = new ScalarDie(nSides); @@ -93,10 +90,9 @@ public class ComplexDice implements IDiceExpression { @Override public int optimize() { if (!canOptimize()) { - throw new UnsupportedOperationException( - "This complex dice cannot be optimized. " - + "Both the dice to be rolled and the number of" - + " dice must be optimizable."); + throw new UnsupportedOperationException("This complex dice cannot be optimized. " + + "Both the dice to be rolled and the number of" + + " dice must be optimizable."); } return nDice.optimize(); @@ -112,9 +108,8 @@ public class ComplexDice implements IDiceExpression { int nRoll = nDice.roll(); if (nRoll < 0) { - throw new UnsupportedOperationException( - "Attempted to roll a negative number of dice. " - + "The problematic expression is " + nDice); + throw new UnsupportedOperationException("Attempted to roll a negative number of dice. " + + "The problematic expression is " + nDice); } // Roll all the dice and combine them @@ -132,7 +127,6 @@ public class ComplexDice implements IDiceExpression { return nDice.toString() + die.toString(); } - return "complex[n=" + nDice.toString() + ", d=" + die.toString() - + "]"; + return "complex[n=" + nDice.toString() + ", d=" + die.toString() + "]"; } } diff --git a/dice-lang/src/bjc/dicelang/v1/CompoundDice.java b/dice-lang/src/bjc/dicelang/v1/CompoundDice.java index 2d53540..a70ae39 100644 --- a/dice-lang/src/bjc/dicelang/v1/CompoundDice.java +++ b/dice-lang/src/bjc/dicelang/v1/CompoundDice.java @@ -3,8 +3,8 @@ package bjc.dicelang.v1; /** * Implements a "compound dice" * - * To explain, a compound dice is something like a d100 composed from two - * d10s instead of a hundred sided die. + * To explain, a compound dice is something like a d100 composed from two d10s + * instead of a hundred sided die. * * @author ben * @@ -13,20 +13,20 @@ public class CompoundDice implements IDiceExpression { /* * The left die of the expression */ - private IDiceExpression left; + private IDiceExpression left; /* * The right die of the expression */ - private IDiceExpression right; + private IDiceExpression right; /** * Create a new compound dice using the specified dice * * @param lft - * The die to use on the left + * The die to use on the left * @param rght - * The die to use on the right + * The die to use on the right */ public CompoundDice(IDiceExpression lft, IDiceExpression rght) { this.left = lft; @@ -37,20 +37,19 @@ public class CompoundDice implements IDiceExpression { * Create a new compound dice from two dice strings * * @param lft - * The left side dice as a string + * The left side dice as a string * @param rght - * The right side dice as a string + * The right side dice as a string */ public CompoundDice(String lft, String rght) { - this(ComplexDice.fromString(lft), - ComplexDice.fromString(rght)); + this(ComplexDice.fromString(lft), ComplexDice.fromString(rght)); } /** * Create a new compound dice from an array of dice strings * * @param exps - * An array of two dice strings + * An array of two dice strings */ public CompoundDice(String[] exps) { this(exps[0], exps[1]); @@ -64,14 +63,11 @@ public class CompoundDice implements IDiceExpression { @Override public int optimize() { if (!canOptimize()) { - throw new UnsupportedOperationException( - "Cannot optimize this compound dice. " - + "Both component dice must be optimizable" - + " to optimize a compound dice"); + throw new UnsupportedOperationException("Cannot optimize this compound dice. " + + "Both component dice must be optimizable" + " to optimize a compound dice"); } - return Integer - .parseInt(left.optimize() + "" + right.optimize()); + return Integer.parseInt(left.optimize() + "" + right.optimize()); } @Override @@ -84,7 +80,6 @@ public class CompoundDice implements IDiceExpression { @Override public String toString() { - return "compound[l=" + left.toString() + ", r=" - + right.toString() + "]"; + return "compound[l=" + left.toString() + ", r=" + right.toString() + "]"; } } diff --git a/dice-lang/src/bjc/dicelang/v1/DiceExpressionBuilder.java b/dice-lang/src/bjc/dicelang/v1/DiceExpressionBuilder.java index eb19c2a..e0c62c1 100644 --- a/dice-lang/src/bjc/dicelang/v1/DiceExpressionBuilder.java +++ b/dice-lang/src/bjc/dicelang/v1/DiceExpressionBuilder.java @@ -21,7 +21,7 @@ public class DiceExpressionBuilder { * Build a dice expression from a seed dice expression * * @param seed - * The dice expression to use as a seed + * The dice expression to use as a seed */ public DiceExpressionBuilder(IDiceExpression seed) { baking = seed; @@ -31,9 +31,9 @@ public class DiceExpressionBuilder { * Build a dice expression from a seed dice * * @param nSides - * The number of sides in the dice + * The number of sides in the dice * @param nDice - * The number of dice in the group + * The number of dice in the group */ public DiceExpressionBuilder(int nSides, int nDice) { baking = new ComplexDice(nSides, nDice); @@ -43,7 +43,7 @@ public class DiceExpressionBuilder { * Add a term to this dice expression * * @param exp - * The expression to use on the left + * The expression to use on the left * @return A new expression adding the two dice */ public DiceExpressionBuilder add(IDiceExpression exp) { @@ -55,12 +55,11 @@ public class DiceExpressionBuilder { * Add a scalar to this dice * * @param num - * The scalar to add to the dice + * The scalar to add to the dice * @return A dice expression adding a scalar to this */ public DiceExpressionBuilder add(int num) { - baking = new OperatorDiceExpression(baking, new ScalarDie(num), - ADD); + baking = new OperatorDiceExpression(baking, new ScalarDie(num), ADD); return this; } @@ -77,7 +76,7 @@ public class DiceExpressionBuilder { * Divide a term from dice expression * * @param exp - * The expression to use on the left + * The expression to use on the left * @return A new expression dividing the two dice */ public DiceExpressionBuilder divide(IDiceExpression exp) { @@ -89,12 +88,11 @@ public class DiceExpressionBuilder { * Divide a scalar from this dice * * @param num - * The scalar to add to the dice + * The scalar to add to the dice * @return A dice expression dividing a scalar from this */ public DiceExpressionBuilder divide(int num) { - baking = new OperatorDiceExpression(baking, new ScalarDie(num), - DIVIDE); + baking = new OperatorDiceExpression(baking, new ScalarDie(num), DIVIDE); return this; } @@ -102,7 +100,7 @@ public class DiceExpressionBuilder { * Multiply a term by this dice expression * * @param exp - * The expression to use on the left + * The expression to use on the left * @return A new expression multiplying the two dice */ public DiceExpressionBuilder multiply(IDiceExpression exp) { @@ -114,12 +112,11 @@ public class DiceExpressionBuilder { * Multiply a scalar by this dice * * @param num - * The scalar to multiply to the dice + * The scalar to multiply to the dice * @return A dice expression multiplying a scalar to this */ public DiceExpressionBuilder multiply(int num) { - baking = new OperatorDiceExpression(baking, new ScalarDie(num), - MULTIPLY); + baking = new OperatorDiceExpression(baking, new ScalarDie(num), MULTIPLY); return this; } @@ -127,7 +124,7 @@ public class DiceExpressionBuilder { * Add a term to this dice expression * * @param exp - * The expression to use on the left + * The expression to use on the left * @return A new expression adding the two dice */ public DiceExpressionBuilder subtract(IDiceExpression exp) { @@ -139,12 +136,11 @@ public class DiceExpressionBuilder { * Add a scalar to this dice * * @param num - * The scalar to add to the dice + * The scalar to add to the dice * @return A dice expression adding a scalar to this */ public DiceExpressionBuilder subtract(int num) { - baking = new OperatorDiceExpression(baking, new ScalarDie(num), - SUBTRACT); + baking = new OperatorDiceExpression(baking, new ScalarDie(num), SUBTRACT); return this; } } diff --git a/dice-lang/src/bjc/dicelang/v1/DiceExpressionParser.java b/dice-lang/src/bjc/dicelang/v1/DiceExpressionParser.java index fd8f37b..38a842e 100644 --- a/dice-lang/src/bjc/dicelang/v1/DiceExpressionParser.java +++ b/dice-lang/src/bjc/dicelang/v1/DiceExpressionParser.java @@ -20,18 +20,16 @@ public class DiceExpressionParser { * Parse a dice expression from a string * * @param expression - * The string to parse an expression from + * The string to parse an expression from * @param enviroment - * The enviroment to use when parsing expressions + * The enviroment to use when parsing expressions * @return The parsed dice expression */ - public static IDiceExpression parse(String expression, - Map<String, IDiceExpression> enviroment) { + public static IDiceExpression parse(String expression, Map<String, IDiceExpression> enviroment) { /* * Create a tokenizer over the strings */ - FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer( - expression); + FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(expression); /* * Create a shunter to rewrite the expression @@ -42,11 +40,13 @@ public class DiceExpressionParser { * Add our custom operators to the yard */ yard.addOp("d", 5); // dice operator: use for creating variable - // size dice groups - yard.addOp("c", 6); // compound operator: use for creating compound - // dice from expressions - yard.addOp(":=", 0); // binding operator: Bind a name to a variable - // expression + // size dice groups + yard.addOp("c", 6); // compound operator: use for creating + // compound + // dice from expressions + yard.addOp(":=", 0); // binding operator: Bind a name to a + // variable + // expression /* * Shunt the expression to postfix form @@ -81,80 +81,66 @@ public class DiceExpressionParser { /* * Handle scalar numbers */ - expressions.push(new ScalarDie( - Integer.parseInt(expressionPart))); + expressions.push(new ScalarDie(Integer.parseInt(expressionPart))); } catch (NumberFormatException nfex) { - // We don't care about details, just that it failed + // We don't care about details, just + // that it failed if (expressions.size() >= 2) { /* - * Apply an operation to two dice + * Apply an operation to two + * dice */ - IDiceExpression right = expressions - .pop(); + IDiceExpression right = expressions.pop(); IDiceExpression left = expressions.pop(); switch (expressionPart) { - case ":=": - expressions.push(new BindingDiceExpression( - left, right, - enviroment)); - break; - case "+": - expressions - .push(new OperatorDiceExpression( - right, - left, - DiceExpressionType.ADD)); - break; - case "-": - expressions - .push(new OperatorDiceExpression( - right, - left, - DiceExpressionType.SUBTRACT)); - break; - case "*": - expressions - .push(new OperatorDiceExpression( - right, - left, - DiceExpressionType.MULTIPLY)); - break; - case "/": - expressions - .push(new OperatorDiceExpression( - right, - left, - DiceExpressionType.DIVIDE)); - break; - case "c": - expressions.push(new CompoundDice( - left, right)); - break; - case "d": - expressions.push(new ComplexDice( - left, right)); - break; - default: - /* - * Parse it as a variable reference - * - * Make sure to restore popped variables - */ - expressions.push(left); - expressions.push(right); + case ":=": + expressions.push(new BindingDiceExpression(left, right, + enviroment)); + break; + case "+": + expressions.push(new OperatorDiceExpression(right, left, + DiceExpressionType.ADD)); + break; + case "-": + expressions.push(new OperatorDiceExpression(right, left, + DiceExpressionType.SUBTRACT)); + break; + case "*": + expressions.push(new OperatorDiceExpression(right, left, + DiceExpressionType.MULTIPLY)); + break; + case "/": + expressions.push(new OperatorDiceExpression(right, left, + DiceExpressionType.DIVIDE)); + break; + case "c": + expressions.push(new CompoundDice(left, right)); + break; + case "d": + expressions.push(new ComplexDice(left, right)); + break; + default: + /* + * Parse it as a + * variable reference + * + * Make sure to restore + * popped variables + */ + expressions.push(left); + expressions.push(right); - expressions - .push(new ReferenceDiceExpression( - expressionPart, - enviroment)); + expressions.push(new ReferenceDiceExpression(expressionPart, + enviroment)); } } else { /* - * Parse it as a variable reference + * Parse it as a variable + * reference */ - expressions.push(new ReferenceDiceExpression( - expressionPart, enviroment)); + expressions.push(new ReferenceDiceExpression(expressionPart, + enviroment)); } } } diff --git a/dice-lang/src/bjc/dicelang/v1/DiceExpressionType.java b/dice-lang/src/bjc/dicelang/v1/DiceExpressionType.java index 0c22f2a..8ffe78d 100644 --- a/dice-lang/src/bjc/dicelang/v1/DiceExpressionType.java +++ b/dice-lang/src/bjc/dicelang/v1/DiceExpressionType.java @@ -27,18 +27,17 @@ public enum DiceExpressionType { @Override public String toString() { switch (this) { - case ADD: - return "+"; - case DIVIDE: - return "/"; - case MULTIPLY: - return "*"; - case SUBTRACT: - return "-"; - default: - throw new IllegalArgumentException( - "Got passed a invalid ScalarExpressionType " - + this + ". WAT"); + case ADD: + return "+"; + case DIVIDE: + return "/"; + case MULTIPLY: + return "*"; + case SUBTRACT: + return "-"; + default: + throw new IllegalArgumentException( + "Got passed a invalid ScalarExpressionType " + this + ". WAT"); } }; } diff --git a/dice-lang/src/bjc/dicelang/v1/Die.java b/dice-lang/src/bjc/dicelang/v1/Die.java index 14c7a83..ffb6093 100644 --- a/dice-lang/src/bjc/dicelang/v1/Die.java +++ b/dice-lang/src/bjc/dicelang/v1/Die.java @@ -12,23 +12,22 @@ public class Die implements IDiceExpression { /* * Random # gen to use for dice */ - private static Random rng = new Random(); + private static Random rng = new Random(); /* * Number of sides this die has */ - private int nSides; + private int nSides; /** * Create a die with the specified number of sides * * @param nSides - * The number of sides this dice has + * The number of sides this dice has */ public Die(int nSides) { if (nSides < 1) { - throw new UnsupportedOperationException( - "Dice with less than 1 side are not supported"); + throw new UnsupportedOperationException("Dice with less than 1 side are not supported"); } this.nSides = nSides; @@ -42,8 +41,7 @@ public class Die implements IDiceExpression { @Override public int optimize() { if (nSides != 1) { - throw new UnsupportedOperationException( - "Can't optimize " + nSides + "-sided dice"); + throw new UnsupportedOperationException("Can't optimize " + nSides + "-sided dice"); } return 1; diff --git a/dice-lang/src/bjc/dicelang/v1/IDiceExpression.java b/dice-lang/src/bjc/dicelang/v1/IDiceExpression.java index a0b78b8..86c4d6a 100644 --- a/dice-lang/src/bjc/dicelang/v1/IDiceExpression.java +++ b/dice-lang/src/bjc/dicelang/v1/IDiceExpression.java @@ -22,11 +22,11 @@ public interface IDiceExpression { * <li>Dice concatenation - '1d10c1d10</li> * </ul> * - * Dice concatenation is like using 2 d10s to emulate a d100, so - * instead of adding them, it reads them side by side. + * Dice concatenation is like using 2 d10s to emulate a d100, so instead + * of adding them, it reads them side by side. * * @param expression - * The string to convert to an expression + * The string to convert to an expression * * @return The string, converted into expression form */ @@ -52,8 +52,8 @@ public interface IDiceExpression { return new ScalarDie(Integer.parseInt(literalData)); } catch (NumberFormatException nfex) { UnsupportedOperationException usex = new UnsupportedOperationException( - "Found malformed leaf token " + expression + ". Floating point numbers " + - "are not supported."); + "Found malformed leaf token " + expression + ". Floating point numbers " + + "are not supported."); usex.initCause(nfex); @@ -78,11 +78,10 @@ public interface IDiceExpression { * @return This expression, optimized to a scalar value * * @throws UnsupportedOperationException - * if this type of expression can't be optimized + * if this type of expression can't be optimized */ public default int optimize() { - throw new UnsupportedOperationException( - "Can't optimize this type of expression"); + throw new UnsupportedOperationException("Can't optimize this type of expression"); } /** diff --git a/dice-lang/src/bjc/dicelang/v1/OperatorDiceExpression.java b/dice-lang/src/bjc/dicelang/v1/OperatorDiceExpression.java index ac630a8..bf9254e 100644 --- a/dice-lang/src/bjc/dicelang/v1/OperatorDiceExpression.java +++ b/dice-lang/src/bjc/dicelang/v1/OperatorDiceExpression.java @@ -10,30 +10,29 @@ public class OperatorDiceExpression implements IDiceExpression { /* * The operator to use for combining the dice */ - private DiceExpressionType type; + private DiceExpressionType type; /* * The dice on the left side of the expression */ - private IDiceExpression left; + private IDiceExpression left; /* * The dice on the right side of the expression */ - private IDiceExpression right; + private IDiceExpression right; /** * Create a new compound expression using the specified parameters * * @param rght - * The die on the right side of the expression + * The die on the right side of the expression * @param lft - * The die on the left side of the expression + * The die on the left side of the expression * @param type - * The operator to use for combining the dices + * The operator to use for combining the dices */ - public OperatorDiceExpression(IDiceExpression rght, - IDiceExpression lft, DiceExpressionType type) { + public OperatorDiceExpression(IDiceExpression rght, IDiceExpression lft, DiceExpressionType type) { this.right = rght; this.left = lft; this.type = type; @@ -45,42 +44,37 @@ public class OperatorDiceExpression implements IDiceExpression { * Handle each operator */ switch (type) { - case ADD: - return right.roll() + left.roll(); - case SUBTRACT: - return right.roll() - left.roll(); - case MULTIPLY: - return right.roll() * left.roll(); - case DIVIDE: - /* - * Round to keep results as integers. We don't really have - * any need for floating-point dice, and continuous - * probability is a pain - */ - try { - return right.roll() / left.roll(); - } catch (ArithmeticException aex) { - UnsupportedOperationException usex = new UnsupportedOperationException( - "Attempted to divide by zero." - + " Problematic expression is " - + left); + case ADD: + return right.roll() + left.roll(); + case SUBTRACT: + return right.roll() - left.roll(); + case MULTIPLY: + return right.roll() * left.roll(); + case DIVIDE: + /* + * Round to keep results as integers. We don't really + * have any need for floating-point dice, and continuous + * probability is a pain + */ + try { + return right.roll() / left.roll(); + } catch (ArithmeticException aex) { + UnsupportedOperationException usex = new UnsupportedOperationException( + "Attempted to divide by zero." + " Problematic expression is " + left); - usex.initCause(aex); + usex.initCause(aex); - throw usex; - } - default: - throw new IllegalArgumentException( - "Got passed a invalid ScalarExpressionType (" - + type + "). WAT"); + throw usex; + } + default: + throw new IllegalArgumentException( + "Got passed a invalid ScalarExpressionType (" + type + "). WAT"); } } @Override public String toString() { - return "dice-exp[type=" + type + ", l=" - + left.toString() + ", r=" - + right.toString() + "]"; + return "dice-exp[type=" + type + ", l=" + left.toString() + ", r=" + right.toString() + "]"; } } diff --git a/dice-lang/src/bjc/dicelang/v1/PolyhedralDice.java b/dice-lang/src/bjc/dicelang/v1/PolyhedralDice.java index 4af521b..e20a12a 100644 --- a/dice-lang/src/bjc/dicelang/v1/PolyhedralDice.java +++ b/dice-lang/src/bjc/dicelang/v1/PolyhedralDice.java @@ -20,7 +20,7 @@ public class PolyhedralDice { * Produce the specified number of 10-sided dice * * @param nDice - * The number of ten-sided dice to produce + * The number of ten-sided dice to produce * @return A group of ten-sided dice of the specified size */ public static IDiceExpression d10(int nDice) { @@ -40,7 +40,7 @@ public class PolyhedralDice { * Produce the specified number of 100-sided dice * * @param nDice - * The number of hundred-sided dice to produce + * The number of hundred-sided dice to produce * @return A group of hundred-sided dice of the specified size */ public static IDiceExpression d100(int nDice) { @@ -60,7 +60,7 @@ public class PolyhedralDice { * Produce the specified number of 12-sided dice * * @param nDice - * The number of twelve-sided dice to produce + * The number of twelve-sided dice to produce * @return A group of twelve-sided dice of the specified size */ public static IDiceExpression d12(int nDice) { @@ -80,7 +80,7 @@ public class PolyhedralDice { * Produce the specified number of 20-sided dice * * @param nDice - * The number of twenty-sided dice to produce + * The number of twenty-sided dice to produce * @return A group of twenty-sided dice of the specified size */ public static IDiceExpression d20(int nDice) { @@ -100,7 +100,7 @@ public class PolyhedralDice { * Produce the specified number of 4-sided dice * * @param nDice - * The number of four-sided dice to produce + * The number of four-sided dice to produce * @return A group of four-sided dice of the specified size */ public static IDiceExpression d4(int nDice) { @@ -120,7 +120,7 @@ public class PolyhedralDice { * Produce the specified number of 6-sided dice * * @param nDice - * The number of six-sided dice to produce + * The number of six-sided dice to produce * @return A group of six-sided dice of the specified size */ public static IDiceExpression d6(int nDice) { @@ -140,7 +140,7 @@ public class PolyhedralDice { * Produce the specified number of 8-sided dice * * @param nDice - * The number of eight-sided dice to produce + * The number of eight-sided dice to produce * @return A group of eight-sided dice of the specified size */ public static IDiceExpression d8(int nDice) { diff --git a/dice-lang/src/bjc/dicelang/v1/ReferenceDiceExpression.java b/dice-lang/src/bjc/dicelang/v1/ReferenceDiceExpression.java index bb7ce02..b3b979a 100644 --- a/dice-lang/src/bjc/dicelang/v1/ReferenceDiceExpression.java +++ b/dice-lang/src/bjc/dicelang/v1/ReferenceDiceExpression.java @@ -3,8 +3,7 @@ package bjc.dicelang.v1; import java.util.Map; /** - * A dice expression that refers to a variable bound in a mutable - * enviroment + * A dice expression that refers to a variable bound in a mutable enviroment * * @author ben * @@ -13,24 +12,23 @@ public class ReferenceDiceExpression implements IDiceExpression { /* * The enviroment to do variable dereferencing against */ - private Map<String, IDiceExpression> enviroment; + private Map<String, IDiceExpression> enviroment; /* * The name of the bound variable */ - private String name; + private String name; /** - * Create a new reference dice expression referring to the given name - * in an enviroment + * Create a new reference dice expression referring to the given name in + * an enviroment * * @param nme - * The name of the bound variable + * The name of the bound variable * @param env - * The enviroment to resolve the variable against + * The enviroment to resolve the variable against */ - public ReferenceDiceExpression(String nme, - Map<String, IDiceExpression> env) { + public ReferenceDiceExpression(String nme, Map<String, IDiceExpression> env) { this.name = nme; this.enviroment = env; } @@ -47,9 +45,7 @@ public class ReferenceDiceExpression implements IDiceExpression { @Override public int roll() { if (!enviroment.containsKey(name)) { - throw new UnsupportedOperationException( - "Attempted to reference undefined variable " - + name); + throw new UnsupportedOperationException("Attempted to reference undefined variable " + name); } return enviroment.get(name).roll(); diff --git a/dice-lang/src/bjc/dicelang/v1/ScalarDie.java b/dice-lang/src/bjc/dicelang/v1/ScalarDie.java index 94cf687..c0bb3a9 100644 --- a/dice-lang/src/bjc/dicelang/v1/ScalarDie.java +++ b/dice-lang/src/bjc/dicelang/v1/ScalarDie.java @@ -16,7 +16,7 @@ public class ScalarDie implements IDiceExpression { * Create a dice with the specified number * * @param num - * The number used for the dice + * The number used for the dice */ public ScalarDie(int num) { this.number = num; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java index 5a69bf1..1a41ce6 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/ArithmeticCollapser.java @@ -18,28 +18,25 @@ import bjc.utils.data.Tree; */ final class ArithmeticCollapser implements IOperatorCollapser { // The type of operator we're collapsing - private OperatorDiceNode type; + private OperatorDiceNode type; // The operator to use to collapse operators - private BinaryOperator<Integer> valueOp; + private BinaryOperator<Integer> valueOp; - private int initialValue; + private int initialValue; - public ArithmeticCollapser(OperatorDiceNode type, - BinaryOperator<Integer> valueOp, int initVal) { + public ArithmeticCollapser(OperatorDiceNode type, BinaryOperator<Integer> valueOp, int initVal) { this.type = type; this.valueOp = valueOp; this.initialValue = initVal; } @Override - public IPair<IResult, ITree<IDiceASTNode>> apply( - IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) { - IPair<IResult, ITree<IDiceASTNode>> initialState = new Pair<>( - new IntegerResult(initialValue), new Tree<>(type)); + public IPair<IResult, ITree<IDiceASTNode>> apply(IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) { + IPair<IResult, ITree<IDiceASTNode>> initialState = new Pair<>(new IntegerResult(initialValue), + new Tree<>(type)); - BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = ( - currentState, accumulatedState) -> { + BinaryOperator<IPair<IResult, ITree<IDiceASTNode>>> reducer = (currentState, accumulatedState) -> { // Force evaluation of accumulated state to prevent // certain bugs from occuring // accumulatedState.merge((l, r) -> null); @@ -47,90 +44,66 @@ final class ArithmeticCollapser implements IOperatorCollapser { return reduceStates(accumulatedState, currentState); }; - IPair<IResult, ITree<IDiceASTNode>> reducedState = nodes - .reduceAux(initialState, reducer, (state) -> state); + IPair<IResult, ITree<IDiceASTNode>> reducedState = nodes.reduceAux(initialState, reducer, + (state) -> state); return reducedState; } - private IList<IResult> combineArrayResults(IResult accumulatedValue, - IResult currentValue) { - IList<IResult> currentList = ((ArrayResult) currentValue) - .getValue(); - IList<IResult> accumulatedList = ((ArrayResult) accumulatedValue) - .getValue(); + private IList<IResult> combineArrayResults(IResult accumulatedValue, IResult currentValue) { + IList<IResult> currentList = ((ArrayResult) currentValue).getValue(); + IList<IResult> accumulatedList = ((ArrayResult) accumulatedValue).getValue(); if (currentList.getSize() != accumulatedList.getSize()) { - throw new UnsupportedOperationException( - "Can only apply operations to equal-length arrays"); + throw new UnsupportedOperationException("Can only apply operations to equal-length arrays"); } - IList<IResult> resultList = currentList.combineWith( - accumulatedList, (currentNode, accumulatedNode) -> { - boolean currentNotInt = currentNode - .getType() != ResultType.INTEGER; - boolean accumulatedNotInt = accumulatedNode - .getType() != ResultType.INTEGER; - - if (currentNotInt || accumulatedNotInt) { - throw new UnsupportedOperationException( - "Nesting of array operations isn't allowed"); - } - - int accumulatedInt = ((IntegerResult) accumulatedNode) - .getValue(); - int currentInt = ((IntegerResult) currentNode) - .getValue(); - - IResult combinedValue = new IntegerResult( - valueOp.apply(accumulatedInt, currentInt)); - return combinedValue; - }); + IList<IResult> resultList = currentList.combineWith(accumulatedList, (currentNode, accumulatedNode) -> { + boolean currentNotInt = currentNode.getType() != ResultType.INTEGER; + boolean accumulatedNotInt = accumulatedNode.getType() != ResultType.INTEGER; + + if (currentNotInt || accumulatedNotInt) { + throw new UnsupportedOperationException("Nesting of array operations isn't allowed"); + } + + int accumulatedInt = ((IntegerResult) accumulatedNode).getValue(); + int currentInt = ((IntegerResult) currentNode).getValue(); + + IResult combinedValue = new IntegerResult(valueOp.apply(accumulatedInt, currentInt)); + return combinedValue; + }); return resultList; } - private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse( - IResult accumulatedValue, ITree<IDiceASTNode> accumulatedTree, - IResult currentValue) { - if (accumulatedValue.getType() == ResultType.DUMMY - || currentValue.getType() == ResultType.DUMMY) { - DummyResult result = new DummyResult( - "Found dummy result with either accumulated dummy (" - + ((DummyResult) accumulatedValue).getData() - + ") or current dummy (" - + ((DummyResult) currentValue).getData() - + ")."); + private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse(IResult accumulatedValue, + ITree<IDiceASTNode> accumulatedTree, IResult currentValue) { + if (accumulatedValue.getType() == ResultType.DUMMY || currentValue.getType() == ResultType.DUMMY) { + DummyResult result = new DummyResult("Found dummy result with either accumulated dummy (" + + ((DummyResult) accumulatedValue).getData() + ") or current dummy (" + + ((DummyResult) currentValue).getData() + ")."); return new Pair<>(result, accumulatedTree); } - 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) { - IList<IResult> resultList = combineArrayResults( - accumulatedValue, currentValue); + IList<IResult> resultList = combineArrayResults(accumulatedValue, currentValue); - return new Pair<>(new ArrayResult(resultList), - accumulatedTree); + return new Pair<>(new ArrayResult(resultList), accumulatedTree); } - IList<IResult> resultList = halfCombineLists( - ((ArrayResult) currentValue).getValue(), + IList<IResult> resultList = halfCombineLists(((ArrayResult) currentValue).getValue(), accumulatedValue, true); - return new Pair<>(new ArrayResult(resultList), - accumulatedTree); + return new Pair<>(new ArrayResult(resultList), accumulatedTree); } else if (!accumulatedIsInt) { - IList<IResult> resultList = halfCombineLists( - ((ArrayResult) accumulatedValue).getValue(), + IList<IResult> resultList = halfCombineLists(((ArrayResult) accumulatedValue).getValue(), currentValue, false); - return new Pair<>(new ArrayResult(resultList), - accumulatedTree); + return new Pair<>(new ArrayResult(resultList), accumulatedTree); } int accumulatedInt = ((IntegerResult) accumulatedValue).getValue(); @@ -138,23 +111,19 @@ final class ArithmeticCollapser implements IOperatorCollapser { int combinedValue = valueOp.apply(accumulatedInt, currentInt); - return new Pair<>(new IntegerResult(combinedValue), - accumulatedTree); + return new Pair<>(new IntegerResult(combinedValue), accumulatedTree); } - private IList<IResult> halfCombineLists(IList<IResult> list, - IResult scalar, boolean scalarLeft) { + private IList<IResult> halfCombineLists(IList<IResult> list, IResult scalar, boolean scalarLeft) { if (scalar.getType() != ResultType.INTEGER) { - throw new UnsupportedOperationException( - "Nested array operations not supported"); + throw new UnsupportedOperationException("Nested array operations not supported"); } int scalarInt = ((IntegerResult) scalar).getValue(); return list.map((element) -> { if (element.getType() != ResultType.INTEGER) { - throw new UnsupportedOperationException( - "Nested array operations not supported"); + throw new UnsupportedOperationException("Nested array operations not supported"); } int elementInt = ((IntegerResult) element).getValue(); @@ -162,30 +131,23 @@ final class ArithmeticCollapser implements IOperatorCollapser { IResult combinedValue; if (scalarLeft) { - combinedValue = new IntegerResult( - valueOp.apply(scalarInt, elementInt)); + combinedValue = new IntegerResult(valueOp.apply(scalarInt, elementInt)); } else { - combinedValue = new IntegerResult( - valueOp.apply(elementInt, scalarInt)); + combinedValue = new IntegerResult(valueOp.apply(elementInt, scalarInt)); } return combinedValue; }); } - private IPair<IResult, ITree<IDiceASTNode>> reduceStates( - IPair<IResult, ITree<IDiceASTNode>> accumulatedState, + private IPair<IResult, ITree<IDiceASTNode>> reduceStates(IPair<IResult, ITree<IDiceASTNode>> accumulatedState, IPair<IResult, ITree<IDiceASTNode>> currentState) { - return accumulatedState - .bind((accumulatedValue, accumulatedTree) -> { - return currentState - .bind((currentValue, currentTree) -> { - accumulatedTree.addChild(currentTree); - - return doArithmeticCollapse( - accumulatedValue, accumulatedTree, - currentValue); - }); - }); + return accumulatedState.bind((accumulatedValue, accumulatedTree) -> { + return currentState.bind((currentValue, currentTree) -> { + accumulatedTree.addChild(currentTree); + + return doArithmeticCollapse(accumulatedValue, accumulatedTree, currentValue); + }); + }); } }
\ No newline at end of file diff --git a/dice-lang/src/bjc/dicelang/v1/ast/ArrayResult.java b/dice-lang/src/bjc/dicelang/v1/ast/ArrayResult.java index 6cb9216..c8a35a6 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/ArrayResult.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/ArrayResult.java @@ -16,7 +16,7 @@ public class ArrayResult implements IResult { * Create a new array-valued result * * @param results - * The results in the array + * The results in the array */ public ArrayResult(IList<IResult> results) { this.arrayContents = results; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTEvaluator.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTEvaluator.java index c8c0032..af31ad7 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTEvaluator.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTEvaluator.java @@ -30,27 +30,24 @@ import bjc.utils.data.Tree; * */ public class DiceASTEvaluator { - private static IResult bindLiteralValue(IDiceASTNode leafNode, - IMap<String, ITree<IDiceASTNode>> enviroment) { + private static IResult bindLiteralValue(IDiceASTNode leafNode, IMap<String, ITree<IDiceASTNode>> enviroment) { String variableName = ((VariableDiceNode) leafNode).getVariable(); if (enviroment.containsKey(variableName)) { - IResult result = evaluateAST(enviroment.get(variableName), - enviroment); + IResult result = evaluateAST(enviroment.get(variableName), enviroment); return result; } // Return a DummyResult to handle lets properly - return new DummyResult( - "Attempted to deref unbound variable " + variableName); + return new DummyResult("Attempted to deref unbound variable " + variableName); } /** * Build the map of operations to use when collapsing the AST * * @param enviroment - * The enviroment to evaluate bindings and such against + * The enviroment to evaluate bindings and such against * @return The operations to use when collapsing the AST */ private static IMap<IDiceASTNode, IOperatorCollapser> buildOperations( @@ -58,34 +55,27 @@ public class DiceASTEvaluator { IMap<IDiceASTNode, IOperatorCollapser> operatorCollapsers = new FunctionalMap<>(); operatorCollapsers.put(OperatorDiceNode.ADD, - new ArithmeticCollapser(OperatorDiceNode.ADD, - (left, right) -> left + right, 0)); + new ArithmeticCollapser(OperatorDiceNode.ADD, (left, right) -> left + right, 0)); operatorCollapsers.put(OperatorDiceNode.SUBTRACT, - new ArithmeticCollapser(OperatorDiceNode.SUBTRACT, - (left, right) -> left - right, 0)); + new ArithmeticCollapser(OperatorDiceNode.SUBTRACT, (left, right) -> left - right, 0)); operatorCollapsers.put(OperatorDiceNode.MULTIPLY, - new ArithmeticCollapser(OperatorDiceNode.MULTIPLY, - (left, right) -> left * right, 1)); + new ArithmeticCollapser(OperatorDiceNode.MULTIPLY, (left, right) -> left * right, 1)); operatorCollapsers.put(OperatorDiceNode.DIVIDE, - new ArithmeticCollapser(OperatorDiceNode.DIVIDE, - (left, right) -> left / right, 1)); + new ArithmeticCollapser(OperatorDiceNode.DIVIDE, (left, right) -> left / right, 1)); operatorCollapsers.put(OperatorDiceNode.ASSIGN, (nodes) -> { return parseBinding(enviroment, nodes); }); operatorCollapsers.put(OperatorDiceNode.COMPOUND, - new ArithmeticCollapser(OperatorDiceNode.COMPOUND, - (left, right) -> { - return Integer.parseInt(Integer.toString(left) - + Integer.toString(right)); - }, 0)); + new ArithmeticCollapser(OperatorDiceNode.COMPOUND, (left, right) -> { + return Integer.parseInt(Integer.toString(left) + Integer.toString(right)); + }, 0)); - operatorCollapsers.put(OperatorDiceNode.GROUP, - DiceASTEvaluator::parseGroup); + operatorCollapsers.put(OperatorDiceNode.GROUP, DiceASTEvaluator::parseGroup); operatorCollapsers.put(OperatorDiceNode.LET, (nodes) -> { // @TODO Fix lets prematurely evaluating things @@ -106,8 +96,7 @@ public class DiceASTEvaluator { }; Supplier<ITree<IDiceASTNode>> treeSupplier = () -> { - ITree<IDiceASTNode> returnedTree = new Tree<>( - OperatorDiceNode.ARRAY); + ITree<IDiceASTNode> returnedTree = new Tree<>(OperatorDiceNode.ARRAY); nodes.forEach((element) -> { returnedTree.addChild(element.getRight()); @@ -122,11 +111,9 @@ public class DiceASTEvaluator { return operatorCollapsers; } - private static void doArrayAssign( - IMap<String, ITree<IDiceASTNode>> enviroment, - IPair<IResult, ITree<IDiceASTNode>> nameNode, - ITree<IDiceASTNode> nameTree, ITree<IDiceASTNode> valueTree, - IHolder<Integer> childCount, ITree<IDiceASTNode> child) { + private static void doArrayAssign(IMap<String, ITree<IDiceASTNode>> enviroment, + IPair<IResult, ITree<IDiceASTNode>> nameNode, ITree<IDiceASTNode> nameTree, + ITree<IDiceASTNode> valueTree, IHolder<Integer> childCount, ITree<IDiceASTNode> child) { if (nameTree.getHead().getType() != DiceASTType.VARIABLE) { throw new UnsupportedOperationException( "Assigning to complex variables isn't supported. Problem node is " @@ -146,75 +133,65 @@ public class DiceASTEvaluator { * Evaluate the provided AST to a numeric value * * @param expression - * The expression to evaluate + * The expression to evaluate * @param enviroment - * The enviroment to look up variables in + * The enviroment to look up variables in * @return The integer value of the expression */ public static IResult evaluateAST(ITree<IDiceASTNode> expression, IMap<String, ITree<IDiceASTNode>> enviroment) { - IMap<IDiceASTNode, IOperatorCollapser> collapsers = buildOperations( - enviroment); + IMap<IDiceASTNode, IOperatorCollapser> collapsers = buildOperations(enviroment); - return expression.collapse( - (node) -> evaluateLeaf(node, enviroment), collapsers::get, + return expression.collapse((node) -> evaluateLeaf(node, enviroment), collapsers::get, (pair) -> pair.getLeft()); } - private static IPair<IResult, ITree<IDiceASTNode>> evaluateLeaf( - IDiceASTNode leafNode, + private static IPair<IResult, ITree<IDiceASTNode>> evaluateLeaf(IDiceASTNode leafNode, IMap<String, ITree<IDiceASTNode>> enviroment) { ITree<IDiceASTNode> returnedAST = new Tree<>(leafNode); switch (leafNode.getType()) { - case LITERAL: - return new Pair<>(evaluateLiteral(leafNode), returnedAST); + case LITERAL: + return new Pair<>(evaluateLiteral(leafNode), returnedAST); - case VARIABLE: - return new LazyPair<>(() -> { - return bindLiteralValue(leafNode, enviroment); - }, () -> returnedAST); + case VARIABLE: + return new LazyPair<>(() -> { + return bindLiteralValue(leafNode, enviroment); + }, () -> returnedAST); - case OPERATOR: - default: - throw new UnsupportedOperationException( - "Node '" + leafNode + "' cannot be a leaf."); + case OPERATOR: + default: + throw new UnsupportedOperationException("Node '" + leafNode + "' cannot be a leaf."); } } private static IResult evaluateLiteral(IDiceASTNode leafNode) { - DiceLiteralType literalType = ((ILiteralDiceNode) leafNode) - .getLiteralType(); + DiceLiteralType literalType = ((ILiteralDiceNode) leafNode).getLiteralType(); switch (literalType) { - case DICE: - int diceRoll = ((DiceLiteralNode) leafNode).getValue() - .roll(); - - return new IntegerResult(diceRoll); - case INTEGER: - int val = ((IntegerLiteralNode) leafNode).getValue(); - - return new IntegerResult(val); - default: - throw new UnsupportedOperationException("Literal value '" - + leafNode + "' is of a type (" + literalType - + ") not currently supported."); + case DICE: + int diceRoll = ((DiceLiteralNode) leafNode).getValue().roll(); + + return new IntegerResult(diceRoll); + case INTEGER: + int val = ((IntegerLiteralNode) leafNode).getValue(); + + return new IntegerResult(val); + default: + throw new UnsupportedOperationException("Literal value '" + leafNode + "' is of a type (" + + literalType + ") not currently supported."); } } - private static IPair<IResult, ITree<IDiceASTNode>> parseBinding( - IMap<String, ITree<IDiceASTNode>> enviroment, + private static IPair<IResult, ITree<IDiceASTNode>> parseBinding(IMap<String, ITree<IDiceASTNode>> enviroment, IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) { if (nodes.getSize() != 2) { throw new UnsupportedOperationException( - "Can only bind nodes with two children. Problem children are " - + nodes); + "Can only bind nodes with two children. Problem children are " + nodes); } IPair<IResult, ITree<IDiceASTNode>> nameNode = nodes.getByIndex(0); - IPair<IResult, ITree<IDiceASTNode>> valueNode = nodes - .getByIndex(1); + IPair<IResult, ITree<IDiceASTNode>> valueNode = nodes.getByIndex(1); return nameNode.bindRight((nameTree) -> { return valueNode.bind((valueValue, valueTree) -> { @@ -228,8 +205,7 @@ public class DiceASTEvaluator { return new Pair<>(valueValue, nameTree); } else if (nameTree.getHead() == OperatorDiceNode.ARRAY) { if (valueTree.getHead() == OperatorDiceNode.ARRAY) { - if (nameTree.getChildrenCount() != valueTree - .getChildrenCount()) { + if (nameTree.getChildrenCount() != valueTree.getChildrenCount()) { throw new UnsupportedOperationException( "Array assignment must be between two equal length arrays"); } @@ -237,8 +213,8 @@ public class DiceASTEvaluator { IHolder<Integer> childCount = new Identity<>(0); nameTree.doForChildren((child) -> { - doArrayAssign(enviroment, nameNode, nameTree, - valueTree, childCount, child); + doArrayAssign(enviroment, nameNode, nameTree, valueTree, + childCount, child); childCount.transform(val -> val + 1); }); @@ -248,8 +224,7 @@ public class DiceASTEvaluator { nameTree.doForChildren((child) -> { String varName = child.transformHead((nameNod) -> { - return ((VariableDiceNode) nameNod) - .getVariable(); + return ((VariableDiceNode) nameNod).getVariable(); }); enviroment.put(varName, valueTree); @@ -268,42 +243,33 @@ public class DiceASTEvaluator { private static IPair<IResult, ITree<IDiceASTNode>> parseGroup( IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) { if (nodes.getSize() != 2) { - throw new UnsupportedOperationException( - "Can only form a group from two dice"); + throw new UnsupportedOperationException("Can only form a group from two dice"); } - IPair<IResult, ITree<IDiceASTNode>> numberDiceNode = nodes - .getByIndex(0); - IPair<IResult, ITree<IDiceASTNode>> diceTypeNode = nodes - .getByIndex(1); + IPair<IResult, ITree<IDiceASTNode>> numberDiceNode = nodes.getByIndex(0); + IPair<IResult, ITree<IDiceASTNode>> diceTypeNode = nodes.getByIndex(1); return numberDiceNode.bind((numberDiceValue, numberDiceTree) -> { return diceTypeNode.bind((diceTypeValue, diceTypeTree) -> { - ComplexDice cDice = new ComplexDice( - ((IntegerResult) numberDiceValue).getValue(), + ComplexDice cDice = new ComplexDice(((IntegerResult) numberDiceValue).getValue(), ((IntegerResult) diceTypeValue).getValue()); return new Pair<>(new IntegerResult(cDice.roll()), - new Tree<>(OperatorDiceNode.GROUP, numberDiceTree, - diceTypeTree)); + new Tree<>(OperatorDiceNode.GROUP, numberDiceTree, diceTypeTree)); }); }); } - private static IPair<IResult, ITree<IDiceASTNode>> parseLet( - IMap<String, ITree<IDiceASTNode>> enviroment, + private static IPair<IResult, ITree<IDiceASTNode>> parseLet(IMap<String, ITree<IDiceASTNode>> enviroment, IList<IPair<IResult, ITree<IDiceASTNode>>> nodes) { if (nodes.getSize() != 2) { - throw new UnsupportedOperationException( - "Can only use let with two expressions."); + throw new UnsupportedOperationException("Can only use let with two expressions."); } ITree<IDiceASTNode> bindTree = nodes.getByIndex(0).getRight(); - ITree<IDiceASTNode> expressionTree = nodes.getByIndex(1) - .getRight(); + ITree<IDiceASTNode> expressionTree = nodes.getByIndex(1).getRight(); - IMap<String, ITree<IDiceASTNode>> letEnviroment = enviroment - .extend(); + IMap<String, ITree<IDiceASTNode>> letEnviroment = enviroment.extend(); System.out.println("Evaluating tree for bound values"); @@ -311,10 +277,8 @@ public class DiceASTEvaluator { IResult exprResult = evaluateAST(expressionTree, letEnviroment); - IList<ITree<IDiceASTNode>> childrn = nodes - .map((pair) -> pair.getRight()); + IList<ITree<IDiceASTNode>> childrn = nodes.map((pair) -> pair.getRight()); - return new Pair<>(exprResult, - new Tree<>(OperatorDiceNode.LET, childrn)); + return new Pair<>(exprResult, new Tree<>(OperatorDiceNode.LET, childrn)); } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTInliner.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTInliner.java index 51aba03..38e1361 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTInliner.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTInliner.java @@ -20,9 +20,9 @@ public class DiceASTInliner { * Inline all the variables in the AST * * @param ast - * The AST to inline variables into + * The AST to inline variables into * @param enviroment - * The enviroment to inline from + * The enviroment to inline from * @return The inlined AST */ public static ITree<IDiceASTNode> inlineAll(ITree<IDiceASTNode> ast, @@ -32,8 +32,7 @@ public class DiceASTInliner { return selectiveInline(ast, enviroment, (String[]) null); } - private static ITree<IDiceASTNode> inlineNode(IDiceASTNode node, - IMap<String, ITree<IDiceASTNode>> enviroment, + private static ITree<IDiceASTNode> inlineNode(IDiceASTNode node, IMap<String, ITree<IDiceASTNode>> enviroment, boolean specificInline, IList<String> variableNames) { // Only variables get inlined if (node.getType() != DiceASTType.VARIABLE) { @@ -50,8 +49,7 @@ public class DiceASTInliner { // You can't inline non-existent variables if (!enviroment.containsKey(variableName)) { throw new UnsupportedOperationException( - "Attempted to inline non-existant variable " - + variableName); + "Attempted to inline non-existant variable " + variableName); } // Return the tree for the variable @@ -61,12 +59,11 @@ public class DiceASTInliner { // We're not inlining this particular variable return new Tree<>(node); } - + // You can't inline non-existent variables if (!enviroment.containsKey(variableName)) { throw new UnsupportedOperationException( - "Attempted to inline non-existant variable " - + variableName); + "Attempted to inline non-existant variable " + variableName); } // Return the tree for the variable @@ -77,37 +74,32 @@ public class DiceASTInliner { * Inline the specified variables in the AST * * @param ast - * The AST to inline variables into + * The AST to inline variables into * @param enviroment - * The enviroment to inline from + * The enviroment to inline from * @param variables - * The variables to inline + * The variables to inline * @return The inlined AST */ - public static ITree<IDiceASTNode> selectiveInline( - ITree<IDiceASTNode> ast, - IMap<String, ITree<IDiceASTNode>> enviroment, - IList<String> variables) { + public static ITree<IDiceASTNode> selectiveInline(ITree<IDiceASTNode> ast, + IMap<String, ITree<IDiceASTNode>> enviroment, IList<String> variables) { // Inline the specified variables - return selectiveInline(ast, enviroment, - variables.toArray(new String[0])); + return selectiveInline(ast, enviroment, variables.toArray(new String[0])); } /** * Inline the specified variables in the AST * * @param ast - * The AST to inline variables into + * The AST to inline variables into * @param enviroment - * The enviroment to inline from + * The enviroment to inline from * @param variables - * The variables to inline + * The variables to inline * @return The inlined AST */ - public static ITree<IDiceASTNode> selectiveInline( - ITree<IDiceASTNode> ast, - IMap<String, ITree<IDiceASTNode>> enviroment, - String... variables) { + public static ITree<IDiceASTNode> selectiveInline(ITree<IDiceASTNode> ast, + IMap<String, ITree<IDiceASTNode>> enviroment, String... variables) { // If we're selectively inlining, do so if (variables != null && variables.length > 0) { IList<String> variableNames = new FunctionalList<>(variables); diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTOptimizer.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTOptimizer.java index 178b175..a93de33 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTOptimizer.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTOptimizer.java @@ -27,7 +27,7 @@ public class DiceASTOptimizer { * Add a pass to the list of optimization passes * * @param pass - * The pass to add + * The pass to add */ public void addPass(IOptimizationPass pass) { passes.add(pass); @@ -37,23 +37,19 @@ public class DiceASTOptimizer { * Optimize the passed in tree * * @param ast - * The tree to optimize + * The tree to optimize * @param enviroment - * The enviroment for variable references + * The enviroment for variable references * @return The optimized tree */ - public ITree<IDiceASTNode> optimizeTree(ITree<IDiceASTNode> ast, - IMap<String, ITree<IDiceASTNode>> enviroment) { - ITree<IDiceASTNode> optimizedTree = passes.reduceAux(ast, - (currentPass, currentTree) -> { - return currentTree.collapse(currentPass::optimizeLeaf, - (operator) -> { - return (nodes) -> { - return currentPass.optimizeOperator( - operator, nodes); - }; - }, (tree) -> tree); - }, (tree) -> tree); + public ITree<IDiceASTNode> optimizeTree(ITree<IDiceASTNode> ast, IMap<String, ITree<IDiceASTNode>> enviroment) { + ITree<IDiceASTNode> optimizedTree = passes.reduceAux(ast, (currentPass, currentTree) -> { + return currentTree.collapse(currentPass::optimizeLeaf, (operator) -> { + return (nodes) -> { + return currentPass.optimizeOperator(operator, nodes); + }; + }, (tree) -> tree); + }, (tree) -> tree); return optimizedTree; } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTParser.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTParser.java index d536cc3..87f3640 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTParser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTParser.java @@ -29,135 +29,124 @@ import bjc.utils.parserutils.TreeConstructor; * */ public class DiceASTParser { - private static IDiceASTNode convertLeafNode(String leafNode) { - DiceLiteralType literalType = ILiteralDiceNode - .getLiteralType(leafNode); - - if (literalType != null) { - switch (literalType) { - case DICE: - return new DiceLiteralNode( - IDiceExpression.toExpression(leafNode)); - case INTEGER: - return new IntegerLiteralNode( - Integer.parseInt(leafNode)); - default: - throw new InputMismatchException( - "Cannot convert string '" + leafNode - + "' into a literal."); - } - } - - if (leafNode.matches("[+-]?\\d*\\.\\d+")) { - throw new InputMismatchException( - "Floating point literals are not supported"); - } - - return new VariableDiceNode(leafNode); + private static IDiceASTNode convertLeafNode(String leafNode) { + DiceLiteralType literalType = ILiteralDiceNode.getLiteralType(leafNode); + + if (literalType != null) { + switch (literalType) { + case DICE: + return new DiceLiteralNode(IDiceExpression.toExpression(leafNode)); + case INTEGER: + return new IntegerLiteralNode(Integer.parseInt(leafNode)); + default: + throw new InputMismatchException( + "Cannot convert string '" + leafNode + "' into a literal."); + } } - private static IDiceASTNode convertOperatorNode(String operatorNode) { - try { - return OperatorDiceNode.fromString(operatorNode); - } catch (IllegalArgumentException iaex) { - InputMismatchException imex = new InputMismatchException( - "Attempted to parse invalid operator " + operatorNode); + if (leafNode.matches("[+-]?\\d*\\.\\d+")) { + throw new InputMismatchException("Floating point literals are not supported"); + } + + return new VariableDiceNode(leafNode); + } - imex.initCause(iaex); + private static IDiceASTNode convertOperatorNode(String operatorNode) { + try { + return OperatorDiceNode.fromString(operatorNode); + } catch (IllegalArgumentException iaex) { + InputMismatchException imex = new InputMismatchException( + "Attempted to parse invalid operator " + operatorNode); - throw imex; - } + imex.initCause(iaex); + + throw imex; + } + } + + /** + * Create an AST from a list of tokens + * + * @param tokens + * The list of tokens to convert + * @return An AST built from the tokens + */ + public static ITree<IDiceASTNode> createFromString(IList<String> tokens) { + // Mark arrays as special operators + Predicate<String> specialPicker = (operator) -> { + if (StringUtils.containsOnly(operator, "\\[") || StringUtils.containsOnly(operator, "\\]")) { + return true; + } + + return false; + }; + + // Here is the map for holding special operators + IMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators = new FunctionalMap<>(); + + // Handle open [ + operators.put("[", (queuedTrees) -> { + // Just put in a [ + Tree<String> openArray = new Tree<>("["); + + return openArray; + }); + + operators.put("]", (queuedTrees) -> { + // Parse closing an array + return parseCloseArray(queuedTrees); + }); + + ITree<String> rawTokens = TreeConstructor.constructTree(tokens, (token) -> { + return isOperatorNode(token); + }, specialPicker, operators::get); + + ITree<IDiceASTNode> tokenizedTree = rawTokens.rebuildTree(DiceASTParser::convertLeafNode, + DiceASTParser::convertOperatorNode); + + return tokenizedTree; + } + + private static boolean isOperatorNode(String token) { + if (StringUtils.containsOnly(token, "\\[")) { + return true; + } else if (StringUtils.containsOnly(token, "\\]")) { + return true; } - /** - * Create an AST from a list of tokens - * - * @param tokens - * The list of tokens to convert - * @return An AST built from the tokens - */ - public static ITree<IDiceASTNode> createFromString( - IList<String> tokens) { - // Mark arrays as special operators - Predicate<String> specialPicker = (operator) -> { - if (StringUtils.containsOnly(operator, "\\[") || - StringUtils.containsOnly(operator, "\\]")) { - return true; - } - - return false; - }; - - // Here is the map for holding special operators - IMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators = new FunctionalMap<>(); - - // Handle open [ - operators.put("[", (queuedTrees) -> { - // Just put in a [ - Tree<String> openArray = new Tree<>("["); - - return openArray; - }); - - operators.put("]", (queuedTrees) -> { - // Parse closing an array - return parseCloseArray(queuedTrees); - }); - - ITree<String> rawTokens = TreeConstructor.constructTree(tokens, - (token) -> { - return isOperatorNode(token); - }, specialPicker, operators::get); - - ITree<IDiceASTNode> tokenizedTree = rawTokens.rebuildTree( - DiceASTParser::convertLeafNode, - DiceASTParser::convertOperatorNode); - - return tokenizedTree; - } - - private static boolean isOperatorNode(String token) { - if (StringUtils.containsOnly(token, "\\[")) { - return true; - } else if (StringUtils.containsOnly(token, "\\]")) { - return true; - } - - if (token.equals("[]")) { - // This is a synthetic operator, constructed by [ and ] - return true; - } - - try { - OperatorDiceNode.fromString(token); - return true; - } catch (IllegalArgumentException iaex) { - // We don't care about details - return false; - } + if (token.equals("[]")) { + // This is a synthetic operator, constructed by [ and ] + return true; } - private static ITree<String> parseCloseArray( - Deque<ITree<String>> queuedTrees) { - IList<ITree<String>> children = new FunctionalList<>(); + try { + OperatorDiceNode.fromString(token); + return true; + } catch (IllegalArgumentException iaex) { + // We don't care about details + return false; + } + } + + private static ITree<String> parseCloseArray(Deque<ITree<String>> queuedTrees) { + IList<ITree<String>> children = new FunctionalList<>(); - while (shouldContinuePopping(queuedTrees)) { - children.add(queuedTrees.pop()); - } + while (shouldContinuePopping(queuedTrees)) { + children.add(queuedTrees.pop()); + } - queuedTrees.pop(); + queuedTrees.pop(); - children.reverse(); + children.reverse(); - ITree<String> arrayTree = new Tree<>("[]", children); + ITree<String> arrayTree = new Tree<>("[]", children); - return arrayTree; - } + return arrayTree; + } - private static boolean shouldContinuePopping( - Deque<ITree<String>> queuedTrees) { - String peekToken = queuedTrees.peek().getHead(); + private static boolean shouldContinuePopping(Deque<ITree<String>> queuedTrees) { + String peekToken = queuedTrees.peek().getHead(); - return !peekToken.equals("["); - } + return !peekToken.equals("["); + } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceChecker.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceChecker.java index 5492cf7..5be2090 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceChecker.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceChecker.java @@ -13,25 +13,24 @@ import bjc.utils.data.IHolder; * @author ben * */ -public final class DiceASTReferenceChecker - implements Consumer<IDiceASTNode> { +public final class DiceASTReferenceChecker implements Consumer<IDiceASTNode> { /** * This is true if the specified node references the set variable */ - private IHolder<Boolean> referencesVariable; + private IHolder<Boolean> referencesVariable; - private String varName; + private String varName; /** * Create a new reference checker * * @param referencesVar - * The holder of whether the variable is referenced or not + * The holder of whether the variable is referenced or + * not * @param varName - * The variable to check for references in + * The variable to check for references in */ - public DiceASTReferenceChecker(IHolder<Boolean> referencesVar, - String varName) { + public DiceASTReferenceChecker(IHolder<Boolean> referencesVar, String varName) { this.referencesVariable = referencesVar; this.varName = varName; } @@ -45,7 +44,7 @@ public final class DiceASTReferenceChecker * Check if a given AST node directly references the specified variable * * @param astNode - * The node to check + * The node to check * @return Whether or not the node directly the variable */ private boolean isDirectReference(IDiceASTNode astNode) { diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceSanitizer.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceSanitizer.java index 79c0ce7..5bb07fd 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceSanitizer.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTReferenceSanitizer.java @@ -12,9 +12,8 @@ import bjc.utils.data.TopDownTransformResult; import bjc.utils.data.Tree; /** - * 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 - * previous definition + * 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 previous definition * * @author ben * @@ -23,8 +22,7 @@ public class DiceASTReferenceSanitizer { private static ITree<IDiceASTNode> doSanitize(ITree<IDiceASTNode> ast, IMap<String, ITree<IDiceASTNode>> enviroment) { if (ast.getChildrenCount() != 2) { - throw new UnsupportedOperationException( - "Assignment must have two arguments."); + throw new UnsupportedOperationException("Assignment must have two arguments."); } ITree<IDiceASTNode> nameTree = ast.getChild(0); @@ -36,8 +34,7 @@ public class DiceASTReferenceSanitizer { nameTree.doForChildren((child) -> { if (allSimpleVariables.getValue()) { - boolean isSimple = DiceASTUtils - .containsSimpleVariable(child); + boolean isSimple = DiceASTUtils.containsSimpleVariable(child); allSimpleVariables.replace(isSimple); } @@ -50,8 +47,7 @@ public class DiceASTReferenceSanitizer { } if (valueTree.getHead() == OperatorDiceNode.ARRAY) { - if (nameTree.getChildrenCount() != valueTree - .getChildrenCount()) { + if (nameTree.getChildrenCount() != valueTree.getChildrenCount()) { throw new UnsupportedOperationException( "Array assignment between arrays must be" + " between two arrays of equal length"); @@ -67,24 +63,21 @@ public class DiceASTReferenceSanitizer { if (valueTree.getHead() == OperatorDiceNode.ARRAY) { IHolder<Integer> childCounter = new Identity<>(0); - ITree<IDiceASTNode> returnTree = new Tree<>( - OperatorDiceNode.ARRAY); + ITree<IDiceASTNode> returnTree = new Tree<>(OperatorDiceNode.ARRAY); nameTree.doForChildren((child) -> { String variableName = child.transformHead((node) -> { return ((VariableDiceNode) node).getVariable(); }); - ITree<IDiceASTNode> currentValue = valueTree - .getChild(childCounter.getValue()); + ITree<IDiceASTNode> currentValue = valueTree.getChild(childCounter.getValue()); - ITree<IDiceASTNode> sanitizedSubtree = doSingleSanitize( - ast, enviroment, child, currentValue, - variableName); + ITree<IDiceASTNode> sanitizedSubtree = doSingleSanitize(ast, enviroment, child, + currentValue, variableName); if (sanitizedSubtree == null) { - ITree<IDiceASTNode> oldTree = new Tree<>( - ast.getHead(), child, currentValue); + ITree<IDiceASTNode> oldTree = new Tree<>(ast.getHead(), child, + currentValue); returnTree.addChild(oldTree); } else { @@ -97,18 +90,16 @@ public class DiceASTReferenceSanitizer { return returnTree; } - ITree<IDiceASTNode> returnTree = new Tree<>( - OperatorDiceNode.ARRAY); + ITree<IDiceASTNode> returnTree = new Tree<>(OperatorDiceNode.ARRAY); nameTree.doForChildren((child) -> { - String variableName = child.transformHead( - (node) -> ((VariableDiceNode) node).getVariable()); + String variableName = child + .transformHead((node) -> ((VariableDiceNode) node).getVariable()); - ITree<IDiceASTNode> sanitizedChild = doSingleSanitize(ast, - enviroment, child, valueTree, variableName); + ITree<IDiceASTNode> sanitizedChild = doSingleSanitize(ast, enviroment, child, valueTree, + variableName); if (sanitizedChild == null) { - ITree<IDiceASTNode> oldTree = new Tree<>(ast.getHead(), - child, valueTree); + ITree<IDiceASTNode> oldTree = new Tree<>(ast.getHead(), child, valueTree); returnTree.addChild(oldTree); } else { @@ -119,11 +110,10 @@ public class DiceASTReferenceSanitizer { return returnTree; } - String variableName = nameTree.transformHead( - (node) -> ((VariableDiceNode) node).getVariable()); + String variableName = nameTree.transformHead((node) -> ((VariableDiceNode) node).getVariable()); - ITree<IDiceASTNode> sanitizedTree = doSingleSanitize(ast, - enviroment, nameTree, valueTree, variableName); + ITree<IDiceASTNode> sanitizedTree = doSingleSanitize(ast, enviroment, nameTree, valueTree, + variableName); if (sanitizedTree == null) { return ast; @@ -132,22 +122,19 @@ public class DiceASTReferenceSanitizer { return sanitizedTree; } - private static ITree<IDiceASTNode> doSingleSanitize( - ITree<IDiceASTNode> ast, - IMap<String, ITree<IDiceASTNode>> enviroment, - ITree<IDiceASTNode> nameTree, ITree<IDiceASTNode> valueTree, - String variableName) { + private static ITree<IDiceASTNode> doSingleSanitize(ITree<IDiceASTNode> ast, + IMap<String, ITree<IDiceASTNode>> enviroment, ITree<IDiceASTNode> nameTree, + ITree<IDiceASTNode> valueTree, String variableName) { if (enviroment.containsKey(variableName)) { // @ is a meta-variable standing for the left side of an // assignment - ITree<IDiceASTNode> oldVal = enviroment.put("@", - enviroment.get(variableName)); + ITree<IDiceASTNode> oldVal = enviroment.put("@", enviroment.get(variableName)); - // We should always inline out references to last, because it + // We should always inline out references to last, + // because it // will always change - ITree<IDiceASTNode> inlinedValue = DiceASTInliner - .selectiveInline(valueTree, enviroment, variableName, - "last", "@"); + ITree<IDiceASTNode> inlinedValue = DiceASTInliner.selectiveInline(valueTree, enviroment, + variableName, "last", "@"); if (oldVal != null) { enviroment.put("@", oldVal); @@ -170,32 +157,30 @@ public class DiceASTReferenceSanitizer { */ public static ITree<IDiceASTNode> sanitize(ITree<IDiceASTNode> ast, IMap<String, ITree<IDiceASTNode>> enviroment) { - return ast.topDownTransform( - DiceASTReferenceSanitizer::shouldSanitize, (subTree) -> { - return doSanitize(subTree, enviroment); - }); + return ast.topDownTransform(DiceASTReferenceSanitizer::shouldSanitize, (subTree) -> { + return doSanitize(subTree, enviroment); + }); } - private static TopDownTransformResult shouldSanitize( - IDiceASTNode node) { + private static TopDownTransformResult shouldSanitize(IDiceASTNode node) { if (!node.isOperator()) { return TopDownTransformResult.SKIP; } switch (((OperatorDiceNode) node)) { - case ASSIGN: - return TopDownTransformResult.TRANSFORM; - case ARRAY: - case LET: - return TopDownTransformResult.PASSTHROUGH; - case ADD: - case COMPOUND: - case DIVIDE: - case GROUP: - case MULTIPLY: - case SUBTRACT: - default: - return TopDownTransformResult.SKIP; + case ASSIGN: + return TopDownTransformResult.TRANSFORM; + case ARRAY: + case LET: + return TopDownTransformResult.PASSTHROUGH; + case ADD: + case COMPOUND: + case DIVIDE: + case GROUP: + case MULTIPLY: + case SUBTRACT: + default: + return TopDownTransformResult.SKIP; } } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTUtils.java b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTUtils.java index 92658b6..4d710fe 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DiceASTUtils.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DiceASTUtils.java @@ -20,12 +20,11 @@ public class DiceASTUtils { * Check if a dice AST contains a simple variable reference * * @param nameTree - * The tree to check for a reference in + * The tree to check for a reference in * @return Whether or not a dice AST contains a simple variable * reference */ - public static boolean containsSimpleVariable( - ITree<IDiceASTNode> nameTree) { + public static boolean containsSimpleVariable(ITree<IDiceASTNode> nameTree) { return nameTree.transformHead((nameNode) -> { if (nameNode.getType() != DiceASTType.VARIABLE) { return false; @@ -39,28 +38,26 @@ public class DiceASTUtils { * Convert an literal AST node to a dice expression, if possible. * * @param tree - * The node to convert in tree form + * The node to convert in tree form * @return The tree as a dice expression * * @throws ClassCastException - * if the head of the tree is not a literal (implements - * {@link ILiteralDiceNode}) + * if the head of the tree is not a literal (implements + * {@link ILiteralDiceNode}) * @throws UnsupportedOperationException - * if the head of the tree is not optimizable + * if the head of the tree is not optimizable */ - public static IDiceExpression literalToExpression( - ITree<IDiceASTNode> tree) { + public static IDiceExpression literalToExpression(ITree<IDiceASTNode> tree) { ILiteralDiceNode literalNode = (ILiteralDiceNode) tree.getHead(); switch (literalNode.getLiteralType()) { - case DICE: - return ((DiceLiteralNode) literalNode).getValue(); - case INTEGER: - return new ScalarDie( - ((IntegerLiteralNode) literalNode).getValue()); - default: - throw new UnsupportedOperationException( - "This type of literal isn't convertable to an expression"); + case DICE: + return ((DiceLiteralNode) literalNode).getValue(); + case INTEGER: + return new ScalarDie(((IntegerLiteralNode) literalNode).getValue()); + default: + throw new UnsupportedOperationException( + "This type of literal isn't convertable to an expression"); } } @@ -68,14 +65,14 @@ public class DiceASTUtils { * Convert an literal AST node to an integer, if possible. * * @param tree - * The literal node to convert, as a tree + * The literal node to convert, as a tree * @return The node as an integer * * @throws ClassCastException - * if the head of the tree is not a literal (implements - * {@link ILiteralDiceNode}) + * if the head of the tree is not a literal (implements + * {@link ILiteralDiceNode}) * @throws UnsupportedOperationException - * if the head of the tree is not optimizable + * if the head of the tree is not optimizable */ public static int literalToInteger(ITree<IDiceASTNode> tree) { return tree.transformHead((node) -> { diff --git a/dice-lang/src/bjc/dicelang/v1/ast/DummyResult.java b/dice-lang/src/bjc/dicelang/v1/ast/DummyResult.java index 1dd7057..6858022 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/DummyResult.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/DummyResult.java @@ -16,7 +16,7 @@ public class DummyResult implements IResult { * Create a new dummy result with a reason * * @param data - * The reason why the result is a dummy + * The reason why the result is a dummy */ public DummyResult(String data) { dummyData = data; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/IOperatorCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/IOperatorCollapser.java index df5f95b..bd120a8 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/IOperatorCollapser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/IOperatorCollapser.java @@ -13,7 +13,7 @@ import bjc.utils.funcdata.IList; * @author ben * */ -public interface IOperatorCollapser extends - Function<IList<IPair<IResult, ITree<IDiceASTNode>>>, IPair<IResult, ITree<IDiceASTNode>>> { +public interface IOperatorCollapser + extends Function<IList<IPair<IResult, ITree<IDiceASTNode>>>, IPair<IResult, ITree<IDiceASTNode>>> { // Just an alias } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/IntegerResult.java b/dice-lang/src/bjc/dicelang/v1/ast/IntegerResult.java index 2934dfa..b365282 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/IntegerResult.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/IntegerResult.java @@ -13,7 +13,7 @@ public class IntegerResult implements IResult { * Create a new integer valued result * * @param val - * The value of the result + * The value of the result */ public IntegerResult(int val) { value = val; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceLiteralNode.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceLiteralNode.java index 4e9b560..bb979d1 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceLiteralNode.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceLiteralNode.java @@ -15,7 +15,7 @@ public class DiceLiteralNode implements ILiteralDiceNode { * Create a new literal from an expression * * @param exp - * The expression to attempt to create a literal from + * The expression to attempt to create a literal from */ public DiceLiteralNode(IDiceExpression exp) { expression = exp; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceOperatorType.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceOperatorType.java index 35e5680..a5a79a6 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceOperatorType.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/DiceOperatorType.java @@ -3,8 +3,8 @@ package bjc.dicelang.v1.ast.nodes; /** * Represents the different type of operators. * - * Mostly, what distinguishes groups is that all the operators in a group - * have similiar precedence, and operate on similiar things + * Mostly, what distinguishes groups is that all the operators in a group have + * similiar precedence, and operate on similiar things * * @author ben * diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/ILiteralDiceNode.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/ILiteralDiceNode.java index 11d0d90..ece528b 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/ILiteralDiceNode.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/ILiteralDiceNode.java @@ -11,17 +11,15 @@ public interface ILiteralDiceNode extends IDiceASTNode { * Check if a token represents a literal, and if so, what type * * @param tok - * The token to check - * @return The type the literal would be if it is one, or null - * otherwise + * The token to check + * @return The type the literal would be if it is one, or null otherwise */ static DiceLiteralType getLiteralType(String tok) { String diceGroup = "\\d*d\\d+\\"; String diceGroupOrNumber = "[(?:" + diceGroup + ")(?:\\d+)]"; - if (tok.matches("\\A" + diceGroupOrNumber + "?" + "c" - + diceGroupOrNumber + "\\Z")) { + if (tok.matches("\\A" + diceGroupOrNumber + "?" + "c" + diceGroupOrNumber + "\\Z")) { return DiceLiteralType.DICE; } @@ -34,7 +32,8 @@ public interface ILiteralDiceNode extends IDiceASTNode { return DiceLiteralType.INTEGER; } catch (NumberFormatException nfex) { // We don't care about details - // This probably shouldn't return null, but I believe it does so + // This probably shouldn't return null, but I believe it + // does so // because where its called checks that. @FIXME return null; } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/IntegerLiteralNode.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/IntegerLiteralNode.java index 4a756d6..1c8aa56 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/IntegerLiteralNode.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/IntegerLiteralNode.java @@ -13,7 +13,7 @@ public class IntegerLiteralNode implements ILiteralDiceNode { * Create a new integer literal from the given number * * @param val - * The value this node represents + * The value this node represents */ public IntegerLiteralNode(int val) { value = val; diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/OperatorDiceNode.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/OperatorDiceNode.java index b52ba49..0af9d81 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/OperatorDiceNode.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/OperatorDiceNode.java @@ -52,34 +52,33 @@ public enum OperatorDiceNode implements IDiceASTNode { * Create a operator node from a string * * @param s - * The string to convert to a node + * The string to convert to a node * @return The operator corresponding to the node */ public static OperatorDiceNode fromString(String s) { switch (s) { - case ":=": - return ASSIGN; - case "+": - return ADD; - case "-": - return SUBTRACT; - case "*": - return MULTIPLY; - case "/": - return DIVIDE; - case "d": - case "group": - return GROUP; - case "c": - case "compound": - return COMPOUND; - case "=>": - return LET; - case "[]": - return ARRAY; - default: - throw new IllegalArgumentException( - s + " is not a valid operator node"); + case ":=": + return ASSIGN; + case "+": + return ADD; + case "-": + return SUBTRACT; + case "*": + return MULTIPLY; + case "/": + return DIVIDE; + case "d": + case "group": + return GROUP; + case "c": + case "compound": + return COMPOUND; + case "=>": + return LET; + case "[]": + return ARRAY; + default: + throw new IllegalArgumentException(s + " is not a valid operator node"); } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/nodes/VariableDiceNode.java b/dice-lang/src/bjc/dicelang/v1/ast/nodes/VariableDiceNode.java index d32b6b0..22ddf17 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/nodes/VariableDiceNode.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/nodes/VariableDiceNode.java @@ -16,7 +16,7 @@ public class VariableDiceNode implements IDiceASTNode { * Create a new node representing the specified variable * * @param varName - * The name of the variable being referenced + * The name of the variable being referenced */ public VariableDiceNode(String varName) { this.variableName = varName; @@ -74,8 +74,7 @@ public class VariableDiceNode implements IDiceASTNode { public int hashCode() { final int prime = 31; int result = 1; - result = prime * result - + ((variableName == null) ? 0 : variableName.hashCode()); + result = prime * result + ((variableName == null) ? 0 : variableName.hashCode()); return result; } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java index 0d10a07..9fb0a5e 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ArithmeticCollapser.java @@ -13,17 +13,15 @@ import bjc.utils.funcdata.IList; import bjc.utils.data.Tree; class ArithmeticCollapser { - private BinaryOperator<Integer> reducer; - private OperatorDiceNode type; + private BinaryOperator<Integer> reducer; + private OperatorDiceNode type; - public ArithmeticCollapser(BinaryOperator<Integer> reducr, - OperatorDiceNode typ) { + public ArithmeticCollapser(BinaryOperator<Integer> reducr, OperatorDiceNode typ) { reducer = reducr; this.type = typ; } - public ITree<IDiceASTNode> collapse( - IList<ITree<IDiceASTNode>> children) { + public ITree<IDiceASTNode> collapse(IList<ITree<IDiceASTNode>> children) { boolean allConstant = children.allMatch((subtree) -> { return subtree.transformHead((node) -> { if (node.getType() == DiceASTType.LITERAL) { @@ -40,10 +38,8 @@ class ArithmeticCollapser { int initState = DiceASTUtils.literalToInteger(children.first()); - return children.tail().reduceAux(initState, - (currentNode, state) -> { - return reducer.apply(state, - DiceASTUtils.literalToInteger(currentNode)); - }, (state) -> new Tree<>(new IntegerLiteralNode(state))); + return children.tail().reduceAux(initState, (currentNode, state) -> { + return reducer.apply(state, DiceASTUtils.literalToInteger(currentNode)); + }, (state) -> new Tree<>(new IntegerLiteralNode(state))); } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java index 89f17db..a0daf31 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/ConstantCollapser.java @@ -16,21 +16,20 @@ import bjc.utils.data.Tree; * */ public class ConstantCollapser implements IOptimizationPass { - private static final ArithmeticCollapser additionCollapser = new ArithmeticCollapser( + private static final ArithmeticCollapser additionCollapser = new ArithmeticCollapser( (left, right) -> left + right, OperatorDiceNode.ADD); - private static final ArithmeticCollapser divideCollapser = new ArithmeticCollapser( + private static final ArithmeticCollapser divideCollapser = new ArithmeticCollapser( (left, right) -> left / right, OperatorDiceNode.DIVIDE); - private static final ArithmeticCollapser multiplyCollapser = new ArithmeticCollapser( + private static final ArithmeticCollapser multiplyCollapser = new ArithmeticCollapser( (left, right) -> left * right, OperatorDiceNode.MULTIPLY); - private static final ArithmeticCollapser subtractCollapser = new ArithmeticCollapser( + 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)), + private static final ArithmeticCollapser compoundCollapser = new ArithmeticCollapser( + (left, right) -> Integer.parseInt(Integer.toString(left) + Integer.toString(left)), OperatorDiceNode.COMPOUND); @Override @@ -40,51 +39,46 @@ public class ConstantCollapser implements IOptimizationPass { } @Override - public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, - IList<ITree<IDiceASTNode>> children) { + public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, IList<ITree<IDiceASTNode>> children) { if (!operator.isOperator()) { return new Tree<>(operator, children); } switch ((OperatorDiceNode) operator) { - case ADD: - return additionCollapser.collapse(children); - case DIVIDE: - return divideCollapser.collapse(children); - case MULTIPLY: - return multiplyCollapser.collapse(children); - case SUBTRACT: - return subtractCollapser.collapse(children); - case COMPOUND: - return compoundCollapser.collapse(children); - case GROUP: - if (children.getSize() != 2) { - return new Tree<>(operator, children); - } + case ADD: + return additionCollapser.collapse(children); + case DIVIDE: + return divideCollapser.collapse(children); + case MULTIPLY: + return multiplyCollapser.collapse(children); + case SUBTRACT: + return subtractCollapser.collapse(children); + case COMPOUND: + return compoundCollapser.collapse(children); + case GROUP: + if (children.getSize() != 2) { + return new Tree<>(operator, children); + } - ComplexDice dice = new ComplexDice( - DiceASTUtils.literalToExpression( - children.getByIndex(0)), - DiceASTUtils.literalToExpression( - children.getByIndex(1))); + ComplexDice dice = new ComplexDice(DiceASTUtils.literalToExpression(children.getByIndex(0)), + DiceASTUtils.literalToExpression(children.getByIndex(1))); - if (dice.canOptimize()) { - return new Tree<>( - new IntegerLiteralNode(dice.optimize())); - } + if (dice.canOptimize()) { + return new Tree<>(new IntegerLiteralNode(dice.optimize())); + } + return new Tree<>(operator, children); + case ARRAY: + if (children.getSize() != 1) { return new Tree<>(operator, children); - case ARRAY: - if (children.getSize() != 1) { - return new Tree<>(operator, children); - } + } - return children.first(); - case ASSIGN: - case LET: - default: - // We don't optimize these operators - return new Tree<>(operator, children); + return children.first(); + case ASSIGN: + case LET: + default: + // We don't optimize these operators + return new Tree<>(operator, children); } } } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java index 58943fa..b09d95d 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/IOptimizationPass.java @@ -15,7 +15,7 @@ public interface IOptimizationPass { * Optimize a leaf in the tree * * @param leafNode - * The node to optimize + * The node to optimize * @return The optimized node */ public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode); @@ -24,11 +24,10 @@ public interface IOptimizationPass { * Optimize an operator in an AST node * * @param operator - * The operator being optimized + * The operator being optimized * @param children - * The children of the operator being optimized + * The children of the operator being optimized * @return The optimized node */ - public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, - IList<ITree<IDiceASTNode>> children); + public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator, IList<ITree<IDiceASTNode>> children); } diff --git a/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java b/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java index 4a34167..f00d390 100644 --- a/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java +++ b/dice-lang/src/bjc/dicelang/v1/ast/optimization/OperationCondenser.java @@ -20,18 +20,15 @@ public class OperationCondenser { * Condense chained similiar operations into a single level * * @param ast - * The AST to condense + * The AST to condense * @return The condensed AST */ public static ITree<IDiceASTNode> condense(ITree<IDiceASTNode> ast) { - return ast.topDownTransform(OperationCondenser::pickNode, - OperationCondenser::doCondense); + return ast.topDownTransform(OperationCondenser::pickNode, OperationCondenser::doCondense); } - private static ITree<IDiceASTNode> doCondense( - ITree<IDiceASTNode> ast) { - OperatorDiceNode operation = ast - .transformHead((node) -> (OperatorDiceNode) node); + private static ITree<IDiceASTNode> doCondense(ITree<IDiceASTNode> ast) { + OperatorDiceNode operation = ast.transformHead((node) -> (OperatorDiceNode) node); IHolder<Boolean> canCondense = new Identity<>(true); @@ -72,35 +69,32 @@ public class OperationCondenser { private static TopDownTransformResult pickNode(IDiceASTNode node) { switch (node.getType()) { - case LITERAL: - return TopDownTransformResult.SKIP; - case OPERATOR: - return pickOperator((OperatorDiceNode) node); - case VARIABLE: - return TopDownTransformResult.SKIP; - default: - throw new UnsupportedOperationException( - "Attempted to traverse unknown node type " + node); + case LITERAL: + return TopDownTransformResult.SKIP; + case OPERATOR: + return pickOperator((OperatorDiceNode) node); + case VARIABLE: + return TopDownTransformResult.SKIP; + default: + throw new UnsupportedOperationException("Attempted to traverse unknown node type " + node); } } - private static TopDownTransformResult pickOperator( - OperatorDiceNode node) { + private static TopDownTransformResult pickOperator(OperatorDiceNode node) { switch (node) { - case ADD: - case MULTIPLY: - case SUBTRACT: - case DIVIDE: - case COMPOUND: - return TopDownTransformResult.PUSHDOWN; - case ARRAY: - case ASSIGN: - case GROUP: - case LET: - return TopDownTransformResult.PASSTHROUGH; - default: - throw new UnsupportedOperationException( - "Attempted to traverse unknown operator " + node); + case ADD: + case MULTIPLY: + case SUBTRACT: + case DIVIDE: + case COMPOUND: + return TopDownTransformResult.PUSHDOWN; + case ARRAY: + case ASSIGN: + case GROUP: + case LET: + return TopDownTransformResult.PASSTHROUGH; + default: + throw new UnsupportedOperationException("Attempted to traverse unknown operator " + node); } } } diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceASTLanguageTest.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceASTLanguageTest.java index 117bc98..f20e276 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceASTLanguageTest.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceASTLanguageTest.java @@ -25,9 +25,9 @@ import bjc.utils.funcdata.IMap; * */ public class DiceASTLanguageTest { - private static IMap<String, DiceASTPragma> actions; + private static IMap<String, DiceASTPragma> actions; - private static DiceASTOptimizer optimizer; + private static DiceASTOptimizer optimizer; // Set up things that need to be configured static { @@ -42,7 +42,7 @@ public class DiceASTLanguageTest { System.out.println(varName + " is bound to " + varValue); }); }); - + // Create and configure the optimizer optimizer = new DiceASTOptimizer(); @@ -50,8 +50,7 @@ public class DiceASTLanguageTest { } // Read in a command - private static String getNextCommand(Scanner inputSource, - int commandNumber) { + private static String getNextCommand(Scanner inputSource, int commandNumber) { // Print a prompt using the current command number System.out.print("\ndice-lang-" + commandNumber + "> "); @@ -59,8 +58,7 @@ public class DiceASTLanguageTest { return inputSource.nextLine(); } - private static void handleInlineAction( - FunctionalStringTokenizer tokenizer, + private static void handleInlineAction(FunctionalStringTokenizer tokenizer, IMap<String, ITree<IDiceASTNode>> enviroment) { // Skip the pragma name tokenizer.nextToken(); @@ -70,11 +68,10 @@ public class DiceASTLanguageTest { if (pragmaArgs.getSize() < 3) { // Complain about pragma arguments not being valid - System.err.println( - "ERROR: Inline requires at least 3 parameters. They are:" - + "\n\t1. The name of the expression to inline." - + "\n\t2. The name of the variable to bind the result to." - + "\n\t3 and onwards. Names of variables to inline in the expression."); + System.err.println("ERROR: Inline requires at least 3 parameters. They are:" + + "\n\t1. The name of the expression to inline." + + "\n\t2. The name of the variable to bind the result to." + + "\n\t3 and onwards. Names of variables to inline in the expression."); } else { // Get arguments String inlineExpression = pragmaArgs.getByIndex(0); @@ -84,9 +81,8 @@ public class DiceASTLanguageTest { IList<String> inlinedVariables = pragmaArgs.tail().tail(); // Actually inline the variable - ITree<IDiceASTNode> inlinedExpression = DiceASTInliner - .selectiveInline(enviroment.get(inlineExpression), - enviroment, inlinedVariables); + ITree<IDiceASTNode> inlinedExpression = DiceASTInliner.selectiveInline( + enviroment.get(inlineExpression), enviroment, inlinedVariables); // Stick the inlined variable into the enviroment enviroment.put(variableName, inlinedExpression); @@ -97,7 +93,7 @@ public class DiceASTLanguageTest { * Main method of class * * @param args - * Unused CLI args + * Unused CLI args */ public static void main(String[] args) { // Prepare the things we need for input @@ -118,12 +114,10 @@ public class DiceASTLanguageTest { // Check and see if we're executing an action if (actions.containsKey(possibleActionName)) { // Execute action - FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer( - currentLine); + FunctionalStringTokenizer tokenizer = new FunctionalStringTokenizer(currentLine); // Execute the action - actions.get(possibleActionName).accept(tokenizer, - enviroment); + actions.get(possibleActionName).accept(tokenizer, enviroment); // Get the next command currentLine = getNextCommand(inputSource, commandNumber); @@ -138,11 +132,9 @@ public class DiceASTLanguageTest { long time = System.nanoTime(); // Prepare the command - IList<String> preparedTokens = DiceExpressionPreparer - .prepareCommand(currentLine); + IList<String> preparedTokens = DiceExpressionPreparer.prepareCommand(currentLine); - System.out.println("Command prepared in " - + (double) (System.nanoTime() - time) / 1000000000 + System.out.println("Command prepared in " + (double) (System.nanoTime() - time) / 1000000000 + " s"); try { @@ -152,14 +144,9 @@ public class DiceASTLanguageTest { // Create the AST builtAST = DiceASTParser.createFromString(preparedTokens); - System.out - .println( - "Command parsed in " - + (double) (System.nanoTime() - - time) / 1000000000 - + " s"); - } catch (InputMismatchException | IllegalStateException - | UnsupportedOperationException ex) { + System.out.println("Command parsed in " + + (double) (System.nanoTime() - time) / 1000000000 + " s"); + } catch (InputMismatchException | IllegalStateException | UnsupportedOperationException ex) { // Tell the user there was an error in parsing System.out.println("PARSING ERROR: " + ex.getLocalizedMessage()); @@ -176,40 +163,33 @@ public class DiceASTLanguageTest { time = System.nanoTime(); // Transform the AST - ITree<IDiceASTNode> transformedAST = transformAST(builtAST, - enviroment); + ITree<IDiceASTNode> transformedAST = transformAST(builtAST, enviroment); - System.out.println("Command transformed in " - + (double) (System.nanoTime() - time) / 1000000000 + System.out.println("Command transformed in " + (double) (System.nanoTime() - time) / 1000000000 + " s"); // Print out the transformed AST - System.out - .println("\tTransformed: " + transformedAST.toString()); - + System.out.println("\tTransformed: " + transformedAST.toString()); try { // Time the evaluation time = System.nanoTime(); // Evaluate the expression once - IResult sampleResult = DiceASTEvaluator.evaluateAST(transformedAST, - enviroment); + IResult sampleResult = DiceASTEvaluator.evaluateAST(transformedAST, enviroment); - System.out - .println( - "Command evaluated in " - + (double) (System.nanoTime() - - time) / 1000000000 - + " s"); + System.out.println("Command evaluated in " + + (double) (System.nanoTime() - time) / 1000000000 + " s"); - // Print out the result of evaluating the expression + // Print out the result of evaluating the + // expression System.out.println("\t\tSample Result: " + sampleResult); - + // Update the 'last' meta-variable enviroment.put("last", transformedAST); } catch (UnsupportedOperationException usex) { - // Tell the user there was an error in evaluation + // Tell the user there was an error in + // evaluation System.out.println("EVALUATION ERROR: " + usex.getLocalizedMessage()); // Get the next command @@ -219,7 +199,6 @@ public class DiceASTLanguageTest { continue; } - // Increase the number of commands commandNumber++; @@ -234,20 +213,16 @@ public class DiceASTLanguageTest { } // Transform a parsed AST - private static ITree<IDiceASTNode> transformAST( - ITree<IDiceASTNode> builtAST, + private static ITree<IDiceASTNode> transformAST(ITree<IDiceASTNode> builtAST, IMap<String, ITree<IDiceASTNode>> enviroment) { // Optimize the tree first - ITree<IDiceASTNode> optimizedTree = optimizer - .optimizeTree(builtAST, enviroment); + ITree<IDiceASTNode> optimizedTree = optimizer.optimizeTree(builtAST, enviroment); // Then, condense unnecessary operations - ITree<IDiceASTNode> condensedTree = OperationCondenser - .condense(optimizedTree); + ITree<IDiceASTNode> condensedTree = OperationCondenser.condense(optimizedTree); // Next, sanitize references - ITree<IDiceASTNode> sanitizedTree = DiceASTReferenceSanitizer - .sanitize(condensedTree, enviroment); + ITree<IDiceASTNode> sanitizedTree = DiceASTReferenceSanitizer.sanitize(condensedTree, enviroment); // Re-optimize the sanitized & condensed tree optimizedTree = optimizer.optimizeTree(sanitizedTree, enviroment); diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceASTPragma.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceASTPragma.java index 2fe9d30..a29b8b5 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceASTPragma.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceASTPragma.java @@ -10,12 +10,12 @@ import bjc.utils.funcdata.IMap; /** * Alias for the type of a 'pragma' or special language command * - * To explain it, a pragma is a function that takes a tokenizer with the rest - * of the line, and an enviroment that contains variable bindings + * To explain it, a pragma is a function that takes a tokenizer with the rest of + * the line, and an enviroment that contains variable bindings + * * @author ben * */ -public interface DiceASTPragma extends - BiConsumer<FunctionalStringTokenizer, IMap<String, ITree<IDiceASTNode>>> { +public interface DiceASTPragma extends BiConsumer<FunctionalStringTokenizer, IMap<String, ITree<IDiceASTNode>>> { // Just an alias } diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionParserTest.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionParserTest.java index 68a0da5..adffc69 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionParserTest.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionParserTest.java @@ -17,7 +17,7 @@ public class DiceExpressionParserTest { * Run the parser test * * @param args - * Unused CLI arguments + * Unused CLI arguments */ public static void main(String[] args) { /* @@ -39,8 +39,7 @@ public class DiceExpressionParserTest { int nTimes = Integer.parseInt(scn.nextLine()); - IDiceExpression dexp = DiceExpressionParser.parse(exp, - new HashMap<>()); + IDiceExpression dexp = DiceExpressionParser.parse(exp, new HashMap<>()); /* * Roll the dice a specified amount of times diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionPreparer.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionPreparer.java index f498f51..121847c 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionPreparer.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceExpressionPreparer.java @@ -20,11 +20,11 @@ public class DiceExpressionPreparer { /** * The yard to use for shunting expressions */ - private static ShuntingYard<String> yard; + private static ShuntingYard<String> yard; - private static final int MATH_PREC = 20; - private static final int DICE_PREC = 10; - private static final int EXPR_PREC = 0; + private static final int MATH_PREC = 20; + private static final int DICE_PREC = 10; + private static final int EXPR_PREC = 0; // Do initialization for all parsers static { @@ -39,29 +39,29 @@ public class DiceExpressionPreparer { yard.addOp("*", 1 + MATH_PREC); yard.addOp("/", 1 + MATH_PREC); - yard.addOp("d", 0 + DICE_PREC); // dice operator: use for creating + yard.addOp("d", 0 + DICE_PREC); // dice operator: use for + // creating // variable size dice groups yard.addOp("c", 1 + DICE_PREC); // compound operator: use for // creating compound dice from expressions yard.addOp("=>", 0 + EXPR_PREC); // let operator: evaluate an // expression in the context of another - yard.addOp(":=", 1 + EXPR_PREC); // binding operator: Bind a name + yard.addOp(":=", 1 + EXPR_PREC); // binding operator: Bind a + // name // to a variable expression } /** - * Prepare a command, turning raw tokens into input for the tree - * builder + * Prepare a command, turning raw tokens into input for the tree builder * * @param currentLine - * The command to prepare + * The command to prepare * @return A stream of tokens representing the command */ public static IList<String> prepareCommand(String currentLine) { // Split the command into tokens - IList<String> tokens = FunctionalStringTokenizer - .fromString(currentLine).toList(); + IList<String> tokens = FunctionalStringTokenizer.fromString(currentLine).toList(); // The linked list to use for handling tokens Deque<IPair<String, String>> ops = new LinkedList<>(); @@ -75,8 +75,7 @@ public class DiceExpressionPreparer { ops.add(new Pair<>("=>", "=>")); // Expand infix single tokens to multiple infix tokens - IList<String> semiExpandedTokens = ListUtils.splitTokens(tokens, - ops); + IList<String> semiExpandedTokens = ListUtils.splitTokens(tokens, ops); // Reinitialize the list ops = new LinkedList<>(); @@ -88,8 +87,7 @@ public class DiceExpressionPreparer { ops.add(new Pair<>("]", "\\]")); // Deaffix ('s and ['s from tokens - IList<String> fullyExpandedTokens = ListUtils - .deAffixTokens(semiExpandedTokens, ops); + IList<String> fullyExpandedTokens = ListUtils.deAffixTokens(semiExpandedTokens, ops); // Remove blank tokens fullyExpandedTokens.removeIf((strang) -> strang.equals("")); diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageState.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageState.java index e402d73..e2a71b4 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageState.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageState.java @@ -12,8 +12,7 @@ import bjc.utils.data.Pair; * @author ben * */ -public class DiceLanguageState - extends Pair<DiceExpressionParser, Map<String, IDiceExpression>> { +public class DiceLanguageState extends Pair<DiceExpressionParser, Map<String, IDiceExpression>> { /** * Create a new state @@ -25,12 +24,11 @@ public class DiceLanguageState * Create a new state with the desired parameters * * @param left - * The parser to use + * The parser to use * @param right - * The enviroment to use + * The enviroment to use */ - public DiceLanguageState(DiceExpressionParser left, - Map<String, IDiceExpression> right) { + public DiceLanguageState(DiceExpressionParser left, Map<String, IDiceExpression> right) { super(left, right); } } diff --git a/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageTest.java b/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageTest.java index 257e646..2d90318 100644 --- a/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageTest.java +++ b/dice-lang/src/bjc/dicelang/v1/examples/DiceLanguageTest.java @@ -28,7 +28,7 @@ public class DiceLanguageTest { * Main method * * @param args - * Unused CLI args + * Unused CLI args */ public static void main(String[] args) { Scanner scn = new Scanner(System.in); @@ -67,25 +67,24 @@ public class DiceLanguageTest { /** * @param ln - * Unused parameter, kept to comply with expected type sig + * Unused parameter, kept to comply with expected type + * sig */ private static void printEnv(String ln, DiceLanguageState stat) { System.out.println("Printing enviroment for debugging purposes."); - stat.doWith((dep, env) -> env.forEach((key, exp) -> System.out - .println("\tKey: " + key + "\tExp: " + exp.toString()))); + stat.doWith((dep, env) -> env.forEach( + (key, exp) -> System.out.println("\tKey: " + key + "\tExp: " + exp.toString()))); } private static void rollReference(String ln, DiceLanguageState stat) { String[] strangs = ln.split(" "); - System.out.println("\tRolling dice expression " + strangs[1] + " " - + strangs[2] + " times."); + System.out.println("\tRolling dice expression " + strangs[1] + " " + strangs[2] + " times."); 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(); |