Update

8 files changed, 311 insertions, 285 deletions

diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
index ad56cc1..1517abd 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
@@ -224,8 +224,7 @@ public class DiceLangEngine {
 				System.out.println("\tString literals in table");
 
 				stringLiterals.forEach((key, val) -> {
-					System.out.printf("\t\tName: (%s)\tValue: (%s)\n",
-						key, val);
+					System.out.printf("\t\tName: (%s)\tValue: (%s)\n", key, val);
 				});
 			}
 		}
@@ -287,57 +286,10 @@ public class DiceLangEngine {
 		IList<Token> shuntedTokens = lexedTokens;
 
 		IList<Token> preparedTokens         = new FunctionalList<>();
-		int curBraceCount                   = 0;
-		Deque<IList<Token>> bracedTokens    = new LinkedList<>();
-		IList<Token> curBracedTokens        = null;
-
-		for(Token tk : lexedTokens) {
-			if(tk.type == Token.Type.OBRACE && tk.intValue == 2) {
-				curBraceCount += 1;
-
-				if(curBraceCount != 1) {
-					bracedTokens.push(curBracedTokens);
-				}
-
-				curBracedTokens = new FunctionalList<>();
-			} else if(tk.type == Token.Type.CBRACE && tk.intValue == 2) {
-				if(curBraceCount == 0) {
-					Errors.inst.printError(EK_ENG_NOOPENING);
-					return false;
-				}
-
-				curBraceCount -= 1;
-
-				IList<Token> preshuntTokens = new FunctionalList<>();
-
-				success = shunt.shuntTokens(curBracedTokens, preshuntTokens);
-
-				if(debugMode)
-					System.out.println("\t\tPreshunted " + curBracedTokens + " into " + preshuntTokens);
-
-				if(!success) return false;
-
-				if(curBraceCount >= 1) {
-					curBracedTokens = bracedTokens.pop();
-
-					curBracedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
-				} else {
-					preparedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
-				}
-			} else {
-				if(curBraceCount >= 1) {
-					curBracedTokens.add(tk);
-				} else {
-					preparedTokens.add(tk);
-				}
-			}
-		}
-
-		if(curBraceCount > 0) {
-			Errors.inst.printError(EK_ENG_NOCLOSING);
-			return false;
-		}
+		boolean sc = removePreshuntTokens(lexedTokens, preparedTokens);
 
+		if(!sc) return false;
+		
 		if(debugMode && !postfixMode)
 			System.out.printf("\tCommand after pre-shunter removal: %s\n", preparedTokens.toString());
 
@@ -389,55 +341,115 @@ public class DiceLangEngine {
 		if(!success) return false;
 
 		if(debugMode) {
-			System.out.println("\tParsed forest of asts");
-			int treeNo = 1;
+			evaluateForest(astForest);
+		}
 
-			for(ITree<Node> ast : astForest) {
-				System.out.println("\t\tTree " + treeNo + " in forest:\n\t\t    " + ast);
+		return true;
+	}
 
-				if(stepEval) {
-					int step = 1;
+	private void evaluateForest(IList<ITree<Node>> astForest) {
+		System.out.println("\tParsed forest of asts");
+		int treeNo = 1;
 
-					for(Iterator<ITree<Node>> itr = eval.stepDebug(ast); itr.hasNext();){
-						ITree<Node> nodeStep = itr.next();
+		for(ITree<Node> ast : astForest) {
+			System.out.println("\t\tTree " + treeNo + " in forest:\n\t\t    " + ast);
 
-						System.out.printf("\t\tStep %d: Node is %s", step, nodeStep);
+			if(stepEval) {
+				int step = 1;
 
-						if(nodeStep.getHead().type == Node.Type.RESULT) {
-							Evaluator.Result res = nodeStep.getHead().resultVal;
+				for(Iterator<ITree<Node>> itr = eval.stepDebug(ast); itr.hasNext();){
+					ITree<Node> nodeStep = itr.next();
 
-							System.out.printf(" (result is %s", res);
+					System.out.printf("\t\tStep %d: Node is %s", step, nodeStep);
 
-							if(res.type == Evaluator.Result.Type.DICE) {
-								System.out.printf(" (sample roll %s)", res.diceVal.value());
-							}
+					if(nodeStep.getHead().type == Node.Type.RESULT) {
+						EvaluatorResult res = nodeStep.getHead().resultVal;
 
-							if(res.origVal != null) {
-								System.out.printf(" (original tree is %s)", res.origVal);
-							}
+						System.out.printf(" (result is %s", res);
 
-							System.out.printf(")");
+						if(res.type == EvaluatorResult.Type.DICE) {
+							System.out.printf(" (sample roll %s)", res.diceVal.value());
 						}
 
+						if(res.origVal != null) {
+							System.out.printf(" (original tree is %s)", res.origVal);
+						}
 
-						System.out.println();
-						step += 1;
+						System.out.printf(")");
 					}
-				} else {
-					Evaluator.Result res = eval.evaluate(ast);
-					System.out.printf("\t\tEvaluates to %s", res);
 
-					if(res.type == Evaluator.Result.Type.DICE) {
-						System.out.println(" (sample roll " + res.diceVal.value() + ")");
-					}
+
+					System.out.println();
+					step += 1;
+				}
+			} else {
+				EvaluatorResult res = eval.evaluate(ast);
+				System.out.printf("\t\tEvaluates to %s", res);
+
+				if(res.type == EvaluatorResult.Type.DICE) {
+					System.out.println(" (sample roll " + res.diceVal.value() + ")");
 				}
+			}
 
-				System.out.println();
+			System.out.println();
 
-				treeNo += 1;
+			treeNo += 1;
+		}
+	}
+
+	private boolean removePreshuntTokens(IList<Token> lexedTokens, IList<Token> preparedTokens) {
+		boolean success;
+		int curBraceCount                   = 0;
+		Deque<IList<Token>> bracedTokens    = new LinkedList<>();
+		IList<Token> curBracedTokens        = null;
+
+		for(Token tk : lexedTokens) {
+			if(tk.type == Token.Type.OBRACE && tk.intValue == 2) {
+				curBraceCount += 1;
+
+				if(curBraceCount != 1) {
+					bracedTokens.push(curBracedTokens);
+				}
+
+				curBracedTokens = new FunctionalList<>();
+			} else if(tk.type == Token.Type.CBRACE && tk.intValue == 2) {
+				if(curBraceCount == 0) {
+					Errors.inst.printError(EK_ENG_NOOPENING);
+					return false;
+				}
+
+				curBraceCount -= 1;
+
+				IList<Token> preshuntTokens = new FunctionalList<>();
+
+				success = shunt.shuntTokens(curBracedTokens, preshuntTokens);
+
+				if(debugMode)
+					System.out.println("\t\tPreshunted " + curBracedTokens + " into " + preshuntTokens);
+
+				if(!success) return false;
+
+				if(curBraceCount >= 1) {
+					curBracedTokens = bracedTokens.pop();
+
+					curBracedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
+				} else {
+					preparedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
+				}
+			} else {
+				if(curBraceCount >= 1) {
+					curBracedTokens.add(tk);
+				} else {
+					preparedTokens.add(tk);
+				}
 			}
 		}
 
+		if(curBraceCount > 0) {
+			Errors.inst.printError(EK_ENG_NOCLOSING);
+			return false;
+		}
+		
 		return true;
 	}
 
diff --git a/dice-lang/src/bjc/dicelang/v2/Errors.java b/dice-lang/src/bjc/dicelang/v2/Errors.java
index a533438..0f4c52d 100644
--- a/dice-lang/src/bjc/dicelang/v2/Errors.java
+++ b/dice-lang/src/bjc/dicelang/v2/Errors.java
@@ -35,8 +35,12 @@ public class Errors {
 		EK_EVAL_INVNODE,
 		// Incorrect # of args to binary operator
 		EK_EVAL_INVBIN,
+		// Incorrect # of args to unary operator
+		EK_EVAL_INVUNARY,
 		// Unknown binary operator
 		EK_EVAL_UNBIN,
+		// Unknown unary operator
+		EK_EVAL_UNUNARY,
 		// Math on strings doesn't work
 		EK_EVAL_STRINGMATH,
 		// Attempted divide by zero
diff --git a/dice-lang/src/bjc/dicelang/v2/Evaluator.java b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
index c13e42d..7624b47 100644
--- a/dice-lang/src/bjc/dicelang/v2/Evaluator.java
+++ b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
@@ -2,106 +2,15 @@ package bjc.dicelang.v2;
 
 import bjc.utils.data.ITree;
 import bjc.utils.data.Tree;
-import bjc.utils.data.TransformedIterator;
 import bjc.utils.data.TopDownTransformIterator;
 import bjc.utils.data.TopDownTransformResult;
 import java.util.Iterator;
 import java.util.function.Consumer;
 
 import static bjc.dicelang.v2.Errors.ErrorKey.*;
-import static bjc.dicelang.v2.Evaluator.Result.Type.*;
+import static bjc.dicelang.v2.EvaluatorResult.Type.*;
 
 public class Evaluator {
-	public static class Result {
-		public static enum Type {
-			FAILURE,
-			INT, FLOAT, DICE, STRING
-		}
-
-		public final Type type;
-
-		// These may or may not have values based
-		// off of the result type
-		public long                  intVal;
-		public double                floatVal;
-		public DiceBox.DieExpression diceVal;
-		public String                stringVal;
-
-		// Original node data
-		public ITree<Node>           origVal;
-
-		public Result(Type typ) {
-			type = typ;
-		}
-
-		public Result(Type typ, ITree<Node> orig) {
-			this(typ);
-
-			origVal = orig;
-		}
-
-		public Result(Type typ, Node orig) {
-			this(typ, new Tree<>(orig));
-		}
-
-		public Result(Type typ, Result orig) {
-			this(typ, new Node(Node.Type.RESULT, orig));
-		}
-
-		public Result(Type typ, long iVal) {
-			this(typ);
-
-			intVal = iVal;
-		}
-
-		public Result(Type typ, double dVal) {
-			this(typ);
-
-			floatVal = dVal;
-		}
-
-		public Result(Type typ, DiceBox.DieExpression dVal) {
-			this(typ);
-
-			diceVal = dVal;
-		}
-
-		public Result(Type typ, DiceBox.Die dVal) {
-			this(typ);
-
-			diceVal = new DiceBox.DieExpression(dVal);
-		}
-
-		public Result(Type typ, DiceBox.DieList dVal) {
-			this(typ);
-
-			diceVal = new DiceBox.DieExpression(dVal);
-		}
-
-		public Result(Type typ, String strang) {
-			this(typ);
-
-			stringVal = strang;
-		}
-
-		public String toString() {
-			switch(type) {
-				case INT:
-					return type.toString() + "(" + intVal + ")";
-				case FLOAT:
-					return type.toString() + "(" + floatVal + ")";
-				case DICE:
-					return type.toString() + "(" + diceVal + ")";
-				case STRING:
-					return type.toString() + "(" + stringVal + ")";
-				case FAILURE:
-					return type.toString();
-				default:
-					return "Unknown result type " + type.toString();
-			}
-		}
-	}
-
 	private static class Context {
 		public Consumer<Iterator<ITree<Node>>> thunk;
 		
@@ -109,19 +18,19 @@ public class Evaluator {
 	}
 
 	private static Node FAIL() {
-		return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE));
+		return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE));
 	}
 
 	private static Node FAIL(ITree<Node> orig) {
-		return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, orig));
+		return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, orig));
 	}
 
 	private static Node FAIL(Node orig) {
-		return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, orig));
+		return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, orig));
 	}
 
-	private static Node FAIL(Result res) {
-		return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, new Node(Node.Type.RESULT, res)));
+	private static Node FAIL(EvaluatorResult res) {
+		return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, new Node(Node.Type.RESULT, res)));
 	}
 
 	private DiceLangEngine eng;
@@ -130,7 +39,7 @@ public class Evaluator {
 		eng = en;
 	}
 
-	public Result evaluate(ITree<Node> comm) {
+	public EvaluatorResult evaluate(ITree<Node> comm) {
 		Context ctx = new Context();
 
 		ctx.isDebug = false;
@@ -161,7 +70,7 @@ public class Evaluator {
 			case UNARYOP:
 				switch(nd.operatorType) {
 					case COERCE:
-						return TopDownTransformResult.PULLUP;
+						return TopDownTransformResult.RTRANSFORM;
 					default:
 						return TopDownTransformResult.PUSHDOWN;
 				}
@@ -190,7 +99,7 @@ public class Evaluator {
 		switch(ast.getHead().operatorType) {
 			case COERCE:
 				if(ast.getChildrenCount() != 1) {
-					Errors.inst.printError(EK_EVAL_NOTUNARY, ast.getChildrenCount());
+					Errors.inst.printError(EK_EVAL_UNUNARY, Integer.toString(ast.getChildrenCount()));
 					return new Tree<>(FAIL(ast));
 				}
 				break;
@@ -198,6 +107,9 @@ public class Evaluator {
 				Errors.inst.printError(EK_EVAL_INVUNARY, ast.getHead().operatorType.toString());
 				return new Tree<>(FAIL(ast));
 		}
+		
+		// @TODO remove me
+		return new Tree<>(FAIL(ast));
 	}
 
 	private ITree<Node> evaluateBinaryOp(ITree<Node> ast, Context ctx) {
@@ -234,26 +146,26 @@ public class Evaluator {
 	}
 
 	private ITree<Node> evaluateDiceBinary(Token.Type op,
-			Result left, Result right, Context ctx) {
-		Result res = null;
+			EvaluatorResult left, EvaluatorResult right, Context ctx) {
+		EvaluatorResult res = null;
 
 		switch(op) {
 			case DICEGROUP:
 				if(left.type == DICE && !left.diceVal.isList) {
 					if(right.type == DICE && !right.diceVal.isList) {
-						res = new Result(DICE,
+						res = new EvaluatorResult(DICE,
 								new DiceBox.SimpleDie(left.diceVal.scalar, right.diceVal.scalar));
 					} else if (right.type == INT) {
-						res = new Result(DICE, new DiceBox.SimpleDie(left.diceVal.scalar, right.intVal));
+						res = new EvaluatorResult(DICE, new DiceBox.SimpleDie(left.diceVal.scalar, right.intVal));
 					} else {
 						Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
 						return new Tree<>(FAIL(right));
 					}
 				} else if(left.type == INT) {
 					if(right.type == DICE && !right.diceVal.isList) {
-						res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.diceVal.scalar));
+						res = new EvaluatorResult(DICE, new DiceBox.SimpleDie(left.intVal, right.diceVal.scalar));
 					} else if (right.type == INT) {
-						res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.intVal));
+						res = new EvaluatorResult(DICE, new DiceBox.SimpleDie(left.intVal, right.intVal));
 					} else {
 						Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
 						return new Tree<>(FAIL(right));
@@ -270,7 +182,7 @@ public class Evaluator {
 					Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
 					return new Tree<>(FAIL(right));
 				} else {
-					res = new Result(DICE, 
+					res = new EvaluatorResult(DICE, 
 							new DiceBox.CompoundDie(left.diceVal.scalar, right.diceVal.scalar));
 				}
 				break;
@@ -282,7 +194,7 @@ public class Evaluator {
 					Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
 					return new Tree<>(FAIL(right));
 				} else {
-					res = new Result(DICE,
+					res = new EvaluatorResult(DICE,
 							new DiceBox.SimpleDieList(left.diceVal.scalar, right.diceVal.scalar));
 				}
 				break;
@@ -295,84 +207,84 @@ public class Evaluator {
 	}
 
 	private ITree<Node> evaluateMathBinary(Token.Type op,
-			Result left, Result right, Context ctx) {
-		if(left.type == Result.Type.DICE || right.type == Result.Type.DICE) {
+			EvaluatorResult left, EvaluatorResult right, Context ctx) {
+		if(left.type == EvaluatorResult.Type.DICE || right.type == EvaluatorResult.Type.DICE) {
 			System.out.println("\tEVALUATOR ERROR: Math on dice isn't supported yet");
 			return new Tree<>(FAIL());
-		} else if(left.type == Result.Type.STRING || right.type == Result.Type.STRING) {
+		} else if(left.type == EvaluatorResult.Type.STRING || right.type == EvaluatorResult.Type.STRING) {
 			Errors.inst.printError(EK_EVAL_STRINGMATH);
 			return new Tree<>(FAIL());
-		} else if(left.type == Result.Type.FAILURE || right.type == Result.Type.FAILURE) {
+		} else if(left.type == EvaluatorResult.Type.FAILURE || right.type == EvaluatorResult.Type.FAILURE) {
 			return new Tree<>(FAIL());
-		} else if(left.type == Result.Type.INT && right.type != Result.Type.INT) {
+		} else if(left.type == EvaluatorResult.Type.INT && right.type != EvaluatorResult.Type.INT) {
 			Errors.inst.printError(EK_EVAL_MISMATH);
 			return new Tree<>(FAIL(right));
-		} else if(left.type == Result.Type.FLOAT && right.type != Result.Type.FLOAT) {
+		} else if(left.type == EvaluatorResult.Type.FLOAT && right.type != EvaluatorResult.Type.FLOAT) {
 			Errors.inst.printError(EK_EVAL_MISMATH);
 			return new Tree<>(FAIL(right));
-		} else if(right.type == Result.Type.INT && left.type != Result.Type.INT) {
+		} else if(right.type == EvaluatorResult.Type.INT && left.type != EvaluatorResult.Type.INT) {
 			Errors.inst.printError(EK_EVAL_MISMATH);
 			return new Tree<>(FAIL(left));
-		} else if(right.type == Result.Type.FLOAT && left.type != Result.Type.FLOAT) {
+		} else if(right.type == EvaluatorResult.Type.FLOAT && left.type != EvaluatorResult.Type.FLOAT) {
 			Errors.inst.printError(EK_EVAL_MISMATH);
 			return new Tree<>(FAIL(left));
 		}
 
-		Result res = null;
+		EvaluatorResult res = null;
 
 		switch(op) {
 			case ADD:
-				if(left.type == Result.Type.INT) {
-					res = new Result(Result.Type.INT, left.intVal + right.intVal);
+				if(left.type == EvaluatorResult.Type.INT) {
+					res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal + right.intVal);
 				} else {
-					res = new Result(Result.Type.FLOAT, left.floatVal + right.floatVal);
+					res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal + right.floatVal);
 				}
 				break;
 			case SUBTRACT:
-				if(left.type == Result.Type.INT) {
-					res = new Result(Result.Type.INT, left.intVal - right.intVal);
+				if(left.type == EvaluatorResult.Type.INT) {
+					res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal - right.intVal);
 				} else {
-					res = new Result(Result.Type.FLOAT, left.floatVal - right.floatVal);
+					res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal - right.floatVal);
 				}
 				break;
 			case MULTIPLY:
-				if(left.type == Result.Type.INT) {
-					res = new Result(Result.Type.INT, left.intVal * right.intVal);
+				if(left.type == EvaluatorResult.Type.INT) {
+					res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal * right.intVal);
 				} else {
-					res = new Result(Result.Type.FLOAT, left.floatVal * right.floatVal);
+					res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal * right.floatVal);
 				}
 				break;
 			case DIVIDE:
-				if(left.type == Result.Type.INT) {
+				if(left.type == EvaluatorResult.Type.INT) {
 					if(right.intVal == 0) {
 						Errors.inst.printError(EK_EVAL_DIVZERO);
-						res = new Result(Result.Type.FAILURE, right);
+						res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
 					} else {
-						res = new Result(Result.Type.FLOAT, left.intVal / right.intVal);
+						res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.intVal / right.intVal);
 					}
 				} else {
 					if(right.floatVal == 0) {
 						Errors.inst.printError(EK_EVAL_DIVZERO);
-						res = new Result(Result.Type.FAILURE, right);
+						res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
 					} else {
-						res = new Result(Result.Type.FLOAT, left.floatVal / right.floatVal);
+						res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal / right.floatVal);
 					}
 				}
 				break;
 			case IDIVIDE:
-				if(left.type == Result.Type.INT) {
+				if(left.type == EvaluatorResult.Type.INT) {
 					if(right.intVal == 0) {
 						Errors.inst.printError(EK_EVAL_DIVZERO);
-						res = new Result(Result.Type.FAILURE, right);
+						res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
 					} else {
-						res = new Result(Result.Type.INT, (int) (left.intVal / right.intVal));
+						res = new EvaluatorResult(EvaluatorResult.Type.INT, (int) (left.intVal / right.intVal));
 					}
 				} else {
 					if(right.floatVal == 0) {
 						Errors.inst.printError(EK_EVAL_DIVZERO);
-						res = new Result(Result.Type.FAILURE, right);
+						res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
 					} else {
-						res = new Result(Result.Type.INT, (int) (left.floatVal / right.floatVal));
+						res = new EvaluatorResult(EvaluatorResult.Type.INT, (int) (left.floatVal / right.floatVal));
 					}
 				}
 				break;
@@ -385,24 +297,24 @@ public class Evaluator {
 	}
 
 	private ITree<Node> evaluateTokenRef(Token tk, Context ctx) {
-		Result res = null;
+		EvaluatorResult res = null;
 
 		switch(tk.type) {
 			case INT_LIT:
-				res = new Result(Result.Type.INT, tk.intValue);
+				res = new EvaluatorResult(EvaluatorResult.Type.INT, tk.intValue);
 				break;
 			case FLOAT_LIT:
-				res = new Result(Result.Type.FLOAT, tk.floatValue);
+				res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, tk.floatValue);
 				break;
 			case DICE_LIT:
-				res = new Result(Result.Type.DICE, tk.diceValue);
+				res = new EvaluatorResult(EvaluatorResult.Type.DICE, tk.diceValue);
 				break;
 			case STRING_LIT:
-				res = new Result(Result.Type.STRING, eng.stringLits.get((int)(tk.intValue)));
+				res = new EvaluatorResult(EvaluatorResult.Type.STRING, eng.stringLits.get((int)(tk.intValue)));
 				break;
 			default:
 				Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString());
-				res = new Result(Result.Type.FAILURE);
+				res = new EvaluatorResult(EvaluatorResult.Type.FAILURE);
 		}
 
 		return new Tree<>(new Node(Node.Type.RESULT, res));
diff --git a/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java b/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java
new file mode 100644
index 0000000..510d5e9
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java
@@ -0,0 +1,94 @@
+package bjc.dicelang.v2;

+

+import bjc.utils.data.ITree;

+import bjc.utils.data.Tree;

+

+public class EvaluatorResult {

+	public static enum Type {

+		FAILURE,

+		INT, FLOAT, DICE, STRING

+	}

+

+	public final EvaluatorResult.Type type;

+

+	// These may or may not have values based

+	// off of the result type

+	public long                  intVal;

+	public double                floatVal;

+	public DiceBox.DieExpression diceVal;

+	public String                stringVal;

+

+	// Original node data

+	public ITree<Node>           origVal;

+

+	public EvaluatorResult(EvaluatorResult.Type typ) {

+		type = typ;

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, ITree<Node> orig) {

+		this(typ);

+

+		origVal = orig;

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, Node orig) {

+		this(typ, new Tree<>(orig));

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, EvaluatorResult orig) {

+		this(typ, new Node(Node.Type.RESULT, orig));

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, long iVal) {

+		this(typ);

+

+		intVal = iVal;

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, double dVal) {

+		this(typ);

+

+		floatVal = dVal;

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.DieExpression dVal) {

+		this(typ);

+

+		diceVal = dVal;

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.Die dVal) {

+		this(typ);

+

+		diceVal = new DiceBox.DieExpression(dVal);

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.DieList dVal) {

+		this(typ);

+

+		diceVal = new DiceBox.DieExpression(dVal);

+	}

+

+	public EvaluatorResult(EvaluatorResult.Type typ, String strang) {

+		this(typ);

+

+		stringVal = strang;

+	}

+

+	public String toString() {

+		switch(type) {

+			case INT:

+				return type.toString() + "(" + intVal + ")";

+			case FLOAT:

+				return type.toString() + "(" + floatVal + ")";

+			case DICE:

+				return type.toString() + "(" + diceVal + ")";

+			case STRING:

+				return type.toString() + "(" + stringVal + ")";

+			case FAILURE:

+				return type.toString();

+			default:

+				return "Unknown result type " + type.toString();

+		}

+	}

+}
\ No newline at end of file
diff --git a/dice-lang/src/bjc/dicelang/v2/Node.java b/dice-lang/src/bjc/dicelang/v2/Node.java
index bd191d2..334a9f3 100644
--- a/dice-lang/src/bjc/dicelang/v2/Node.java
+++ b/dice-lang/src/bjc/dicelang/v2/Node.java
@@ -18,7 +18,7 @@ public class Node {
 	public Token      		tokenVal;
 	public Token.Type 		operatorType;
 	public GroupType 		groupType;
-	public Evaluator.Result resultVal;
+	public EvaluatorResult resultVal;
 
 	public Node(Type typ) {
 		type = typ;
@@ -42,7 +42,7 @@ public class Node {
 		groupType = grupType;
 	}
 
-	public Node(Type typ, Evaluator.Result res) {
+	public Node(Type typ, EvaluatorResult res) {
 		this(typ);
 
 		resultVal = res;
diff --git a/dice-lang/src/bjc/dicelang/v2/Parser.java b/dice-lang/src/bjc/dicelang/v2/Parser.java
index 7151e0e..c939a8b 100644
--- a/dice-lang/src/bjc/dicelang/v2/Parser.java
+++ b/dice-lang/src/bjc/dicelang/v2/Parser.java
@@ -28,59 +28,8 @@ public class Parser {
 					break;
 				case CBRACKET:
 				case CBRACE:
-					if(working.size() == 0) {
-						Errors.inst.printError(EK_PARSE_NOCLOSE);
-						return false;
-					}
-					
-					ITree<Node> groupNode = null;
-					switch(tk.type) {
-						case CBRACE:
-							groupNode = new Tree<>(new Node(GROUP, Node.GroupType.CODE));
-							break;
-						case CBRACKET:
-							groupNode = new Tree<>(new Node(GROUP, Node.GroupType.ARRAY));
-							break;
-						default:
-							break;
-					}
-					Token matching = null;
-
-					if(tk.type == CBRACKET) {
-						matching = new Token(Token.Type.OBRACKET, tk.intValue);
-					} else if(tk.type == CBRACE) {
-						matching = new Token(Token.Type.OBRACE, tk.intValue);
-					}
-
-					ITree<Node> matchNode = new Tree<>(new Node(OGROUP, matching));
-
-					if(!working.contains(matchNode)) {
-						Errors.inst.printError(EK_PARSE_UNCLOSE, tk.toString(), matchNode.toString());
-
-						System.out.println("\tCurrent forest is: ");
-
-						int treeNo = 1;
-						for(ITree<Node> ast : working) {
-							System.out.println("Tree " + treeNo++ + ": " + ast.toString());
-						}
-
-						return false;
-					} else {
-						Deque<ITree<Node>> childs = new LinkedList<>();
-
-						while(!working.peek().equals(matchNode)) {
-							childs.push(working.pop());
-						}
-
-						// Discard opener
-						working.pop();
-
-						for(ITree<Node> child : childs) {
-							groupNode.addChild(child);
-						}
-
-						working.push(groupNode);
-					}
+					boolean sc = parseClosingGrouper(working, tk);
+					if(!sc)      return false;
 					break;
 				case LET:
 				case BIND:
@@ -158,4 +107,61 @@ public class Parser {
 
 		return true;
 	}
+
+	private boolean parseClosingGrouper(Deque<ITree<Node>> working, Token tk) {
+		if(working.size() == 0) {
+			Errors.inst.printError(EK_PARSE_NOCLOSE);
+			return false;
+		}
+		
+		ITree<Node> groupNode = null;
+		switch(tk.type) {
+			case CBRACE:
+				groupNode = new Tree<>(new Node(GROUP, Node.GroupType.CODE));
+				break;
+			case CBRACKET:
+				groupNode = new Tree<>(new Node(GROUP, Node.GroupType.ARRAY));
+				break;
+			default:
+				break;
+		}
+		
+		Token matching = null;
+		if(tk.type == CBRACKET) {
+			matching = new Token(Token.Type.OBRACKET, tk.intValue);
+		} else if(tk.type == CBRACE) {
+			matching = new Token(Token.Type.OBRACE, tk.intValue);
+		}
+
+		ITree<Node> matchNode = new Tree<>(new Node(OGROUP, matching));
+		if(!working.contains(matchNode)) {
+			Errors.inst.printError(EK_PARSE_UNCLOSE, tk.toString(), matchNode.toString());
+
+			System.out.println("\tCurrent forest is: ");
+
+			int treeNo = 1;
+			for(ITree<Node> ast : working) {
+				System.out.println("Tree " + treeNo++ + ": " + ast.toString());
+			}
+
+			return false;
+		} else {
+			Deque<ITree<Node>> childs = new LinkedList<>();
+
+			while(!working.peek().equals(matchNode)) {
+				childs.push(working.pop());
+			}
+
+			// Discard opener
+			working.pop();
+
+			for(ITree<Node> child : childs) {
+				groupNode.addChild(child);
+			}
+
+			working.push(groupNode);
+		}
+		
+		return true;
+	}
 }
diff --git a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
index 8755e19..383c7f3 100644
--- a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
@@ -41,8 +41,8 @@ public class StreamEngine {
 			} else {
 				if(tk.equals("{@SU}")) {
 					quoteMode = false;
-				} else if(tk.equals("\\{@SU}")) {
-					currStream.add("{@SU}");
+				} else if(tk.matches("\\\\+{@SU}")) {
+					currStream.add(tk.substring(1));
 				} else {
 					currStream.add(tk);
 				}
diff --git a/dice-lang/src/bjc/dicelang/v2/Token.java b/dice-lang/src/bjc/dicelang/v2/Token.java
index ed5ee8b..e5d3d9f 100644
--- a/dice-lang/src/bjc/dicelang/v2/Token.java
+++ b/dice-lang/src/bjc/dicelang/v2/Token.java
@@ -28,11 +28,7 @@ public class Token {
 		// Synthetic tokens
 		// These are produced when needed
 		NIL,      GROUPSEP, TOKGROUP,
-		TAGOP,    TAGOPR,
-
-		// Tag tokens
-		// These are used for the TAG* tokens
-
+		TAGOP,    TAGOPR
 	}
 
 	public final Type       type;
@@ -104,6 +100,8 @@ public class Token {
 			case DICE_LIT:
 				return type.toString() + "("
 					+ diceValue + ")";
+			case TAGOP:
+			case TAGOPR:
 			case TOKGROUP:
 				return type.toString() + "("
 					+ tokenValues + ")";