Restored basic functionality with new system

3 files changed, 85 insertions, 72 deletions

diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
index 93b56de..0257b91 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTEvaluator.java
@@ -28,6 +28,12 @@ import bjc.utils.parserutils.AST;
  *
  */
 public class DiceASTEvaluator {
+	/**
+	 * Responsible for collapsing arithmetic operators
+	 * 
+	 * @author ben
+	 *
+	 */
 	private static final class ArithmeticCollapser
 			implements IOperatorCollapser {
 		private OperatorDiceNode		type;
@@ -61,27 +67,6 @@ public class DiceASTEvaluator {
 	}
 
 	/**
-	 * Evaluate the provided AST to a numeric value
-	 * 
-	 * @param expression
-	 *            The expression to evaluate
-	 * @param enviroment
-	 *            The enviroment to look up variables in
-	 * @return The integer value of the expression
-	 */
-	public static int evaluateAST(AST<IDiceASTNode> expression,
-			IFunctionalMap<String, AST<IDiceASTNode>> enviroment) {
-		IFunctionalMap<IDiceASTNode, IOperatorCollapser> collapsers =
-				buildOperations(enviroment);
-
-		return expression.collapse((node) -> {
-			return evaluateLeaf(node, enviroment);
-		}, collapsers::get, (pair) -> {
-			return pair.merge((left, right) -> left);
-		});
-	}
-
-	/**
 	 * Build the map of operations to use when collapsing the AST
 	 * 
 	 * @param enviroment
@@ -123,6 +108,73 @@ public class DiceASTEvaluator {
 		return operatorCollapsers;
 	}
 
+	/**
+	 * Evaluate the provided AST to a numeric value
+	 * 
+	 * @param expression
+	 *            The expression to evaluate
+	 * @param enviroment
+	 *            The enviroment to look up variables in
+	 * @return The integer value of the expression
+	 */
+	public static int evaluateAST(AST<IDiceASTNode> expression,
+			IFunctionalMap<String, AST<IDiceASTNode>> enviroment) {
+		IFunctionalMap<IDiceASTNode, IOperatorCollapser> collapsers =
+				buildOperations(enviroment);
+
+		return expression.collapse(
+				(node) -> evaluateLeaf(node, enviroment), collapsers::get,
+				(pair) -> pair.merge((left, right) -> left));
+	}
+
+	private static IPair<Integer, AST<IDiceASTNode>> evaluateLeaf(
+			IDiceASTNode leafNode,
+			IFunctionalMap<String, AST<IDiceASTNode>> enviroment) {
+		int returnedValue = 0;
+
+		switch (leafNode.getType()) {
+			case LITERAL:
+				returnedValue = evaluateLiteral(leafNode, returnedValue);
+
+				break;
+			case VARIABLE:
+				String variableName =
+						((VariableDiceNode) leafNode).getVariable();
+
+				returnedValue = evaluateAST(enviroment.get(variableName),
+						enviroment);
+				break;
+			case OPERATOR:
+				throw new UnsupportedOperationException(
+						"Operator '" + leafNode + "' cannot be a leaf.");
+			default:
+				break;
+
+		}
+
+		return new Pair<>(returnedValue, new AST<>(leafNode));
+	}
+
+	private static int evaluateLiteral(IDiceASTNode leafNode,
+			int returnedValue) {
+		DiceLiteralType literalType =
+				((ILiteralDiceNode) leafNode).getLiteralType();
+
+		switch (literalType) {
+			case DICE:
+				returnedValue = ((DiceLiteralNode) leafNode).getValue();
+				break;
+			case INTEGER:
+				returnedValue = ((IntegerLiteralNode) leafNode).getValue();
+				break;
+			default:
+				throw new UnsupportedOperationException("Literal value '"
+						+ leafNode + "' is of a type (" + literalType
+						+ ") not currently supported.");
+		}
+		return returnedValue;
+	}
+
 	private static IPair<Integer, AST<IDiceASTNode>> parseBinding(
 			IFunctionalMap<String, AST<IDiceASTNode>> enviroment,
 			IPair<Integer, AST<IDiceASTNode>> left,
@@ -148,8 +200,7 @@ public class DiceASTEvaluator {
 				rightAST.traverse(TreeLinearizationMethod.PREORDER,
 						refChecker);
 
-				// Ignore meta-variable that'll be auto-frozen to restore
-				// definition sanity
+				// Ignore meta-variable
 				if (selfReference.unwrap((bool) -> bool)
 						&& !variableName.equals("last")) {
 					throw new UnsupportedOperationException(
@@ -161,7 +212,7 @@ public class DiceASTEvaluator {
 				if (!variableName.equals("last")) {
 					enviroment.put(variableName, rightAST);
 				} else {
-					// Do nothing, last is a auto-handled meta-variable
+					// Do nothing, last is an auto-handled meta-variable
 				}
 
 				return new Pair<>(rightValue, new AST<>(
@@ -210,52 +261,4 @@ public class DiceASTEvaluator {
 			});
 		});
 	}
-
-	private static IPair<Integer, AST<IDiceASTNode>> evaluateLeaf(
-			IDiceASTNode leafNode,
-			IFunctionalMap<String, AST<IDiceASTNode>> enviroment) {
-		int returnedValue = 0;
-
-		switch (leafNode.getType()) {
-			case LITERAL:
-				returnedValue = evaluateLiteral(leafNode, returnedValue);
-
-				break;
-			case VARIABLE:
-				String variableName =
-						((VariableDiceNode) leafNode).getVariable();
-
-				returnedValue = evaluateAST(enviroment.get(variableName),
-						enviroment);
-				break;
-			case OPERATOR:
-				throw new UnsupportedOperationException(
-						"Operator '" + leafNode + "' cannot be a leaf.");
-			default:
-				break;
-
-		}
-
-		return new Pair<>(returnedValue, new AST<>(leafNode));
-	}
-
-	private static int evaluateLiteral(IDiceASTNode leafNode,
-			int returnedValue) {
-		DiceLiteralType literalType =
-				((ILiteralDiceNode) leafNode).getLiteralType();
-
-		switch (literalType) {
-			case DICE:
-				returnedValue = ((DiceLiteralNode) leafNode).getValue();
-				break;
-			case INTEGER:
-				returnedValue = ((IntegerLiteralNode) leafNode).getValue();
-				break;
-			default:
-				throw new UnsupportedOperationException("Literal value '"
-						+ leafNode + "' is of a type (" + literalType
-						+ ") not currently supported.");
-		}
-		return returnedValue;
-	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceLiteralNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceLiteralNode.java
index 82c764d..b2e1825 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceLiteralNode.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/DiceLiteralNode.java
@@ -54,4 +54,9 @@ public class DiceLiteralNode implements ILiteralDiceNode {
 	public int optimize() {
 		return expression.optimize();
 	}
+	
+	@Override
+	public String toString() {
+		return expression.toString();
+	}
 }
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/IntegerLiteralNode.java b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/IntegerLiteralNode.java
index 415f30f..0ed2c2c 100644
--- a/dice-lang/src/main/java/bjc/dicelang/ast/nodes/IntegerLiteralNode.java
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/nodes/IntegerLiteralNode.java
@@ -32,4 +32,9 @@ public class IntegerLiteralNode implements ILiteralDiceNode {
 	public int getValue() {
 		return value;
 	}
+	
+	@Override
+	public String toString() {
+		return Integer.toString(value);
+	}
 }