Lots of things, but mostly evaluation

10 files changed, 1158 insertions, 111 deletions

diff --git a/dice-lang/src/bjc/dicelang/v2/Define.java b/dice-lang/src/bjc/dicelang/v2/Define.java
index 6ca0c74..2ecbc69 100644
--- a/dice-lang/src/bjc/dicelang/v2/Define.java
+++ b/dice-lang/src/bjc/dicelang/v2/Define.java
@@ -23,7 +23,8 @@ public class Define implements UnaryOperator<String> {
 	private Iterator<String>  replacers;
 	private String replacer;
 
-	public Define(int priorty, boolean isSub, boolean recur,
+	public Define(int priorty,
+			boolean isSub, boolean recur, boolean isCircular,
 			String predicte, String searchr, Iterable<String> replacrs) {
 		priority = priorty;
 		doRecur  = recur;
@@ -36,7 +37,7 @@ public class Define implements UnaryOperator<String> {
 
 		if(subType) {
 			if(replacrs.iterator().hasNext()) {
-				replacers = new CircularIterator<>(replacrs);
+				replacers = new CircularIterator<>(replacrs, isCircular);
 			} else {
 				replacers = null;
 			}
@@ -79,8 +80,19 @@ public class Define implements UnaryOperator<String> {
 			StringBuffer sb = new StringBuffer();
 
 			while(searcherMatcher.find()) {
-				if(replacers == null) searcherMatcher.appendReplacement(sb,"");
-				else                  searcherMatcher.appendReplacement(sb, replacers.next());
+				if(replacers == null) {
+					System.out.println("\t\tTRACE: running null replacer  on substring "
+							+ tok.substring(searcherMatcher.start(), searcherMatcher.end()));
+
+					searcherMatcher.appendReplacement(sb,"");
+				} else {
+					String replac = replacers.next();
+
+					System.out.println("\t\tTRACE: running replacer " + replac + " on substring "
+							+ tok.substring(searcherMatcher.start(), searcherMatcher.end()));
+
+					searcherMatcher.appendReplacement(sb, replacers.next());
+				}
 			}
 			
 			searcherMatcher.appendTail(sb);
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java b/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
index 5460286..5731877 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
@@ -58,15 +58,28 @@ public class DiceLangConsole {
 	private boolean handlePragma(String pragma) {
 		System.out.println("\tRaw pragma: " + pragma);
 
-		switch(pragma.substring(0, pragma.indexOf(' '))) {
+		String pragmaName = null;
+		int firstIndex = pragma.indexOf(' ');
+		if(firstIndex == -1) {
+			pragmaName = pragma;
+		} else {
+			pragmaName = pragma.substring(0, firstIndex);
+		}
+
+		switch(pragmaName) {
 			case "debug":
 				System.out.println("\tDebug mode is now " + eng.toggleDebug());
 				break;
 			case "postfix":
 				System.out.println("\tPostfix mode is now " + eng.togglePostfix());
 				break;
+			case "prefix":
+				System.out.println("\tPrefix mode is now " + eng.togglePrefix());
+				break;
 			case "define":
 				return defineMode(pragma.substring(7));
+			case "help":
+				return helpMode(pragma.substring(5));
 			default:
 				System.out.println("\tERROR: Unknown pragma: " + pragma);
 				return false;
@@ -75,6 +88,19 @@ public class DiceLangConsole {
 		return true;
 	}
 	
+	private boolean helpMode(String pragma) {
+		switch(pragma.trim()) {
+			case "define":
+				System.out.println("\tdefine <priority> <type> <recursion> <guard> <circular> <patterns>...");
+				break;
+			default:
+				System.out.println("\tNo help available for pragma " + pragma);
+		}
+
+		// Help always works
+		return true;
+	}
+
 	/*
 	 * Matches slash-delimited strings
 	 * 		(like /text/ or /text\/text/)
@@ -87,7 +113,7 @@ public class DiceLangConsole {
 	 *		Then, we just follow the pattern, escape it for java strings, and
 	 *		add the enclosing slashes
 	 */
-	private Pattern slashPattern = Pattern.compile("/([^/\\\\]*(?:\\\\/(?:[^/\\\\])*)*)/");
+	private Pattern slashPattern = Pattern.compile("/((?:\\\\.|[^/\\\\])*)/");
 
 	private boolean defineMode(String defineText) {
 		int firstIndex    = defineText.indexOf(' ');
@@ -95,6 +121,7 @@ public class DiceLangConsole {
 		int thirdIndex    = defineText.indexOf(' ', secondIndex + 1);
 		int fourthIndex   = defineText.indexOf(' ', thirdIndex  + 1);
 		int fifthIndex    = defineText.indexOf(' ', fourthIndex + 1);
+		int sixthIndex    = defineText.indexOf(' ', fifthIndex + 1);
 
 		if(firstIndex == -1) {
 			System.out.println("\tERROR: Improperly formatted define (no priority)");
@@ -109,6 +136,9 @@ public class DiceLangConsole {
 			System.out.println("\tERROR: Improperly formatted define (no guard type)");
 			return false;
 		} else if(fifthIndex == -1) {
+			System.out.println("\tERROR: Improperly formatted define (no circularity)");
+			return false;
+		} else if(sixthIndex == -1) {
 			System.out.println("\tERROR: Improperly formatted define (no patterns)");
 			return false;
 		}
@@ -141,13 +171,14 @@ public class DiceLangConsole {
 				return false;
 		}
 
-		boolean doRecur = defineText.substring(secondIndex + 1, thirdIndex)
+		boolean doRecur    = defineText.substring(secondIndex + 1, thirdIndex)
+			.equalsIgnoreCase("true");
+		boolean hasGuard   = defineText.substring(thirdIndex + 1, fourthIndex)
+			.equalsIgnoreCase("true");
+		boolean isCircular = defineText.substring(thirdIndex + 1, fourthIndex)
 			.equalsIgnoreCase("true");
-		boolean hasGuard = defineText.substring(thirdIndex + 1, fourthIndex).
-			equalsIgnoreCase("true");
-
-		String pats = defineText.substring(fourthIndex + 1);
 
+		String pats = defineText.substring(fifthIndex + 1).trim();
 		Matcher patMatcher = slashPattern.matcher(pats);
 
 		String guardPattern = null;
@@ -171,7 +202,8 @@ public class DiceLangConsole {
 			replacePatterns.add(patMatcher.group(1));
 		}
 
-		Define dfn = new Define(priority, subMode, doRecur, guardPattern, searchPattern, replacePatterns);
+		Define dfn = new Define(priority, subMode, doRecur, isCircular,
+				guardPattern, searchPattern, replacePatterns);
 		
 		if(type == Define.Type.LINE) {
 			eng.addLineDefine(dfn);
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
index db471c2..5fbfb3a 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
@@ -1,7 +1,9 @@
 package bjc.dicelang.v2;
 
 import bjc.utils.data.IPair;
+import bjc.utils.data.ITree;
 import bjc.utils.data.Pair;
+import bjc.utils.data.Tree;
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.FunctionalMap;
 import bjc.utils.funcdata.FunctionalStringTokenizer;
@@ -33,9 +35,15 @@ public class DiceLangEngine {
 	private boolean debugMode;
 	// Should we do shunting?
 	private boolean postfixMode;
+	// Should we reverse the token stream
+	private boolean prefixMode;
 
 	// Shunter for token postfixing
 	private Shunter shunt;
+	// Parser for tree construction
+	private Parser parsr;
+	// Evaluator for evaluating
+	private Evaluator eval;
 
 	// Tables for symbols
 	private IMap<Integer, String> symTable;
@@ -51,6 +59,7 @@ public class DiceLangEngine {
 	// Are defns sorted by priority
 	private boolean defnsSorted;
 
+	// Stream engine for processing streams
 	private StreamEngine streamEng;
 
 	private final int MATH_PREC = 20;
@@ -67,13 +76,14 @@ public class DiceLangEngine {
 		
 		opExpansionList = new LinkedList<>();
 
-		opExpansionList.add(new Pair<>("+", "\\+"));
-		opExpansionList.add(new Pair<>("-", "-"));
-		opExpansionList.add(new Pair<>("*", "\\*"));
+		opExpansionList.add(new Pair<>("+",  "\\+"));
+		opExpansionList.add(new Pair<>("-",  "-"));
+		opExpansionList.add(new Pair<>("*",  "\\*"));
 		opExpansionList.add(new Pair<>("//", "//"));
-		opExpansionList.add(new Pair<>("/", "/"));
+		opExpansionList.add(new Pair<>("/",  "/"));
 		opExpansionList.add(new Pair<>(":=", ":="));
 		opExpansionList.add(new Pair<>("=>", "=>"));
+		opExpansionList.add(new Pair<>(",",  ","));
 
 		deaffixationList = new LinkedList<>();
 
@@ -81,6 +91,8 @@ public class DiceLangEngine {
 		deaffixationList.add(new Pair<>(")", "\\)"));
 		deaffixationList.add(new Pair<>("[", "\\["));
 		deaffixationList.add(new Pair<>("]", "\\]"));
+		deaffixationList.add(new Pair<>("{", "\\{"));
+		deaffixationList.add(new Pair<>("}", "}"));
 
 		litTokens = new FunctionalMap<>();
 
@@ -94,15 +106,19 @@ public class DiceLangEngine {
 		litTokens.put("dl", DICELIST);
 		litTokens.put("=>", LET);
 		litTokens.put(":=", BIND);
-
-		shunt = new Shunter();
+		litTokens.put(",",  GROUPSEP);
 
 		nextLiteral = 1;
 
 		debugMode   = true;
 		postfixMode = false;
+		prefixMode  = false;
 
 		streamEng = new StreamEngine(this);
+
+		shunt = new Shunter();
+		parsr = new Parser();
+		eval  = new Evaluator(this);
 	}
 
 	public void sortDefns() {
@@ -138,6 +154,12 @@ public class DiceLangEngine {
 		return postfixMode;
 	}
 
+	public boolean togglePrefix() {
+		prefixMode = !prefixMode;
+
+		return prefixMode;
+	}
+
 	/*
 	 * Matches quote-delimited strings
 	 * 		(like "text" or "text\"text")
@@ -150,7 +172,10 @@ public class DiceLangEngine {
 	 *		Then, we just follow the pattern, escape it for java strings, and
 	 *		add the enclosing quotes
 	 */
-	private Pattern quotePattern = Pattern.compile("\"([^\\\"]*(?:\\\"/(?:[^\\\"])*)*)\"");
+	private Pattern quotePattern = Pattern.compile("\"([^\\\"]*(?:\\\"(?:[^\\\"])*)*)\"");
+
+	// Similiar to the above, but using angle brackets instead of quotes and not allowing spaces
+	private Pattern nonExpandPattern = Pattern.compile("<([^\\>&&[^\\s]]*(?:\\>(?:[^\\>&&[^\\s]])*)*)>");
 
 	public boolean runCommand(String command) {
 		// Sort the defines if they aren't sorted
@@ -190,31 +215,59 @@ public class DiceLangEngine {
 
 		// Split the command into tokens
 		IList<String> tokens = FunctionalStringTokenizer
-			.fromString(destringedCommand.toString())
-			.toList();
+			.fromString(destringedCommand.toString()).toList();
 
 		if(debugMode) {
-			System.out.println("\tCommand after destringing: " + tokens.toString());
+			System.out.println("\tCommand after destringing: " + destringedCommand);
 
-			System.out.println("\tString literals in table");
+			if(stringLiterals.getSize() > 0) {
+				System.out.println("\tString literals in table");
 
-			stringLiterals.forEach((key, val) -> {
-				System.out.printf("\t\tName: (%s)\tValue: (%s)\n",
-					key, val);
-			});
+				stringLiterals.forEach((key, val) -> {
+					System.out.printf("\t\tName: (%s)\tValue: (%s)\n",
+						key, val);
+				});
+			}
 		}
 
+		IMap<String, String> nonExpandedTokens = new FunctionalMap<>();
+		
+		tokens = tokens.map(tk -> {
+			Matcher nonExpandMatcher = nonExpandPattern.matcher(tk);
+
+			if(nonExpandMatcher.matches()) {
+				String tkName = "nonExpandToken" + nextLiteral++;
+				nonExpandedTokens.put(tkName, nonExpandMatcher.group(1));
+
+				return tkName;
+			} else {
+				return tk;
+			}
+		});
+
+		System.out.println("\tCommand after removal of non-expanders: " + tokens.toString());
+
 		IList<String> semiExpandedTokens  = deaffixTokens(tokens, deaffixationList);
 		IList<String> fullyExpandedTokens = deaffixTokens(semiExpandedTokens, opExpansionList);
 
+		System.out.println("\tCommand after token expansion: " + fullyExpandedTokens.toString());
+
+		fullyExpandedTokens = fullyExpandedTokens.map(tk -> {
+			if(tk.startsWith("nonExpandToken")) {
+				return nonExpandedTokens.get(tk);
+			} else {
+				return tk;
+			}
+		});
+
 		if(debugMode) 
-			System.out.printf("\tCommand after token expansion: " 
+			System.out.printf("\tCommand after non-expander reinsertion: " 
 					+ fullyExpandedTokens.toString() + "\n");
 		
 
 		IList<Token> lexedTokens = new FunctionalList<>();
 
-		for(String token : fullyExpandedTokens.toIterable()) {
+		for(String token : fullyExpandedTokens) {
 			String newTok = token;
 
 			for(Define dfn : tokenDefns.toIterable()) {
@@ -233,15 +286,113 @@ public class DiceLangEngine {
 
 		IList<Token> shuntedTokens = lexedTokens;
 
-		if(!postfixMode) {
+		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) {
+					System.out.println("\tERROR: Encountered closing brace without matching open brace");
+					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(debugMode && !postfixMode)
+			System.out.printf("\tCommand after pre-shunter removal: %s\n", preparedTokens.toString());
+
+		if(!postfixMode && !prefixMode) {
 			shuntedTokens = new FunctionalList<>();
-			success       = shunt.shuntTokens(lexedTokens, shuntedTokens);
+			success       = shunt.shuntTokens(preparedTokens, shuntedTokens);
 			if(!success) return false;
+		} else if(prefixMode) {
+			preparedTokens.reverse();
+			shuntedTokens = preparedTokens.map(tk -> {
+				switch(tk.type) {
+					case OBRACE:
+						return new Token(CBRACE, tk.intValue);
+					case OPAREN:
+						return new Token(CPAREN, tk.intValue);
+					case OBRACKET:
+						return new Token(CBRACKET, tk.intValue);
+					case CBRACE:
+						return new Token(OBRACE, tk.intValue);
+					case CPAREN:
+						return new Token(OPAREN, tk.intValue);
+					case CBRACKET:
+						return new Token(OBRACKET, tk.intValue);
+					default:
+						return tk;
+				}
+			});
 		}
 
 		if(debugMode && !postfixMode)
 			System.out.printf("\tCommand after shunting: %s\n", shuntedTokens.toString());
 
+		IList<Token> readyTokens = shuntedTokens.flatMap(tk -> {
+			if(tk.type == Token.Type.TOKGROUP) {
+				return tk.tokenValues;
+			} else {
+				return new FunctionalList<>(tk);
+			}
+		});
+
+		if(debugMode && !postfixMode)
+			System.out.printf("\tCommand after re-preshunting: %s\n", readyTokens.toString());
+
+		IList<ITree<Node>> astForest = new FunctionalList<>();
+		success                      = parsr.parseTokens(readyTokens, astForest);
+
+		if(!success) return false;
+
+		if(debugMode) {
+			System.out.println("\tParsed forest of asts");
+			int treeNo = 1;
+
+			for(ITree<Node> ast : astForest) {
+				System.out.println("\t\tTree " + treeNo + " in forest:\n\t\t    " + ast);
+
+				System.out.println("\t\tEvaluates to " + eval.evaluate(ast));
+				treeNo += 1;
+			}
+		}
+
 		return true;
 	}
 
@@ -253,11 +404,13 @@ public class DiceLangEngine {
 		if(litTokens.containsKey(token)) {
 			tk = new Token(litTokens.get(token));
 		} else {
-			switch(token) {
-				case "(":
-				case ")":
-				case "[":
-				case "]":
+			switch(token.charAt(0)) {
+				case '(':
+				case ')':
+				case '[':
+				case ']':
+				case '{':
+				case '}':
 					   tk = tokenizeGrouping(token);
 					   break;
 				default:
@@ -272,19 +425,28 @@ public class DiceLangEngine {
 		Token tk = Token.NIL_TOKEN;
 
 		if(StringUtils.containsOnly(token, "\\" + token.charAt(0))) {
-			switch(token) {
-				case "(":
+			switch(token.charAt(0)) {
+				case '(':
 					tk = new Token(OPAREN, token.length());
 					break;
-				case ")":
+				case ')':
 					tk = new Token(CPAREN, token.length());
 					break;
-				case "[":
+				case '[':
 					tk = new Token(OBRACKET, token.length());
 					break;
-				case "]":
+				case ']':
 					tk = new Token(CBRACKET, token.length());
 					break;
+				case '{':
+					tk = new Token(OBRACE, token.length());
+					break;
+				case '}':
+					tk = new Token(CBRACE, token.length());
+					break;
+				default:
+					System.out.println("\tERROR: Unrecognized grouping token " + token);
+					break;
 			}
 		}
 
@@ -343,7 +505,7 @@ public class DiceLangEngine {
 	 private IList<String> deaffixTokens(IList<String> tokens, List<IPair<String, String>> deaffixTokens) {
 		Deque<String> working = new LinkedList<>();
 
-		for(String tk : tokens.toIterable()) {
+		for(String tk : tokens) {
 			working.add(tk);
 		}
 
@@ -359,7 +521,6 @@ public class DiceLangEngine {
 			Pattern opRegexEnding   = Pattern.compile(opRegex + "\\Z");
 
 			for(String tk : working) {
-				// @Incomplete
 				if(opRegexOnly.matcher(tk).matches()) {
 					// The string contains only the operator
 					newWorking.add(tk);
@@ -379,7 +540,6 @@ public class DiceLangEngine {
 
 					boolean startsWith = startMatcher.find();
 					boolean endsWith   = endMatcher.find();
-
 					boolean doSplit = medianMatcher.find();
 
 					medianMatcher.reset();
diff --git a/dice-lang/src/bjc/dicelang/v2/Evaluator.java b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
new file mode 100644
index 0000000..d9efbea
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
@@ -0,0 +1,262 @@
+package bjc.dicelang.v2;
+
+import bjc.utils.data.ITree;
+import bjc.utils.data.Tree;
+import bjc.utils.data.TopDownTransformResult;
+
+public class Evaluator {
+	public static class Result {
+		public static enum Type {
+			FAILURE,
+			INT, FLOAT, DICE
+		}
+
+		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 Result(Type typ) {
+			type = typ;
+		}
+
+		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 String toString() {
+			switch(type) {
+				case INT:
+					return type.toString() + "(" + intVal + ")";
+				case FLOAT:
+					return type.toString() + "(" + floatVal + ")";
+				case DICE:
+					return type.toString() + "(" + diceVal + ")";
+				case FAILURE:
+					return type.toString();
+				default:
+					return "Unknown result type " + type.toString();
+			}
+		}
+	}
+
+	private DiceLangEngine eng;
+
+	public Evaluator(DiceLangEngine en) {
+		eng = en;
+	}
+
+	public Result evaluate(ITree<Node> comm) {
+		return comm.topDownTransform(this::pickEvaluationType, this::evaluateNode).getHead().resultVal;
+	}
+
+	private TopDownTransformResult pickEvaluationType(Node nd) {
+		switch(nd.type) {
+			default:
+				return TopDownTransformResult.PUSHDOWN;
+		}
+	}
+
+	private ITree<Node> evaluateNode(ITree<Node> ast) {
+		switch(ast.getHead().type) {
+			case UNARYOP:
+				System.out.println("\tEVALUATOR ERROR: Unary operator evaluation isn't supported yet");
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+			case BINOP:
+				return evaluateBinaryOp(ast);
+			case TOKREF:
+				return evaluateTokenRef(ast.getHead().tokenVal);
+			default:
+				System.out.println("\tERROR: Unknown node in evaluator: " + ast.getHead().type);
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+		}
+	}
+
+	private ITree<Node> evaluateBinaryOp(ITree<Node> ast) {
+		Token.Type binOp = ast.getHead().operatorType;
+
+		if(ast.getChildrenCount() != 2) {
+			System.out.println("\tERROR: Binary operators only take two operands");
+			return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+		}
+
+		ITree<Node> left  = ast.getChild(0);
+		ITree<Node> right = ast.getChild(1);
+
+		switch(binOp) {
+			case ADD:
+			case SUBTRACT:
+			case MULTIPLY:
+			case DIVIDE:
+			case IDIVIDE:
+				return evaluateMathBinary(binOp, left.getHead().resultVal, right.getHead().resultVal);
+			default:
+				System.out.println("\tERROR: Unknown binary operator: " + binOp);
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+		}
+	}
+
+	private ITree<Node> evaluateMathBinary(Token.Type op, Result left, Result right) {
+		Result.Type resultType;
+
+		if(left.type == Result.Type.DICE || right.type == Result.Type.DICE) {
+			System.out.println("\tEVALUATOR ERROR: Math on dice isn't supported yet");
+		}
+
+		Result res = null;
+
+		switch(op) {
+			case ADD:
+				if(left.type == Result.Type.INT) {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.INT, left.intVal + right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.intVal + right.floatVal);
+					}
+				} else {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.FLOAT, left.floatVal + right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.floatVal + right.floatVal);
+					}
+				}
+				break;
+			case SUBTRACT:
+				if(left.type == Result.Type.INT) {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.INT, left.intVal - right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.intVal - right.floatVal);
+					}
+				} else {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.FLOAT, left.floatVal - right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.floatVal - right.floatVal);
+					}
+				}
+				break;
+			case MULTIPLY:
+				if(left.type == Result.Type.INT) {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.INT, left.intVal * right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.intVal * right.floatVal);
+					}
+				} else {
+					if(right.type == Result.Type.INT) {
+						res = new Result(Result.Type.FLOAT, left.floatVal * right.intVal);
+					} else {
+						res = new Result(Result.Type.FLOAT, left.floatVal * right.floatVal);
+					}
+				}
+				break;
+			case DIVIDE:
+				if(left.type == Result.Type.INT) {
+					if(right.type == Result.Type.INT) {
+						if(right.intVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.FLOAT, left.intVal / right.intVal);
+						}
+					} else {
+						if(right.floatVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.FLOAT, left.intVal / right.floatVal);
+						}
+					}
+				} else {
+					if(right.type == Result.Type.INT) {
+						if(right.intVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.FLOAT, left.floatVal / right.intVal);
+						}
+					} else {
+						if(right.floatVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.FLOAT, left.floatVal / right.floatVal);
+						}
+					}
+				}
+				break;
+			case IDIVIDE:
+				if(left.type == Result.Type.INT) {
+					if(right.type == Result.Type.INT) {
+						if(right.intVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.INT, (int) (left.intVal / right.intVal));
+						}
+					} else {
+						if(right.floatVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.INT, (int) (left.intVal / right.floatVal));
+						}
+					}
+				} else {
+					if(right.type == Result.Type.INT) {
+						if(right.intVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.INT, (int) (left.floatVal / right.intVal));
+						}
+					} else {
+						if(right.floatVal == 0) {
+							System.out.println("\tERROR: Attempted divide by zero");
+							res = new Result(Result.Type.FAILURE);
+						} else {
+							res = new Result(Result.Type.INT, (int) (left.floatVal / right.floatVal));
+						}
+					}
+				}
+				break;
+			default:
+				System.out.println("\tERROR: Unknown math binary operator: " + op);
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+		}
+
+		return new Tree<>(new Node(Node.Type.RESULT, res));
+	}
+
+	private ITree<Node> evaluateTokenRef(Token tk) {
+		switch(tk.type) {
+			case INT_LIT:
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.INT, tk.intValue)));
+			case FLOAT_LIT:
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FLOAT, tk.floatValue)));
+			case DICE_LIT:
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.DICE, tk.diceValue)));
+			default:
+				System.out.println("\tERROR: Unknown token ref: " + tk.type);
+				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+		}
+	}
+}
diff --git a/dice-lang/src/bjc/dicelang/v2/Node.java b/dice-lang/src/bjc/dicelang/v2/Node.java
new file mode 100644
index 0000000..bd191d2
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/Node.java
@@ -0,0 +1,82 @@
+package bjc.dicelang.v2;
+
+public class Node {
+	public static enum Type {
+		 ROOT,    TOKREF,
+		 UNARYOP, BINOP,
+		 GROUP,   OGROUP,
+		 RESULT
+	}
+
+	public static enum GroupType {
+		ARRAY, CODE
+	}
+
+	public final Type type;
+
+	// These can have or not have values based of the node type
+	public Token      		tokenVal;
+	public Token.Type 		operatorType;
+	public GroupType 		groupType;
+	public Evaluator.Result resultVal;
+
+	public Node(Type typ) {
+		type = typ;
+	}
+
+	public Node(Type typ, Token tokenVl) {
+		this(typ);
+
+		tokenVal = tokenVl;
+	}
+
+	public Node(Type typ, Token.Type opType) {
+		this(typ);
+
+		operatorType = opType;
+	}
+
+	public Node(Type typ, GroupType grupType) {
+		this(typ);
+
+		groupType = grupType;
+	}
+
+	public Node(Type typ, Evaluator.Result res) {
+		this(typ);
+
+		resultVal = res;
+	}
+
+	public String toString() {
+		switch(type) {
+			case UNARYOP:
+			case BINOP:
+				return "(" + type.name() + " : " + operatorType + ")";
+			case OGROUP:
+			case TOKREF:
+				return "(" + type.name() + " : " + tokenVal     + ")";
+			case GROUP:
+				return "(" + type.name() + " : " + groupType    + ")";
+			case RESULT:
+				return "(" + type.name() + " : " + resultVal    + ")";
+			default:
+				return "Unknown node type " + type;
+		}
+	}
+
+	public boolean equals(Object other) {
+		if(!(other instanceof Node)) return false;
+
+		Node otk = (Node)other;
+
+		if(otk.type != type) return false;
+
+		switch(type) {
+			case OGROUP:
+				return tokenVal.equals(otk.tokenVal);
+			default:
+				return true;
+		}
+	}
+}
diff --git a/dice-lang/src/bjc/dicelang/v2/Parser.java b/dice-lang/src/bjc/dicelang/v2/Parser.java
new file mode 100644
index 0000000..0e778b4
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/Parser.java
@@ -0,0 +1,147 @@
+package bjc.dicelang.v2;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+import bjc.utils.data.ITree;
+import bjc.utils.data.Tree;
+import bjc.utils.funcdata.IList;
+
+import static bjc.dicelang.v2.Node.Type.*;
+import static bjc.dicelang.v2.Token.Type.*;
+
+public class Parser {
+	public Parser() {
+
+	}
+
+	public boolean parseTokens(IList<Token> tokens,
+			IList<ITree<Node>> results) {
+		Deque<ITree<Node>> working = new LinkedList<>();
+
+		for(Token tk : tokens) {
+			switch(tk.type) {
+				case OBRACKET:
+				case OBRACE:
+					working.push(new Tree<>(new Node(OGROUP, tk)));
+					break;
+				case CBRACKET:
+				case CBRACE:
+					if(working.size() == 0) {
+						System.out.println("\tERROR: Group closing with no possible group opener");
+						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)) {
+						System.out.println("\tERROR: Found group closing without group opener: (closing was " + tk + ", matcher was "
+								+ matchNode + ")");
+
+						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);
+					}
+					break;
+				case LET:
+				case BIND:
+					if(working.size() < 2) {
+						System.out.println("\tERROR: Let and bind require at least two operands");
+					} else {
+						ITree<Node> right = working.pop();
+						ITree<Node> left  = working.pop();
+
+						ITree<Node> opNode = new Tree<>(new Node(BINOP, tk.type));
+						
+						working.push(opNode);
+					}
+					break;
+				case ADD:
+				case SUBTRACT:
+				case MULTIPLY:
+				case DIVIDE:
+				case IDIVIDE:
+				case DICEGROUP:
+				case DICECONCAT:
+				case DICELIST:
+					if(working.size() == 0) {
+						System.out.println("\tERROR: Binary operator " + tk.type + " requires more operands than provided.");
+						return false;
+					} else if(working.size() == 1) {
+						ITree<Node> operand = working.pop();
+
+						ITree<Node> opNode  = new Tree<>(new Node(UNARYOP, tk.type));
+						
+						opNode.addChild(operand);
+
+						working.push(opNode);
+					} else {
+						ITree<Node> right = working.pop();
+						ITree<Node> left  = working.pop();
+
+						ITree<Node> opNode = new Tree<>(new Node(BINOP, tk.type));
+						
+						opNode.addChild(left);
+						opNode.addChild(right);
+
+						working.push(opNode);
+					}
+					break;
+				case INT_LIT:
+				case FLOAT_LIT:
+				case STRING_LIT:
+				case VREF:
+				case DICE_LIT:
+					working.push(new Tree<>(new Node(TOKREF, tk)));
+					break;
+				default:
+					System.out.println("\tERROR: Unrecognized token type in parsing: " + tk.type);
+					return false;
+			}
+		}
+
+		for(ITree<Node> ast : working) {
+			results.add(ast);
+		}
+
+		return true;
+	}
+}
diff --git a/dice-lang/src/bjc/dicelang/v2/Shunter.java b/dice-lang/src/bjc/dicelang/v2/Shunter.java
index b0a822a..7e17e6f 100644
--- a/dice-lang/src/bjc/dicelang/v2/Shunter.java
+++ b/dice-lang/src/bjc/dicelang/v2/Shunter.java
@@ -25,9 +25,9 @@ public class Shunter {
 	// applied to operator tokens
 	private Set<Token.Type> unaryAdverbs;
 
-	private final int MATH_PREC	= 20;
-	private final int DICE_PREC	= 10;
-	private final int EXPR_PREC	= 0;
+	private final int MATH_PREC	 = 20;
+	private final int DICE_PREC	 = 10;
+	private final int EXPR_PREC	 = 0;
 
 	public Shunter() {
 		ops = new FunctionalMap<>();
@@ -53,12 +53,13 @@ public class Shunter {
 	public boolean shuntTokens(IList<Token> tks, IList<Token> returned) {
 		Deque<Token> opStack    = new LinkedList<>();
 
-		boolean unaryMode          = false;
+		boolean unaryMode     = false;
 		Deque<Token> unaryOps = new LinkedList<>();
 
+		Deque<Token> currReturned = new LinkedList<>();
+
 		for(Token tk : tks.toIterable()) {
 			if(unaryMode) {
-				// @TODO finish unary mode
 				if(unaryAdjectives.contains(tk.type) || unaryAdverbs.contains(tk.type)) {
 					unaryOps.push(tk);
 					continue;
@@ -79,8 +80,8 @@ public class Shunter {
 						return false;
 					}
 
-					returned.add(tk);
-					returned.add(unaryOps.pop());
+					currReturned.addLast(tk);
+					currReturned.addLast(unaryOps.pop());
 				} else if (unaryAdverbs.contains(currOperator.type)) {
 					if(opStack.size() < 1) {
 						System.out.printf("\tError: Unary operators %s is an adverb,"
@@ -101,8 +102,8 @@ public class Shunter {
 						return false;
 					}
 
-					returned.add(tk);
-					returned.add(unaryOps.pop());
+					currReturned.addLast(tk);
+					currReturned.addLast(unaryOps.pop());
 				}
 
 				if(unaryOps.isEmpty()) unaryMode = false;
@@ -115,34 +116,75 @@ public class Shunter {
 				} else if(ops.containsKey(tk.type)) {
 					while(!opStack.isEmpty() 
 							&& isHigherPrec(tk.type, opStack.peek().type)) {
-						returned.add(opStack.pop());
+						currReturned.addLast(opStack.pop());
 					}
 
 					opStack.push(tk);
-				} else if(tk.type == OPAREN) {
+				} else if(tk.type == OPAREN || tk.type == OBRACE) {
 					opStack.push(tk);
-				} else if(tk.type == CPAREN) {
-					Token currTk = opStack.peek();
 
-					while(currTk.type != OPAREN && currTk.intValue != tk.intValue) {
-						if(opStack.isEmpty()) {
-							System.out.printf("\tError: Could not find matching parenthesis"
-								+ " with matching level %d\n", tk.intValue);
+					if(tk.type == OBRACE)
+						currReturned.addLast(tk);
+				} else if(tk.type == CPAREN || tk.type == CBRACE) {
+					Token matching = null;
+
+					switch(tk.type) {
+						case CPAREN:
+							matching = new Token(OPAREN, tk.intValue);
+							break;
+						case CBRACE:
+							matching = new Token(OBRACE, tk.intValue);
+							break;
+						default:
+							break;
+					}
+
+					if(!opStack.contains(matching)) {
+						System.out.printf("\tError: Could not find matching grouping "
+								+ tk.type);
+
+						return false;
+					}
+
+					while(!opStack.peek().equals(matching)) {
+						currReturned.addLast(opStack.pop());
+					}
+
+					if(tk.type == CBRACE) {
+						currReturned.addLast(tk);
+					}
+
+					opStack.pop();
+				} else if(tk.type == GROUPSEP) {
+					IList<Token> group = new FunctionalList<>();
 
-							return false;
-						}
+					while(currReturned.size() != 0 && !currReturned.peek().isGrouper()) {
+						group.add(currReturned.pop());
+					}
 
-						returned.add(opStack.pop());
+					while(opStack.size() != 0 && !opStack.peek().isGrouper()) {
+						group.add(opStack.pop());
 					}
+
+					if(currReturned.size() == 0) {
+						System.out.println("\tERROR: Didn't find grouper for group seperator to attach to");
+						return false;
+					}
+
+					currReturned.addLast(new Token(TOKGROUP, group));
 				} else {
-					returned.add(tk);
+					currReturned.addLast(tk);
 				}
 			}
 		}
 
 		// Flush leftover operators
 		while(!opStack.isEmpty()) {
-			returned.add(opStack.pop());
+			currReturned.addLast(opStack.pop());
+		}
+
+		for(Token tk : currReturned) {
+			returned.add(tk);
 		}
 
 		return true;
diff --git a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
index afd4bc1..39bbc0d 100644
--- a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
@@ -11,23 +11,29 @@ public class StreamEngine {
 	private Tape<IList<String>> streams;
 	private IList<String>       currStream;
 
-	public StreamEngine(DiceLangEngine eng) {
+	public StreamEngine(DiceLangEngine engine) {
+		eng = engine;
+	}
+
+	private void init() {
 		streams = new SingleTape<>();
 
 		currStream = new FunctionalList<>();
-		streams.append(currStream);
+		streams.insertBefore(currStream);
 	}
 
 	public boolean doStreams(String[] toks, IList<String> dest) {
+		init();
+
 		for(String tk : toks) {
-			if(tk.startsWith("{@")) {
+			if(tk.startsWith("{@S")) {
 				if(!processCommand(tk)) return false;
 			} else {
 				currStream.add(tk);
 			}
 		}
 
-		for(String tk : currStream.toIterable()) {
+		for(String tk : currStream) {
 			dest.add(tk);
 		}
 
@@ -35,38 +41,49 @@ public class StreamEngine {
 	}
 
 	private boolean processCommand(String tk) {
-		switch(tk.charAt(2)) {
-			case '+':
-				streams.add(new FunctionalList<>());
-				break;
-			case '>':
-				if(!streams.right()) {
-					System.out.println("\tERROR: Attempted to switch to non-existent stream");
-					return false;
-				}
+		char[] comms = null;
 
-				currStream = streams.item();
-				break;
-			case '<':
-				if(!streams.left()) {
-					System.out.println("\tERROR: Attempted to switch to non-existent stream");
-					return false;
-				}
+		if(tk.length() > 5) {
+			comms = tk.substring(3, tk.length() - 1).toCharArray();
+		} else {
+			comms = new char[1];
+			comms[0] = tk.charAt(3);
+		}
+
+		for(char comm : comms) {
+			switch(comm) {
+				case '+':
+					streams.insertAfter(new FunctionalList<>());
+					break;
+				case '>':
+					if(!streams.right()) {
+						System.out.println("\tERROR: Attempted to switch to non-existent stream");
+						return false;
+					}
+
+					currStream = streams.item();
+					break;
+				case '<':
+					if(!streams.left()) {
+						System.out.println("\tERROR: Attempted to switch to non-existent stream");
+						return false;
+					}
 
-				currStream = streams.item();
-				break;
-			case '-':
-				if(streams.size() == 1) {
-					System.out.println("\tERROR: Cannot delete last stream");
-					return false;
-				} else {
-					streams.remove();
 					currStream = streams.item();
-				}
-				break;
-			default:
-				System.out.println("\tERROR: Unknown stream control command: " + tk);
-				return false;
+					break;
+				case '-':
+					if(streams.size() == 1) {
+						System.out.println("\tERROR: Cannot delete last stream");
+						return false;
+					} else {
+						streams.remove();
+						currStream = streams.item();
+					}
+					break;
+				default:
+					System.out.println("\tERROR: Unknown stream control command: " + tk);
+					return false;
+			}
 		}
 
 		return true;
diff --git a/dice-lang/src/bjc/dicelang/v2/Token.java b/dice-lang/src/bjc/dicelang/v2/Token.java
index 9825dae..e6f22a5 100644
--- a/dice-lang/src/bjc/dicelang/v2/Token.java
+++ b/dice-lang/src/bjc/dicelang/v2/Token.java
@@ -1,5 +1,7 @@
 package bjc.dicelang.v2;
 
+import bjc.utils.funcdata.IList;
+
 /**
  * Lexer token
  */
@@ -10,25 +12,33 @@ public class Token {
 	 * Possible token types
 	 */
 	public static enum Type {
-		ADD, SUBTRACT,
-		MULTIPLY, 
-		DIVIDE, IDIVIDE,
-		INT_LIT, FLOAT_LIT, STRING_LIT,
+		// Natural tokens
+		// These are produced from lexemes
+		ADD,      SUBTRACT,
+		MULTIPLY,
+		DIVIDE,   IDIVIDE,
+		INT_LIT,  FLOAT_LIT, STRING_LIT,
 		VREF,
 		DICE_LIT, DICEGROUP, DICECONCAT, DICELIST,
-		LET, BIND,
-		OPAREN, CPAREN,
+		LET,      BIND,
+		OPAREN,   CPAREN,
 		OBRACKET, CBRACKET,
-		NIL,
+		OBRACE,   CBRACE,
+		// Synthetic tokens
+		// These are produced when needed
+		NIL,      PRESHUNT,  GROUPSEP,
+		TOKGROUP
 	}
 
 	public final Type type;
 
 	// At most one of these is valid
 	// based on the token type
-	public long intValue;
-	public double floatValue;
+	public long 				 intValue;
+	public double 				 floatValue;
+	public String 				 stringValue;
 	public DiceBox.DieExpression diceValue;
+	public IList<Token>          tokenValues;
 
 	public Token(Type typ) {
 		type = typ;
@@ -46,12 +56,24 @@ public class Token {
 		floatValue = val;
 	}
 
+	public Token(Type typ, String val) {
+		this(typ);
+
+		stringValue = val;
+	}
+
 	public Token(Type typ, DiceBox.DieExpression val) {
 		this(typ);
 
 		diceValue = val;
 	}
 
+	public Token(Type typ, IList<Token> tkVals) {
+		this(typ);
+
+		tokenValues = tkVals;
+	}
+
 	public String toString() {
 		switch(type) {
 			case INT_LIT:
@@ -61,6 +83,8 @@ public class Token {
 			case CPAREN:
 			case OBRACKET:
 			case CBRACKET:
+			case OBRACE:
+			case CBRACE:
 				return type.toString() + "("
 					+ intValue + ")";
 			case FLOAT_LIT:
@@ -69,8 +93,38 @@ public class Token {
 			case DICE_LIT:
 				return type.toString() + "("
 					+ diceValue + ")";
+			case TOKGROUP:
+				return type.toString() + "("
+					+ tokenValues + ")";
 			default:
 				return type.toString();
 		}
 	}
+
+	public boolean equals(Object other) {
+		if(!(other instanceof Token)) return false;
+
+		Token otk = (Token)other;
+
+		if(otk.type != type) return false;
+
+		switch(type) {
+			case OBRACE:
+			case OBRACKET:
+				return intValue == otk.intValue;
+			default:
+				return true;
+		}
+	}
+
+	public boolean isGrouper() {
+		switch(type) {
+			case OPAREN:
+			case OBRACE:
+			case OBRACKET:
+				return true;
+			default:
+				return false;
+		}
+	}
 }
diff --git a/dice-lang/tags b/dice-lang/tags
index 89199b0..6b1a426 100644
--- a/dice-lang/tags
+++ b/dice-lang/tags
@@ -6,9 +6,11 @@
 !_TAG_PROGRAM_VERSION	5.9~svn20110310	//
 ADD	src/bjc/dicelang/DiceExpressionType.java	/^	ADD,$/;"	e	enum:DiceExpressionType	file:
 ADD	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	ADD(MATH),$/;"	e	enum:OperatorDiceNode	file:
+ADD	src/bjc/dicelang/v2/Token.java	/^		ADD,      SUBTRACT,$/;"	e	enum:Token.Type	file:
 ARRAY	src/bjc/dicelang/ast/ResultType.java	/^	ARRAY,$/;"	e	enum:ResultType	file:
 ARRAY	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^	ARRAY,$/;"	e	enum:DiceOperatorType	file:
 ARRAY	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	ARRAY(DiceOperatorType.ARRAY),$/;"	e	enum:OperatorDiceNode	file:
+ARRAY	src/bjc/dicelang/v2/Node.java	/^		ARRAY, CODE$/;"	e	enum:Node.GroupType	file:
 ASSIGN	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	ASSIGN(EXPRESSION),$/;"	e	enum:OperatorDiceNode	file:
 ArithmeticCollapser	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	public ArithmeticCollapser(OperatorDiceNode type,$/;"	m	class:ArithmeticCollapser
 ArithmeticCollapser	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^final class ArithmeticCollapser implements IOperatorCollapser {$/;"	c
@@ -16,10 +18,16 @@ ArithmeticCollapser	src/bjc/dicelang/ast/optimization/ArithmeticCollapser.java	/
 ArithmeticCollapser	src/bjc/dicelang/ast/optimization/ArithmeticCollapser.java	/^class ArithmeticCollapser {$/;"	c
 ArrayResult	src/bjc/dicelang/ast/ArrayResult.java	/^	public ArrayResult(IList<IResult> results) {$/;"	m	class:ArrayResult
 ArrayResult	src/bjc/dicelang/ast/ArrayResult.java	/^public class ArrayResult implements IResult {$/;"	c
+BIND	src/bjc/dicelang/v2/Token.java	/^		LET,      BIND,$/;"	e	enum:Token.Type	file:
+BINOP	src/bjc/dicelang/v2/Node.java	/^		 UNARYOP, BINOP,$/;"	e	enum:Node.Type	file:
 BindingDiceExpression	src/bjc/dicelang/BindingDiceExpression.java	/^	public BindingDiceExpression(IDiceExpression left,$/;"	m	class:BindingDiceExpression
 BindingDiceExpression	src/bjc/dicelang/BindingDiceExpression.java	/^	public BindingDiceExpression(String name, IDiceExpression expression,$/;"	m	class:BindingDiceExpression
 BindingDiceExpression	src/bjc/dicelang/BindingDiceExpression.java	/^public class BindingDiceExpression implements IDiceExpression {$/;"	c
+CBRACE	src/bjc/dicelang/v2/Token.java	/^		OBRACE,   CBRACE,$/;"	e	enum:Token.Type	file:
+CBRACKET	src/bjc/dicelang/v2/Token.java	/^		OBRACKET, CBRACKET,$/;"	e	enum:Token.Type	file:
+CODE	src/bjc/dicelang/v2/Node.java	/^		ARRAY, CODE$/;"	e	enum:Node.GroupType	file:
 COMPOUND	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	COMPOUND(DICE),$/;"	e	enum:OperatorDiceNode	file:
+CPAREN	src/bjc/dicelang/v2/Token.java	/^		OPAREN,   CPAREN,$/;"	e	enum:Token.Type	file:
 ComplexDice	src/bjc/dicelang/ComplexDice.java	/^	public ComplexDice(IDiceExpression nDce, IDiceExpression de) {$/;"	m	class:ComplexDice
 ComplexDice	src/bjc/dicelang/ComplexDice.java	/^	public ComplexDice(int nSides, int de) {$/;"	m	class:ComplexDice
 ComplexDice	src/bjc/dicelang/ComplexDice.java	/^public class ComplexDice implements IDiceExpression {$/;"	c
@@ -27,13 +35,25 @@ CompoundDice	src/bjc/dicelang/CompoundDice.java	/^	public CompoundDice(IDiceExpr
 CompoundDice	src/bjc/dicelang/CompoundDice.java	/^	public CompoundDice(String lft, String rght) {$/;"	m	class:CompoundDice
 CompoundDice	src/bjc/dicelang/CompoundDice.java	/^	public CompoundDice(String[] exps) {$/;"	m	class:CompoundDice
 CompoundDice	src/bjc/dicelang/CompoundDice.java	/^public class CompoundDice implements IDiceExpression {$/;"	c
+CompoundDie	src/bjc/dicelang/v2/DiceBox.java	/^		public CompoundDie(Die lft, Die rght) {$/;"	m	class:DiceBox.CompoundDie
+CompoundDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static class CompoundDie implements Die {$/;"	c	class:DiceBox
 ConstantCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^public class ConstantCollapser implements IOptimizationPass {$/;"	c
 DICE	src/bjc/dicelang/ast/nodes/DiceLiteralType.java	/^	DICE;$/;"	e	enum:DiceLiteralType	file:
 DICE	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^	DICE,$/;"	e	enum:DiceOperatorType	file:
+DICE	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE$/;"	e	enum:Evaluator.Result.Type	file:
+DICECONCAT	src/bjc/dicelang/v2/Token.java	/^		DICE_LIT, DICEGROUP, DICECONCAT, DICELIST,$/;"	e	enum:Token.Type	file:
+DICEGROUP	src/bjc/dicelang/v2/Token.java	/^		DICE_LIT, DICEGROUP, DICECONCAT, DICELIST,$/;"	e	enum:Token.Type	file:
+DICELIST	src/bjc/dicelang/v2/Token.java	/^		DICE_LIT, DICEGROUP, DICECONCAT, DICELIST,$/;"	e	enum:Token.Type	file:
+DICE_LIT	src/bjc/dicelang/v2/Token.java	/^		DICE_LIT, DICEGROUP, DICECONCAT, DICELIST,$/;"	e	enum:Token.Type	file:
 DICE_PREC	src/bjc/dicelang/examples/DiceExpressionPreparer.java	/^	private static final int			DICE_PREC	= 10;$/;"	f	class:DiceExpressionPreparer	file:
+DICE_PREC	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private final int DICE_PREC = 10;$/;"	f	class:DiceLangEngine	file:
+DICE_PREC	src/bjc/dicelang/v2/Shunter.java	/^	private final int DICE_PREC	 = 10;$/;"	f	class:Shunter	file:
 DIVIDE	src/bjc/dicelang/DiceExpressionType.java	/^	DIVIDE,$/;"	e	enum:DiceExpressionType	file:
 DIVIDE	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	DIVIDE(MATH),$/;"	e	enum:OperatorDiceNode	file:
+DIVIDE	src/bjc/dicelang/v2/Token.java	/^		DIVIDE,   IDIVIDE,$/;"	e	enum:Token.Type	file:
 DUMMY	src/bjc/dicelang/ast/ResultType.java	/^	DUMMY$/;"	e	enum:ResultType	file:
+Define	src/bjc/dicelang/v2/Define.java	/^	public Define(int priorty,$/;"	m	class:Define
+Define	src/bjc/dicelang/v2/Define.java	/^public class Define implements UnaryOperator<String> {$/;"	c
 DiceASTEvaluator	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^public class DiceASTEvaluator {$/;"	c
 DiceASTInliner	src/bjc/dicelang/ast/DiceASTInliner.java	/^public class DiceASTInliner {$/;"	c
 DiceASTLanguageTest	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^public class DiceASTLanguageTest {$/;"	c
@@ -46,6 +66,7 @@ DiceASTReferenceChecker	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^publ
 DiceASTReferenceSanitizer	src/bjc/dicelang/ast/DiceASTReferenceSanitizer.java	/^public class DiceASTReferenceSanitizer {$/;"	c
 DiceASTType	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^public enum DiceASTType {$/;"	g
 DiceASTUtils	src/bjc/dicelang/ast/DiceASTUtils.java	/^public class DiceASTUtils {$/;"	c
+DiceBox	src/bjc/dicelang/v2/DiceBox.java	/^public class DiceBox {$/;"	c
 DiceExpressionBuilder	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder(IDiceExpression seed) {$/;"	m	class:DiceExpressionBuilder
 DiceExpressionBuilder	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder(int nSides, int nDice) {$/;"	m	class:DiceExpressionBuilder
 DiceExpressionBuilder	src/bjc/dicelang/DiceExpressionBuilder.java	/^public class DiceExpressionBuilder {$/;"	c
@@ -67,16 +88,38 @@ DiceLiteralType	src/bjc/dicelang/ast/nodes/DiceLiteralType.java	/^public enum Di
 DiceOperatorType	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^public enum DiceOperatorType {$/;"	g
 Die	src/bjc/dicelang/Die.java	/^	public Die(int nSides) {$/;"	m	class:Die
 Die	src/bjc/dicelang/Die.java	/^public class Die implements IDiceExpression {$/;"	c
+Die	src/bjc/dicelang/v2/DiceBox.java	/^	public interface Die {$/;"	i	class:DiceBox
+DieExpression	src/bjc/dicelang/v2/DiceBox.java	/^		public DieExpression(Die scal) {$/;"	m	class:DiceBox.DieExpression
+DieExpression	src/bjc/dicelang/v2/DiceBox.java	/^		public DieExpression(DieList lst) {$/;"	m	class:DiceBox.DieExpression
+DieExpression	src/bjc/dicelang/v2/DiceBox.java	/^	public static class DieExpression {$/;"	c	class:DiceBox
+DieList	src/bjc/dicelang/v2/DiceBox.java	/^	public interface DieList {$/;"	i	class:DiceBox
+Digits	src/bjc/dicelang/v2/DoubleMatcher.java	/^	private static final String Digits =$/;"	f	class:DoubleMatcher	file:
+DoubleMatcher	src/bjc/dicelang/v2/DoubleMatcher.java	/^public class DoubleMatcher {$/;"	c
 DummyResult	src/bjc/dicelang/ast/DummyResult.java	/^	public DummyResult(String data) {$/;"	m	class:DummyResult
 DummyResult	src/bjc/dicelang/ast/DummyResult.java	/^public class DummyResult implements IResult {$/;"	c
 EXPRESSION	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^	EXPRESSION;$/;"	e	enum:DiceOperatorType	file:
 EXPR_PREC	src/bjc/dicelang/examples/DiceExpressionPreparer.java	/^	private static final int			EXPR_PREC	= 0;$/;"	f	class:DiceExpressionPreparer	file:
+EXPR_PREC	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private final int EXPR_PREC = 0;$/;"	f	class:DiceLangEngine	file:
+EXPR_PREC	src/bjc/dicelang/v2/Shunter.java	/^	private final int EXPR_PREC	 = 0;$/;"	f	class:Shunter	file:
+Evaluator	src/bjc/dicelang/v2/Evaluator.java	/^	public Evaluator(DiceLangEngine en) {$/;"	m	class:Evaluator
+Evaluator	src/bjc/dicelang/v2/Evaluator.java	/^public class Evaluator {$/;"	c
+Exp	src/bjc/dicelang/v2/DoubleMatcher.java	/^	private static final String Exp =$/;"	f	class:DoubleMatcher	file:
+FAILURE	src/bjc/dicelang/v2/Evaluator.java	/^			FAILURE,$/;"	e	enum:Evaluator.Result.Type	file:
+FLOAT	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE$/;"	e	enum:Evaluator.Result.Type	file:
+FLOAT_LIT	src/bjc/dicelang/v2/Token.java	/^		INT_LIT,  FLOAT_LIT, STRING_LIT,$/;"	e	enum:Token.Type	file:
 GROUP	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	GROUP(DICE),$/;"	e	enum:OperatorDiceNode	file:
+GROUP	src/bjc/dicelang/v2/Node.java	/^		 GROUP,   OGROUP,$/;"	e	enum:Node.Type	file:
+GROUPSEP	src/bjc/dicelang/v2/Token.java	/^		NIL,      PRESHUNT,  GROUPSEP,$/;"	e	enum:Token.Type	file:
+GroupType	src/bjc/dicelang/v2/Node.java	/^	public static enum GroupType {$/;"	g	class:Node
+HexDigits	src/bjc/dicelang/v2/DoubleMatcher.java	/^	private static final String HexDigits =$/;"	f	class:DoubleMatcher	file:
+IDIVIDE	src/bjc/dicelang/v2/Token.java	/^		DIVIDE,   IDIVIDE,$/;"	e	enum:Token.Type	file:
 IDiceASTNode	src/bjc/dicelang/ast/nodes/IDiceASTNode.java	/^public interface IDiceASTNode {$/;"	i
 IDiceExpression	src/bjc/dicelang/IDiceExpression.java	/^public interface IDiceExpression {$/;"	i
 ILiteralDiceNode	src/bjc/dicelang/ast/nodes/ILiteralDiceNode.java	/^public interface ILiteralDiceNode extends IDiceASTNode {$/;"	i
+INT	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE$/;"	e	enum:Evaluator.Result.Type	file:
 INTEGER	src/bjc/dicelang/ast/ResultType.java	/^	INTEGER,$/;"	e	enum:ResultType	file:
 INTEGER	src/bjc/dicelang/ast/nodes/DiceLiteralType.java	/^	INTEGER,$/;"	e	enum:DiceLiteralType	file:
+INT_LIT	src/bjc/dicelang/v2/Token.java	/^		INT_LIT,  FLOAT_LIT, STRING_LIT,$/;"	e	enum:Token.Type	file:
 IOperatorCollapser	src/bjc/dicelang/ast/IOperatorCollapser.java	/^public interface IOperatorCollapser extends$/;"	i
 IOptimizationPass	src/bjc/dicelang/ast/optimization/IOptimizationPass.java	/^public interface IOptimizationPass {$/;"	i
 IResult	src/bjc/dicelang/ast/IResult.java	/^public interface IResult {$/;"	i
@@ -85,26 +128,81 @@ IntegerLiteralNode	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^public c
 IntegerResult	src/bjc/dicelang/ast/IntegerResult.java	/^	public IntegerResult(int val) {$/;"	m	class:IntegerResult
 IntegerResult	src/bjc/dicelang/ast/IntegerResult.java	/^public class IntegerResult implements IResult {$/;"	c
 LET	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	LET(EXPRESSION);$/;"	e	enum:OperatorDiceNode	file:
+LET	src/bjc/dicelang/v2/Token.java	/^		LET,      BIND,$/;"	e	enum:Token.Type	file:
+LINE	src/bjc/dicelang/v2/Define.java	/^		LINE, TOKEN$/;"	e	enum:Define.Type	file:
 LITERAL	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^	LITERAL,$/;"	e	enum:DiceASTType	file:
 MATH	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^	MATH,$/;"	e	enum:DiceOperatorType	file:
 MATH_PREC	src/bjc/dicelang/examples/DiceExpressionPreparer.java	/^	private static final int			MATH_PREC	= 20;$/;"	f	class:DiceExpressionPreparer	file:
+MATH_PREC	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private final int MATH_PREC = 20;$/;"	f	class:DiceLangEngine	file:
+MATH_PREC	src/bjc/dicelang/v2/Shunter.java	/^	private final int MATH_PREC	 = 20;$/;"	f	class:Shunter	file:
 MULTIPLY	src/bjc/dicelang/DiceExpressionType.java	/^	MULTIPLY,$/;"	e	enum:DiceExpressionType	file:
 MULTIPLY	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	MULTIPLY(MATH),$/;"	e	enum:OperatorDiceNode	file:
+MULTIPLY	src/bjc/dicelang/v2/Token.java	/^		MULTIPLY,$/;"	e	enum:Token.Type	file:
+NIL	src/bjc/dicelang/v2/Token.java	/^		NIL,      PRESHUNT,  GROUPSEP,$/;"	e	enum:Token.Type	file:
+NIL_TOKEN	src/bjc/dicelang/v2/Token.java	/^	public final static Token NIL_TOKEN = new Token(Type.NIL);$/;"	f	class:Token
+Node	src/bjc/dicelang/v2/Node.java	/^	public Node(Type typ) {$/;"	m	class:Node
+Node	src/bjc/dicelang/v2/Node.java	/^	public Node(Type typ, Evaluator.Result res) {$/;"	m	class:Node
+Node	src/bjc/dicelang/v2/Node.java	/^	public Node(Type typ, GroupType grupType) {$/;"	m	class:Node
+Node	src/bjc/dicelang/v2/Node.java	/^	public Node(Type typ, Token tokenVl) {$/;"	m	class:Node
+Node	src/bjc/dicelang/v2/Node.java	/^	public Node(Type typ, Token.Type opType) {$/;"	m	class:Node
+Node	src/bjc/dicelang/v2/Node.java	/^public class Node {$/;"	c
+OBRACE	src/bjc/dicelang/v2/Token.java	/^		OBRACE,   CBRACE,$/;"	e	enum:Token.Type	file:
+OBRACKET	src/bjc/dicelang/v2/Token.java	/^		OBRACKET, CBRACKET,$/;"	e	enum:Token.Type	file:
+OGROUP	src/bjc/dicelang/v2/Node.java	/^		 GROUP,   OGROUP,$/;"	e	enum:Node.Type	file:
+OPAREN	src/bjc/dicelang/v2/Token.java	/^		OPAREN,   CPAREN,$/;"	e	enum:Token.Type	file:
 OPERATOR	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^	OPERATOR,$/;"	e	enum:DiceASTType	file:
 OperationCondenser	src/bjc/dicelang/ast/optimization/OperationCondenser.java	/^public class OperationCondenser {$/;"	c
 OperatorDiceExpression	src/bjc/dicelang/OperatorDiceExpression.java	/^	public OperatorDiceExpression(IDiceExpression rght,$/;"	m	class:OperatorDiceExpression
 OperatorDiceExpression	src/bjc/dicelang/OperatorDiceExpression.java	/^public class OperatorDiceExpression implements IDiceExpression {$/;"	c
 OperatorDiceNode	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	private OperatorDiceNode(DiceOperatorType ty) {$/;"	m	class:OperatorDiceNode	file:
 OperatorDiceNode	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^public enum OperatorDiceNode implements IDiceASTNode {$/;"	g
+PRESHUNT	src/bjc/dicelang/v2/Token.java	/^		NIL,      PRESHUNT,  GROUPSEP,$/;"	e	enum:Token.Type	file:
+Parser	src/bjc/dicelang/v2/Parser.java	/^	public Parser() {$/;"	m	class:Parser
+Parser	src/bjc/dicelang/v2/Parser.java	/^public class Parser {$/;"	c
 PolyhedralDice	src/bjc/dicelang/PolyhedralDice.java	/^public class PolyhedralDice {$/;"	c
+RESULT	src/bjc/dicelang/v2/Node.java	/^		 RESULT$/;"	e	enum:Node.Type	file:
+ROOT	src/bjc/dicelang/v2/Node.java	/^		 ROOT,    TOKREF,$/;"	e	enum:Node.Type	file:
 ReferenceDiceExpression	src/bjc/dicelang/ReferenceDiceExpression.java	/^	public ReferenceDiceExpression(String nme,$/;"	m	class:ReferenceDiceExpression
 ReferenceDiceExpression	src/bjc/dicelang/ReferenceDiceExpression.java	/^public class ReferenceDiceExpression implements IDiceExpression {$/;"	c
+Result	src/bjc/dicelang/v2/Evaluator.java	/^		public Result(Type typ) {$/;"	m	class:Evaluator.Result
+Result	src/bjc/dicelang/v2/Evaluator.java	/^		public Result(Type typ, DiceBox.DieExpression dVal) {$/;"	m	class:Evaluator.Result
+Result	src/bjc/dicelang/v2/Evaluator.java	/^		public Result(Type typ, double dVal) {$/;"	m	class:Evaluator.Result
+Result	src/bjc/dicelang/v2/Evaluator.java	/^		public Result(Type typ, long iVal) {$/;"	m	class:Evaluator.Result
+Result	src/bjc/dicelang/v2/Evaluator.java	/^	public static class Result {$/;"	c	class:Evaluator
 ResultType	src/bjc/dicelang/ast/ResultType.java	/^public enum ResultType {$/;"	g
+STRING_LIT	src/bjc/dicelang/v2/Token.java	/^		INT_LIT,  FLOAT_LIT, STRING_LIT,$/;"	e	enum:Token.Type	file:
 SUBTRACT	src/bjc/dicelang/DiceExpressionType.java	/^	SUBTRACT;$/;"	e	enum:DiceExpressionType	file:
 SUBTRACT	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	SUBTRACT(MATH),$/;"	e	enum:OperatorDiceNode	file:
+SUBTRACT	src/bjc/dicelang/v2/Token.java	/^		ADD,      SUBTRACT,$/;"	e	enum:Token.Type	file:
 ScalarDie	src/bjc/dicelang/ScalarDie.java	/^	public ScalarDie(int num) {$/;"	m	class:ScalarDie
 ScalarDie	src/bjc/dicelang/ScalarDie.java	/^public class ScalarDie implements IDiceExpression {$/;"	c
+ScalarDie	src/bjc/dicelang/v2/DiceBox.java	/^		public ScalarDie(long vl) {$/;"	m	class:DiceBox.ScalarDie
+ScalarDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static class ScalarDie implements Die {$/;"	c	class:DiceBox
+Shunter	src/bjc/dicelang/v2/Shunter.java	/^	public Shunter() {$/;"	m	class:Shunter
+Shunter	src/bjc/dicelang/v2/Shunter.java	/^public class Shunter {$/;"	c
+SimpleDie	src/bjc/dicelang/v2/DiceBox.java	/^		public SimpleDie(long nDice, long size) {$/;"	m	class:DiceBox.SimpleDie
+SimpleDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static class SimpleDie implements Die {$/;"	c	class:DiceBox
+SimpleDieList	src/bjc/dicelang/v2/DiceBox.java	/^		public SimpleDieList(Die nDice, Die sze) {$/;"	m	class:DiceBox.SimpleDieList
+SimpleDieList	src/bjc/dicelang/v2/DiceBox.java	/^	private static class SimpleDieList implements DieList {$/;"	c	class:DiceBox
+StreamEngine	src/bjc/dicelang/v2/StreamEngine.java	/^	public StreamEngine(DiceLangEngine engine) {$/;"	m	class:StreamEngine
+StreamEngine	src/bjc/dicelang/v2/StreamEngine.java	/^public class StreamEngine {$/;"	c
+TOKEN	src/bjc/dicelang/v2/Define.java	/^		LINE, TOKEN$/;"	e	enum:Define.Type	file:
+TOKGROUP	src/bjc/dicelang/v2/Token.java	/^		TOKGROUP$/;"	e	enum:Token.Type	file:
+TOKREF	src/bjc/dicelang/v2/Node.java	/^		 ROOT,    TOKREF,$/;"	e	enum:Node.Type	file:
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ, DiceBox.DieExpression val) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ, IList<Token> tkVals) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ, String val) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ, double val) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^	public Token(Type typ, long val) {$/;"	m	class:Token
+Token	src/bjc/dicelang/v2/Token.java	/^public class Token {$/;"	c
+Type	src/bjc/dicelang/v2/Define.java	/^	public static enum Type {$/;"	g	class:Define
+Type	src/bjc/dicelang/v2/Evaluator.java	/^		public static enum Type {$/;"	g	class:Evaluator.Result
+Type	src/bjc/dicelang/v2/Node.java	/^	public static enum Type {$/;"	g	class:Node
+Type	src/bjc/dicelang/v2/Token.java	/^	public static enum Type {$/;"	g	class:Token
+UNARYOP	src/bjc/dicelang/v2/Node.java	/^		 UNARYOP, BINOP,$/;"	e	enum:Node.Type	file:
 VARIABLE	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^	VARIABLE;$/;"	e	enum:DiceASTType	file:
+VREF	src/bjc/dicelang/v2/Token.java	/^		VREF,$/;"	e	enum:Token.Type	file:
 VariableDiceNode	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public VariableDiceNode(String varName) {$/;"	m	class:VariableDiceNode
 VariableDiceNode	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^public class VariableDiceNode implements IDiceASTNode {$/;"	c
 accept	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^	public void accept(IDiceASTNode astNode) {$/;"	m	class:DiceASTReferenceChecker
@@ -112,9 +210,12 @@ actions	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	private static IMa
 acts	src/bjc/dicelang/examples/DiceLanguageTest.java	/^	private static Map<String, BiConsumer<String, DiceLanguageState>> acts;$/;"	f	class:DiceLanguageTest	file:
 add	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder add(IDiceExpression exp) {$/;"	m	class:DiceExpressionBuilder
 add	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder add(int num) {$/;"	m	class:DiceExpressionBuilder
+addLineDefine	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public void addLineDefine(Define dfn) {$/;"	m	class:DiceLangEngine
 addPass	src/bjc/dicelang/ast/DiceASTOptimizer.java	/^	public void addPass(IOptimizationPass pass) {$/;"	m	class:DiceASTOptimizer
+addTokenDefine	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public void addTokenDefine(Define dfn) {$/;"	m	class:DiceLangEngine
 additionCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	private static final ArithmeticCollapser	additionCollapser	= new ArithmeticCollapser($/;"	f	class:ConstantCollapser	file:
 apply	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	public IPair<IResult, ITree<IDiceASTNode>> apply($/;"	m	class:ArithmeticCollapser
+apply	src/bjc/dicelang/v2/Define.java	/^	public String apply(String tok) {$/;"	m	class:Define
 arrayContents	src/bjc/dicelang/ast/ArrayResult.java	/^	private IList<IResult> arrayContents;$/;"	f	class:ArrayResult	file:
 bake	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public IDiceExpression bake() {$/;"	m	class:DiceExpressionBuilder
 baking	src/bjc/dicelang/DiceExpressionBuilder.java	/^	private IDiceExpression baking;$/;"	f	class:DiceExpressionBuilder	file:
@@ -167,8 +268,17 @@ bjc.dicelang.examples	src/bjc/dicelang/examples/DiceExpressionParserTest.java	/^
 bjc.dicelang.examples	src/bjc/dicelang/examples/DiceExpressionPreparer.java	/^package bjc.dicelang.examples;$/;"	p
 bjc.dicelang.examples	src/bjc/dicelang/examples/DiceLanguageState.java	/^package bjc.dicelang.examples;$/;"	p
 bjc.dicelang.examples	src/bjc/dicelang/examples/DiceLanguageTest.java	/^package bjc.dicelang.examples;$/;"	p
-bjc.dicelang.examples.v2	src/bjc/dicelang/v2/DiceLangConsole.java	/^package bjc.dicelang.examples.v2;$/;"	p
-bjc.utils.dicelang.v2	src/bjc/dicelang/v2/DiceLangEngine.java	/^package bjc.utils.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Define.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/DiceBox.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/DiceLangConsole.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/DiceLangEngine.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/DoubleMatcher.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Evaluator.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Node.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Parser.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Shunter.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/StreamEngine.java	/^package bjc.dicelang.v2;$/;"	p
+bjc.dicelang.v2	src/bjc/dicelang/v2/Token.java	/^package bjc.dicelang.v2;$/;"	p
 buildOperations	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IMap<IDiceASTNode, IOperatorCollapser> buildOperations($/;"	m	class:DiceASTEvaluator	file:
 canOptimize	src/bjc/dicelang/ComplexDice.java	/^	public boolean canOptimize() {$/;"	m	class:ComplexDice
 canOptimize	src/bjc/dicelang/CompoundDice.java	/^	public boolean canOptimize() {$/;"	m	class:CompoundDice
@@ -178,15 +288,25 @@ canOptimize	src/bjc/dicelang/ScalarDie.java	/^	public boolean canOptimize() {$/;
 canOptimize	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	public boolean canOptimize() {$/;"	m	class:DiceLiteralNode
 canOptimize	src/bjc/dicelang/ast/nodes/ILiteralDiceNode.java	/^	boolean canOptimize();$/;"	m	interface:ILiteralDiceNode
 canOptimize	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public boolean canOptimize() {$/;"	m	class:IntegerLiteralNode
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		boolean canOptimize();$/;"	m	interface:DiceBox.Die
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		boolean canOptimize();$/;"	m	interface:DiceBox.DieList
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		public boolean canOptimize() {$/;"	m	class:DiceBox.CompoundDie
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		public boolean canOptimize() {$/;"	m	class:DiceBox.ScalarDie
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		public boolean canOptimize() {$/;"	m	class:DiceBox.SimpleDie
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		public boolean canOptimize() {$/;"	m	class:DiceBox.SimpleDieList
 collapse	src/bjc/dicelang/ast/optimization/ArithmeticCollapser.java	/^	public ITree<IDiceASTNode> collapse($/;"	m	class:ArithmeticCollapser
 combineArrayResults	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private IList<IResult> combineArrayResults(IResult accumulatedValue,$/;"	m	class:ArithmeticCollapser	file:
 commandNumber	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private int commandNumber;$/;"	f	class:DiceLangConsole	file:
 compoundCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	private static final ArithmeticCollapser	compoundCollapser	= new ArithmeticCollapser($/;"	f	class:ConstantCollapser	file:
+compoundDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  compoundDie        = simpleDie + "c(?:(?:" + simpleDie + ")|(?:\\\\d+))";$/;"	f	class:DiceBox	file:
+compoundDiePattern	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Pattern compoundDiePattern = Pattern.compile("\\\\A" + compoundDie + "\\\\Z");$/;"	f	class:DiceBox	file:
+compoundGroup	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  compoundGroup      = "(?:(?:" + scalarDie + ")|(?:" + simpleDie + ")|(?:"$/;"	f	class:DiceBox	file:
 condense	src/bjc/dicelang/ast/optimization/OperationCondenser.java	/^	public static ITree<IDiceASTNode> condense(ITree<IDiceASTNode> ast) {$/;"	m	class:OperationCondenser
 containsSimpleVariable	src/bjc/dicelang/ast/DiceASTUtils.java	/^	public static boolean containsSimpleVariable($/;"	m	class:DiceASTUtils
 convertLeafNode	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static IDiceASTNode convertLeafNode(String leafNode) {$/;"	m	class:DiceASTParser	file:
 convertOperatorNode	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static IDiceASTNode convertOperatorNode(String operatorNode) {$/;"	m	class:DiceASTParser	file:
 createFromString	src/bjc/dicelang/ast/DiceASTParser.java	/^		public static ITree<IDiceASTNode> createFromString($/;"	m	class:DiceASTParser
+currStream	src/bjc/dicelang/v2/StreamEngine.java	/^	private IList<String>       currStream;$/;"	f	class:StreamEngine	file:
 d10	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d10() {$/;"	m	class:PolyhedralDice
 d10	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d10(int nDice) {$/;"	m	class:PolyhedralDice
 d100	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d100() {$/;"	m	class:PolyhedralDice
@@ -201,6 +321,16 @@ d6	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d6() {$
 d6	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d6(int nDice) {$/;"	m	class:PolyhedralDice
 d8	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d8() {$/;"	m	class:PolyhedralDice
 d8	src/bjc/dicelang/PolyhedralDice.java	/^	public static IDiceExpression d8(int nDice) {$/;"	m	class:PolyhedralDice
+deaffixTokens	src/bjc/dicelang/v2/DiceLangEngine.java	/^	 private IList<String> deaffixTokens(IList<String> tokens, List<IPair<String, String>> deaffixTokens) {$/;"	m	class:DiceLangEngine	file:
+deaffixationList	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private List<IPair<String, String>> deaffixationList;$/;"	f	class:DiceLangEngine	file:
+debugMode	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private boolean debugMode;$/;"	f	class:DiceLangEngine	file:
+defineMode	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private boolean defineMode(String defineText) {$/;"	m	class:DiceLangConsole	file:
+defnsSorted	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private boolean defnsSorted;$/;"	f	class:DiceLangEngine	file:
+diceList	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  diceList           = compoundGroup + "dl" + compoundGroup;$/;"	f	class:DiceBox	file:
+diceListPattern	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Pattern diceListPattern    = Pattern.compile("\\\\A" + diceList + "\\\\Z");$/;"	f	class:DiceBox	file:
+diceSize	src/bjc/dicelang/v2/DiceBox.java	/^		private long diceSize;$/;"	f	class:DiceBox.SimpleDie	file:
+diceVal	src/bjc/dicelang/v2/Evaluator.java	/^		public DiceBox.DieExpression diceVal;$/;"	f	class:Evaluator.Result
+diceValue	src/bjc/dicelang/v2/Token.java	/^	public DiceBox.DieExpression diceValue;$/;"	f	class:Token
 die	src/bjc/dicelang/ComplexDice.java	/^	private IDiceExpression	die;$/;"	f	class:ComplexDice	file:
 divide	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder divide(IDiceExpression exp) {$/;"	m	class:DiceExpressionBuilder
 divide	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder divide(int num) {$/;"	m	class:DiceExpressionBuilder
@@ -208,17 +338,34 @@ divideCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	priv
 doArithmeticCollapse	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private IPair<IResult, ITree<IDiceASTNode>> doArithmeticCollapse($/;"	m	class:ArithmeticCollapser	file:
 doArrayAssign	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static void doArrayAssign($/;"	m	class:DiceASTEvaluator	file:
 doCondense	src/bjc/dicelang/ast/optimization/OperationCondenser.java	/^	private static ITree<IDiceASTNode> doCondense($/;"	m	class:OperationCondenser	file:
+doPass	src/bjc/dicelang/v2/Define.java	/^	private String doPass(String tok) {$/;"	m	class:Define	file:
+doRecur	src/bjc/dicelang/v2/Define.java	/^	private boolean doRecur;$/;"	f	class:Define	file:
 doSanitize	src/bjc/dicelang/ast/DiceASTReferenceSanitizer.java	/^	private static ITree<IDiceASTNode> doSanitize(ITree<IDiceASTNode> ast,$/;"	m	class:DiceASTReferenceSanitizer	file:
 doSingleSanitize	src/bjc/dicelang/ast/DiceASTReferenceSanitizer.java	/^	private static ITree<IDiceASTNode> doSingleSanitize($/;"	m	class:DiceASTReferenceSanitizer	file:
+doStreams	src/bjc/dicelang/v2/StreamEngine.java	/^	public boolean doStreams(String[] toks, IList<String> dest) {$/;"	m	class:StreamEngine
 dummyData	src/bjc/dicelang/ast/DummyResult.java	/^	private String dummyData;$/;"	f	class:DummyResult	file:
 eng	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private DiceLangEngine eng;$/;"	f	class:DiceLangConsole	file:
+eng	src/bjc/dicelang/v2/Evaluator.java	/^	private DiceLangEngine eng;$/;"	f	class:Evaluator	file:
+eng	src/bjc/dicelang/v2/StreamEngine.java	/^	private DiceLangEngine eng;$/;"	f	class:StreamEngine	file:
 enviroment	src/bjc/dicelang/ReferenceDiceExpression.java	/^	private Map<String, IDiceExpression>	enviroment;$/;"	f	class:ReferenceDiceExpression	file:
 equals	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public boolean equals(Object obj) {$/;"	m	class:VariableDiceNode
+equals	src/bjc/dicelang/v2/Node.java	/^	public boolean equals(Object other) {$/;"	m	class:Node
+equals	src/bjc/dicelang/v2/Token.java	/^	public boolean equals(Object other) {$/;"	m	class:Token
+eval	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Evaluator eval;$/;"	f	class:DiceLangEngine	file:
+evaluate	src/bjc/dicelang/v2/Evaluator.java	/^	public Result evaluate(ITree<Node> comm) {$/;"	m	class:Evaluator
 evaluateAST	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	public static IResult evaluateAST(ITree<IDiceASTNode> expression,$/;"	m	class:DiceASTEvaluator
+evaluateBinaryOp	src/bjc/dicelang/v2/Evaluator.java	/^	private ITree<Node> evaluateBinaryOp(ITree<Node> ast) {$/;"	m	class:Evaluator	file:
 evaluateLeaf	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IPair<IResult, ITree<IDiceASTNode>> evaluateLeaf($/;"	m	class:DiceASTEvaluator	file:
 evaluateLiteral	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IResult evaluateLiteral(IDiceASTNode leafNode) {$/;"	m	class:DiceASTEvaluator	file:
+evaluateNode	src/bjc/dicelang/v2/Evaluator.java	/^	private ITree<Node> evaluateNode(ITree<Node> ast) {$/;"	m	class:Evaluator	file:
+evaluateTokenRef	src/bjc/dicelang/v2/Evaluator.java	/^	private ITree<Node> evaluateTokenRef(Token tk) {$/;"	m	class:Evaluator	file:
 expression	src/bjc/dicelang/BindingDiceExpression.java	/^	private IDiceExpression	expression;$/;"	f	class:BindingDiceExpression	file:
 expression	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	private IDiceExpression expression;$/;"	f	class:DiceLiteralNode	file:
+flexadecimalMatcher	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern flexadecimalMatcher = Pattern.compile("\\\\A[\\\\-\\\\+]?[0-9][0-9A-Za-z]+B\\\\d{1,2}\\\\Z");$/;"	f	class:DiceLangEngine	file:
+floatVal	src/bjc/dicelang/v2/Evaluator.java	/^		public double floatVal;$/;"	f	class:Evaluator.Result
+floatValue	src/bjc/dicelang/v2/Token.java	/^	public double 				 floatValue;$/;"	f	class:Token
+floatingLiteral	src/bjc/dicelang/v2/DoubleMatcher.java	/^	public static final Pattern floatingLiteral = Pattern.compile("\\\\A" + fpRegex + "\\\\Z");$/;"	f	class:DoubleMatcher
+fpRegex	src/bjc/dicelang/v2/DoubleMatcher.java	/^	private static final String fpRegex    =$/;"	f	class:DoubleMatcher	file:
 fromString	src/bjc/dicelang/ComplexDice.java	/^	public static IDiceExpression fromString(String expression) {$/;"	m	class:ComplexDice
 fromString	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	public static OperatorDiceNode fromString(String s) {$/;"	m	class:OperatorDiceNode
 getData	src/bjc/dicelang/ast/DummyResult.java	/^	public String getData() {$/;"	m	class:DummyResult
@@ -241,21 +388,38 @@ getValue	src/bjc/dicelang/ast/IntegerResult.java	/^	public int getValue() {$/;"
 getValue	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	public IDiceExpression getValue() {$/;"	m	class:DiceLiteralNode
 getValue	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public int getValue() {$/;"	m	class:IntegerLiteralNode
 getVariable	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public String getVariable() {$/;"	m	class:VariableDiceNode
+groupType	src/bjc/dicelang/v2/Node.java	/^	public GroupType 		groupType;$/;"	f	class:Node
 halfCombineLists	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private IList<IResult> halfCombineLists(IList<IResult> list,$/;"	m	class:ArithmeticCollapser	file:
 handleInlineAction	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	private static void handleInlineAction($/;"	m	class:DiceASTLanguageTest	file:
+handlePragma	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private boolean handlePragma(String pragma) {$/;"	m	class:DiceLangConsole	file:
 hashCode	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public int hashCode() {$/;"	m	class:VariableDiceNode
+helpMode	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private boolean helpMode(String pragma) {$/;"	m	class:DiceLangConsole	file:
+hexadecimalMatcher	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern hexadecimalMatcher  = Pattern.compile("\\\\A[\\\\-\\\\+]?0x[0-9A-Fa-f]+\\\\Z");$/;"	f	class:DiceLangEngine	file:
+init	src/bjc/dicelang/v2/StreamEngine.java	/^	private void init() {$/;"	m	class:StreamEngine	file:
 initialValue	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private int						initialValue;$/;"	f	class:ArithmeticCollapser	file:
 initialize	src/bjc/dicelang/BindingDiceExpression.java	/^	private void initialize(String name, IDiceExpression expr,$/;"	m	class:BindingDiceExpression	file:
 inlineAll	src/bjc/dicelang/ast/DiceASTInliner.java	/^	public static ITree<IDiceASTNode> inlineAll(ITree<IDiceASTNode> ast,$/;"	m	class:DiceASTInliner
 inlineNode	src/bjc/dicelang/ast/DiceASTInliner.java	/^	private static ITree<IDiceASTNode> inlineNode(IDiceASTNode node,$/;"	m	class:DiceASTInliner	file:
+intMatcher	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern intMatcher          = Pattern.compile("\\\\A[\\\\-\\\\+]?\\\\d+\\\\Z");$/;"	f	class:DiceLangEngine	file:
+intVal	src/bjc/dicelang/v2/Evaluator.java	/^		public long intVal;$/;"	f	class:Evaluator.Result
+intValue	src/bjc/dicelang/v2/Token.java	/^	public long 				 intValue;$/;"	f	class:Token
 isDirectReference	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^	private boolean isDirectReference(IDiceASTNode astNode) {$/;"	m	class:DiceASTReferenceChecker	file:
+isGrouper	src/bjc/dicelang/v2/Token.java	/^	public boolean isGrouper() {$/;"	m	class:Token
+isHigherPrec	src/bjc/dicelang/v2/Shunter.java	/^	private boolean isHigherPrec(Token.Type left, Token.Type right) {$/;"	m	class:Shunter	file:
+isList	src/bjc/dicelang/v2/DiceBox.java	/^		public final boolean isList;$/;"	f	class:DiceBox.DieExpression
 isOperator	src/bjc/dicelang/ast/nodes/IDiceASTNode.java	/^	public boolean isOperator();$/;"	m	interface:IDiceASTNode
 isOperator	src/bjc/dicelang/ast/nodes/ILiteralDiceNode.java	/^	default boolean isOperator() {$/;"	m	interface:ILiteralDiceNode
 isOperator	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	public boolean isOperator() {$/;"	m	class:OperatorDiceNode
 isOperator	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public boolean isOperator() {$/;"	m	class:VariableDiceNode
 isOperatorNode	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static boolean isOperatorNode(String token) {$/;"	m	class:DiceASTParser	file:
+isValidExpression	src/bjc/dicelang/v2/DiceBox.java	/^	public static boolean isValidExpression(String exp) {$/;"	m	class:DiceBox
 left	src/bjc/dicelang/CompoundDice.java	/^	private IDiceExpression	left;$/;"	f	class:CompoundDice	file:
 left	src/bjc/dicelang/OperatorDiceExpression.java	/^	private IDiceExpression		left;$/;"	f	class:OperatorDiceExpression	file:
+left	src/bjc/dicelang/v2/DiceBox.java	/^		private Die left;$/;"	f	class:DiceBox.CompoundDie	file:
+lexToken	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Token lexToken(String token, IMap<String, String> stringLts) {$/;"	m	class:DiceLangEngine	file:
+lineDefns	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private IList<Define> lineDefns;$/;"	f	class:DiceLangEngine	file:
+list	src/bjc/dicelang/v2/DiceBox.java	/^		public DieList list;$/;"	f	class:DiceBox.DieExpression
+litTokens	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private IMap<String, Token.Type> litTokens;$/;"	f	class:DiceLangEngine	file:
 literalToExpression	src/bjc/dicelang/ast/DiceASTUtils.java	/^	public static IDiceExpression literalToExpression($/;"	m	class:DiceASTUtils
 literalToInteger	src/bjc/dicelang/ast/DiceASTUtils.java	/^	public static int literalToInteger(ITree<IDiceASTNode> tree) {$/;"	m	class:DiceASTUtils
 main	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	public static void main(String[] args) {$/;"	m	class:DiceASTLanguageTest
@@ -269,8 +433,15 @@ nDice	src/bjc/dicelang/ComplexDice.java	/^	private IDiceExpression	nDice;$/;"	f
 nSides	src/bjc/dicelang/Die.java	/^	private int				nSides;$/;"	f	class:Die	file:
 name	src/bjc/dicelang/BindingDiceExpression.java	/^	private String			name;$/;"	f	class:BindingDiceExpression	file:
 name	src/bjc/dicelang/ReferenceDiceExpression.java	/^	private String							name;$/;"	f	class:ReferenceDiceExpression	file:
+nextLiteral	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private int nextLiteral;$/;"	f	class:DiceLangEngine	file:
+nextSym	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private int nextSym;$/;"	f	class:DiceLangEngine	file:
+nonExpandPattern	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern nonExpandPattern = Pattern.compile("<([^\\\\>&&[^\\\\s]]*(?:\\\\>(?:[^\\\\>&&[^\\\\s]])*)*)>");$/;"	f	class:DiceLangEngine	file:
+numDice	src/bjc/dicelang/v2/DiceBox.java	/^		private Die numDice;$/;"	f	class:DiceBox.SimpleDieList	file:
+numDice	src/bjc/dicelang/v2/DiceBox.java	/^		private long numDice;$/;"	f	class:DiceBox.SimpleDie	file:
 number	src/bjc/dicelang/ScalarDie.java	/^	private int number;$/;"	f	class:ScalarDie	file:
-opExpansionTokens	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Deque<IPair<String, String>> opExpansionTokens;$/;"	f	class:DiceLangEngine	file:
+opExpansionList	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private List<IPair<String, String>> opExpansionList;$/;"	f	class:DiceLangEngine	file:
+operatorType	src/bjc/dicelang/v2/Node.java	/^	public Token.Type 		operatorType;$/;"	f	class:Node
+ops	src/bjc/dicelang/v2/Shunter.java	/^	private IMap<Token.Type, Integer> ops;$/;"	f	class:Shunter	file:
 optimize	src/bjc/dicelang/ComplexDice.java	/^	public int optimize() {$/;"	m	class:ComplexDice
 optimize	src/bjc/dicelang/CompoundDice.java	/^	public int optimize() {$/;"	m	class:CompoundDice
 optimize	src/bjc/dicelang/Die.java	/^	public int optimize() {$/;"	m	class:Die
@@ -279,6 +450,12 @@ optimize	src/bjc/dicelang/ScalarDie.java	/^	public int optimize() {$/;"	m	class:
 optimize	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	public int optimize() {$/;"	m	class:DiceLiteralNode
 optimize	src/bjc/dicelang/ast/nodes/ILiteralDiceNode.java	/^	int optimize();$/;"	m	interface:ILiteralDiceNode
 optimize	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public int optimize() {$/;"	m	class:IntegerLiteralNode
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		long optimize();$/;"	m	interface:DiceBox.Die
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		long[] optimize();$/;"	m	interface:DiceBox.DieList
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		public long optimize() {$/;"	m	class:DiceBox.CompoundDie
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		public long optimize() {$/;"	m	class:DiceBox.ScalarDie
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		public long optimize() {$/;"	m	class:DiceBox.SimpleDie
+optimize	src/bjc/dicelang/v2/DiceBox.java	/^		public long[] optimize() {$/;"	m	class:DiceBox.SimpleDieList
 optimizeLeaf	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode) {$/;"	m	class:ConstantCollapser
 optimizeLeaf	src/bjc/dicelang/ast/optimization/IOptimizationPass.java	/^	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode);$/;"	m	interface:IOptimizationPass
 optimizeOperator	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator,$/;"	m	class:ConstantCollapser
@@ -288,19 +465,34 @@ optimizer	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	private static D
 parse	src/bjc/dicelang/DiceExpressionParser.java	/^	public static IDiceExpression parse(String expression,$/;"	m	class:DiceExpressionParser
 parseBinding	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IPair<IResult, ITree<IDiceASTNode>> parseBinding($/;"	m	class:DiceASTEvaluator	file:
 parseCloseArray	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static ITree<String> parseCloseArray($/;"	m	class:DiceASTParser	file:
+parseExpression	src/bjc/dicelang/v2/DiceBox.java	/^	public static DieExpression parseExpression(String exp) {$/;"	m	class:DiceBox
 parseGroup	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IPair<IResult, ITree<IDiceASTNode>> parseGroup($/;"	m	class:DiceASTEvaluator	file:
 parseLet	src/bjc/dicelang/ast/DiceASTEvaluator.java	/^	private static IPair<IResult, ITree<IDiceASTNode>> parseLet($/;"	m	class:DiceASTEvaluator	file:
+parseTokens	src/bjc/dicelang/v2/Parser.java	/^	public boolean parseTokens(IList<Token> tokens,$/;"	m	class:Parser
+parsr	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Parser parsr;$/;"	f	class:DiceLangEngine	file:
 passes	src/bjc/dicelang/ast/DiceASTOptimizer.java	/^	private IList<IOptimizationPass> passes;$/;"	f	class:DiceASTOptimizer	file:
+pickEvaluationType	src/bjc/dicelang/v2/Evaluator.java	/^	private TopDownTransformResult pickEvaluationType(Node nd) {$/;"	m	class:Evaluator	file:
 pickNode	src/bjc/dicelang/ast/optimization/OperationCondenser.java	/^	private static TopDownTransformResult pickNode(IDiceASTNode node) {$/;"	m	class:OperationCondenser	file:
 pickOperator	src/bjc/dicelang/ast/optimization/OperationCondenser.java	/^	private static TopDownTransformResult pickOperator($/;"	m	class:OperationCondenser	file:
+postfixMode	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private boolean postfixMode;$/;"	f	class:DiceLangEngine	file:
+predicate	src/bjc/dicelang/v2/Define.java	/^	private Pattern predicate;$/;"	f	class:Define	file:
+prefixMode	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private boolean prefixMode;$/;"	f	class:DiceLangEngine	file:
 prepareCommand	src/bjc/dicelang/examples/DiceExpressionPreparer.java	/^	public static IList<String> prepareCommand(String currentLine) {$/;"	m	class:DiceExpressionPreparer
 printEnv	src/bjc/dicelang/examples/DiceLanguageTest.java	/^	private static void printEnv(String ln, DiceLanguageState stat) {$/;"	m	class:DiceLanguageTest	file:
+priority	src/bjc/dicelang/v2/Define.java	/^	public final int priority;$/;"	f	class:Define
+processCommand	src/bjc/dicelang/v2/StreamEngine.java	/^	private boolean processCommand(String tk) {$/;"	m	class:StreamEngine	file:
+quotePattern	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern quotePattern = Pattern.compile("\\"([^\\\\\\"]*(?:\\\\\\"(?:[^\\\\\\"])*)*)\\"");$/;"	f	class:DiceLangEngine	file:
 reduceStates	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private IPair<IResult, ITree<IDiceASTNode>> reduceStates($/;"	m	class:ArithmeticCollapser	file:
 reducer	src/bjc/dicelang/ast/optimization/ArithmeticCollapser.java	/^	private BinaryOperator<Integer>	reducer;$/;"	f	class:ArithmeticCollapser	file:
 referencesVariable	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^	private IHolder<Boolean>	referencesVariable;$/;"	f	class:DiceASTReferenceChecker	file:
+replacer	src/bjc/dicelang/v2/Define.java	/^	private String replacer;$/;"	f	class:Define	file:
+replacers	src/bjc/dicelang/v2/Define.java	/^	private Iterator<String>  replacers;$/;"	f	class:Define	file:
+resultVal	src/bjc/dicelang/v2/Node.java	/^	public Evaluator.Result resultVal;$/;"	f	class:Node
 right	src/bjc/dicelang/CompoundDice.java	/^	private IDiceExpression	right;$/;"	f	class:CompoundDice	file:
 right	src/bjc/dicelang/OperatorDiceExpression.java	/^	private IDiceExpression		right;$/;"	f	class:OperatorDiceExpression	file:
+right	src/bjc/dicelang/v2/DiceBox.java	/^		private Die right;$/;"	f	class:DiceBox.CompoundDie	file:
 rng	src/bjc/dicelang/Die.java	/^	private static Random	rng	= new Random();$/;"	f	class:Die	file:
+rng	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Random rng = new Random();$/;"	f	class:DiceBox	file:
 roll	src/bjc/dicelang/BindingDiceExpression.java	/^	public int roll() {$/;"	m	class:BindingDiceExpression
 roll	src/bjc/dicelang/ComplexDice.java	/^	public int roll() {$/;"	m	class:ComplexDice
 roll	src/bjc/dicelang/CompoundDice.java	/^	public int roll() {$/;"	m	class:CompoundDice
@@ -309,16 +501,40 @@ roll	src/bjc/dicelang/IDiceExpression.java	/^	public int roll();$/;"	m	interface
 roll	src/bjc/dicelang/OperatorDiceExpression.java	/^	public int roll() {$/;"	m	class:OperatorDiceExpression
 roll	src/bjc/dicelang/ReferenceDiceExpression.java	/^	public int roll() {$/;"	m	class:ReferenceDiceExpression
 roll	src/bjc/dicelang/ScalarDie.java	/^	public int roll() {$/;"	m	class:ScalarDie
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		long roll();$/;"	m	interface:DiceBox.Die
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		long[] roll();$/;"	m	interface:DiceBox.DieList
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		public long roll() {$/;"	m	class:DiceBox.CompoundDie
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		public long roll() {$/;"	m	class:DiceBox.ScalarDie
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		public long roll() {$/;"	m	class:DiceBox.SimpleDie
+roll	src/bjc/dicelang/v2/DiceBox.java	/^		public long[] roll() {$/;"	m	class:DiceBox.SimpleDieList
 rollReference	src/bjc/dicelang/examples/DiceLanguageTest.java	/^	private static void rollReference(String ln, DiceLanguageState stat) {$/;"	m	class:DiceLanguageTest	file:
 run	src/bjc/dicelang/v2/DiceLangConsole.java	/^	public void run() {$/;"	m	class:DiceLangConsole
 runCommand	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public boolean runCommand(String command) {$/;"	m	class:DiceLangEngine
 sanitize	src/bjc/dicelang/ast/DiceASTReferenceSanitizer.java	/^	public static ITree<IDiceASTNode> sanitize(ITree<IDiceASTNode> ast,$/;"	m	class:DiceASTReferenceSanitizer
+scalar	src/bjc/dicelang/v2/DiceBox.java	/^		public Die     scalar;$/;"	f	class:DiceBox.DieExpression
+scalarDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  scalarDie          = "[\\\\+\\\\-]?\\\\d+";$/;"	f	class:DiceBox	file:
+scalarDiePattern	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Pattern scalarDiePattern   = Pattern.compile("\\\\A" + scalarDie + "\\\\Z");$/;"	f	class:DiceBox	file:
+searcher	src/bjc/dicelang/v2/Define.java	/^	private Pattern searcher;$/;"	f	class:Define	file:
 selectiveInline	src/bjc/dicelang/ast/DiceASTInliner.java	/^	public static ITree<IDiceASTNode> selectiveInline($/;"	m	class:DiceASTInliner
 shouldContinuePopping	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static boolean shouldContinuePopping($/;"	m	class:DiceASTParser	file:
 shouldSanitize	src/bjc/dicelang/ast/DiceASTReferenceSanitizer.java	/^	private static TopDownTransformResult shouldSanitize($/;"	m	class:DiceASTReferenceSanitizer	file:
+shunt	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Shunter shunt;$/;"	f	class:DiceLangEngine	file:
+shuntTokens	src/bjc/dicelang/v2/Shunter.java	/^	public boolean shuntTokens(IList<Token> tks, IList<Token> returned) {$/;"	m	class:Shunter
+simpleDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  simpleDie          = "(?:\\\\d+)?d\\\\d+";$/;"	f	class:DiceBox	file:
+simpleDiePattern	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Pattern simpleDiePattern   = Pattern.compile("\\\\A" + simpleDie + "\\\\Z");$/;"	f	class:DiceBox	file:
+size	src/bjc/dicelang/v2/DiceBox.java	/^		private Die size;$/;"	f	class:DiceBox.SimpleDieList	file:
+slashPattern	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private Pattern slashPattern = Pattern.compile("\/((?:\\\\\\\\.|[^\/\\\\\\\\])*)\/");$/;"	f	class:DiceLangConsole	file:
+sortDefns	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public void sortDefns() {$/;"	m	class:DiceLangEngine
+streamEng	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private StreamEngine streamEng;$/;"	f	class:DiceLangEngine	file:
+streams	src/bjc/dicelang/v2/StreamEngine.java	/^	private Tape<IList<String>> streams;$/;"	f	class:StreamEngine	file:
+stringLitMatcher	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Pattern stringLitMatcher    = Pattern.compile("\\\\AstringLiteral(\\\\d+)\\\\Z");$/;"	f	class:DiceLangEngine	file:
+stringLits	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private IMap<Integer, String> stringLits;$/;"	f	class:DiceLangEngine	file:
+stringValue	src/bjc/dicelang/v2/Token.java	/^	public String 				 stringValue;$/;"	f	class:Token
+subType	src/bjc/dicelang/v2/Define.java	/^	private boolean subType;$/;"	f	class:Define	file:
 subtract	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder subtract(IDiceExpression exp) {$/;"	m	class:DiceExpressionBuilder
 subtract	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder subtract(int num) {$/;"	m	class:DiceExpressionBuilder
 subtractCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	private static final ArithmeticCollapser	subtractCollapser	= new ArithmeticCollapser($/;"	f	class:ConstantCollapser	file:
+symTable	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private IMap<Integer, String> symTable;$/;"	f	class:DiceLangEngine	file:
 toExpression	src/bjc/dicelang/IDiceExpression.java	/^	static IDiceExpression toExpression(String expression) {$/;"	m	interface:IDiceExpression
 toString	src/bjc/dicelang/BindingDiceExpression.java	/^	public String toString() {$/;"	m	class:BindingDiceExpression
 toString	src/bjc/dicelang/ComplexDice.java	/^	public String toString() {$/;"	m	class:ComplexDice
@@ -335,13 +551,36 @@ toString	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^	public String toString()
 toString	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	public String toString() {$/;"	m	class:DiceLiteralNode
 toString	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public String toString() {$/;"	m	class:IntegerLiteralNode
 toString	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	public String toString() {$/;"	m	class:VariableDiceNode
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.CompoundDie
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.DieExpression
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.ScalarDie
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.SimpleDie
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.SimpleDieList
+toString	src/bjc/dicelang/v2/Evaluator.java	/^		public String toString() {$/;"	m	class:Evaluator.Result
+toString	src/bjc/dicelang/v2/Node.java	/^	public String toString() {$/;"	m	class:Node
+toString	src/bjc/dicelang/v2/Token.java	/^	public String toString() {$/;"	m	class:Token
+toggleDebug	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public boolean toggleDebug() {$/;"	m	class:DiceLangEngine
+togglePostfix	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public boolean togglePostfix() {$/;"	m	class:DiceLangEngine
+togglePrefix	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public boolean togglePrefix() {$/;"	m	class:DiceLangEngine
+tokenDefns	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private IList<Define> tokenDefns;$/;"	f	class:DiceLangEngine	file:
+tokenVal	src/bjc/dicelang/v2/Node.java	/^	public Token      		tokenVal;$/;"	f	class:Node
+tokenValues	src/bjc/dicelang/v2/Token.java	/^	public IList<Token>          tokenValues;$/;"	f	class:Token
+tokenizeGrouping	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Token tokenizeGrouping(String token) {$/;"	m	class:DiceLangEngine	file:
+tokenizeLiteral	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Token tokenizeLiteral(String token, IMap<String, String> stringLts) {$/;"	m	class:DiceLangEngine	file:
 transformAST	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	private static ITree<IDiceASTNode> transformAST($/;"	m	class:DiceASTLanguageTest	file:
 type	src/bjc/dicelang/OperatorDiceExpression.java	/^	private DiceExpressionType	type;$/;"	f	class:OperatorDiceExpression	file:
 type	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private OperatorDiceNode		type;$/;"	f	class:ArithmeticCollapser	file:
 type	src/bjc/dicelang/ast/nodes/OperatorDiceNode.java	/^	public final DiceOperatorType type;$/;"	f	class:OperatorDiceNode
 type	src/bjc/dicelang/ast/optimization/ArithmeticCollapser.java	/^	private OperatorDiceNode		type;$/;"	f	class:ArithmeticCollapser	file:
+type	src/bjc/dicelang/v2/Evaluator.java	/^		public final Type type;$/;"	f	class:Evaluator.Result
+type	src/bjc/dicelang/v2/Node.java	/^	public final Type type;$/;"	f	class:Node
+type	src/bjc/dicelang/v2/Token.java	/^	public final Type type;$/;"	f	class:Token
+unaryAdjectives	src/bjc/dicelang/v2/Shunter.java	/^	private Set<Token.Type> unaryAdjectives;$/;"	f	class:Shunter	file:
+unaryAdverbs	src/bjc/dicelang/v2/Shunter.java	/^	private Set<Token.Type> unaryAdverbs;$/;"	f	class:Shunter	file:
+val	src/bjc/dicelang/v2/DiceBox.java	/^		private long val;$/;"	f	class:DiceBox.ScalarDie	file:
 value	src/bjc/dicelang/ast/IntegerResult.java	/^	private int value;$/;"	f	class:IntegerResult	file:
 value	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	private int value;$/;"	f	class:IntegerLiteralNode	file:
+value	src/bjc/dicelang/v2/DiceBox.java	/^		public String value() {$/;"	m	class:DiceBox.DieExpression
 valueOp	src/bjc/dicelang/ast/ArithmeticCollapser.java	/^	private BinaryOperator<Integer>	valueOp;$/;"	f	class:ArithmeticCollapser	file:
 varName	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^	private String				varName;$/;"	f	class:DiceASTReferenceChecker	file:
 variableName	src/bjc/dicelang/ast/nodes/VariableDiceNode.java	/^	private String variableName;$/;"	f	class:VariableDiceNode	file: