Error & dice handling

10 files changed, 918 insertions, 138 deletions

diff --git a/dice-lang/src/bjc/dicelang/v2/Define.java b/dice-lang/src/bjc/dicelang/v2/Define.java
index 2ecbc69..3ee2f37 100644
--- a/dice-lang/src/bjc/dicelang/v2/Define.java
+++ b/dice-lang/src/bjc/dicelang/v2/Define.java
@@ -4,15 +4,21 @@ import bjc.utils.data.CircularIterator;
 
 import java.util.Iterator;
 import java.util.function.UnaryOperator;
-import java.util.regex.Pattern;
 import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.regex.PatternSyntaxException;
+
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
 
 public class Define implements UnaryOperator<String> {
 	public static enum Type {
 		LINE, TOKEN
 	}
 
+	public static final int MAX_RECURS = 10;
+
 	public final int priority;
+	public final boolean inError;
 
 	private boolean doRecur;
 	private boolean subType;
@@ -31,9 +37,26 @@ public class Define implements UnaryOperator<String> {
 		subType  = isSub;
 
 		if(predicte != null) {
-			predicate = Pattern.compile(predicte);
+			try {
+				predicate = Pattern.compile(predicte);
+			} catch (PatternSyntaxException psex) {
+				Errors.inst.printError(EK_DFN_PREDSYN, psex.getMessage());
+				inError = true;
+
+				return;
+			}
+		}
+
+		try {
+			searcher  = Pattern.compile(searchr);
+		} catch (PatternSyntaxException psex) {
+			Errors.inst.printError(EK_DFN_SRCSYN, psex.getMessage());
+			inError = true;
+
+			return;
 		}
-		searcher  = Pattern.compile(searchr);
+
+		inError = false;
 
 		if(subType) {
 			if(replacrs.iterator().hasNext()) {
@@ -50,6 +73,8 @@ public class Define implements UnaryOperator<String> {
 	}
 
 	public String apply(String tok) {
+		if(inError) return tok;
+
 		if(predicate != null) {
 			if(!predicate.matcher(tok).matches()) {
 				return tok;
@@ -59,6 +84,8 @@ public class Define implements UnaryOperator<String> {
 		String strang = doPass(tok);
 
 		if(doRecur) {
+			int recurCount = 0;
+
 			if(strang.equals(tok)) {
 				return strang;
 			} else {
@@ -66,7 +93,14 @@ public class Define implements UnaryOperator<String> {
 
 				do {
 					strang = doPass(tok);
-				} while(!strang.equals(oldStrang));
+
+					recurCount += 1;
+				} while(!strang.equals(oldStrang) && recurCount < MAX_RECURS);
+
+				if(recurCount >= MAX_RECURS) {
+					Errors.inst.printError(EK_DFN_RECUR, Integer.toString(MAX_RECURS), tok, strang);
+					return strang;
+				}
 			}
 		}
 
@@ -81,16 +115,10 @@ public class Define implements UnaryOperator<String> {
 
 			while(searcherMatcher.find()) {
 				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());
 				}
 			}
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceBox.java b/dice-lang/src/bjc/dicelang/v2/DiceBox.java
index 375e256..342ea2e 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceBox.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceBox.java
@@ -1,9 +1,14 @@
 package bjc.dicelang.v2;
 
 import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Random;
+import java.util.function.Predicate;
 import java.util.regex.Pattern;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
+
 public class DiceBox {
 	private static final Random rng = new Random();
 
@@ -12,6 +17,7 @@ public class DiceBox {
 		long optimize();
 
 		long roll();
+		long rollSingle();
 	}
 
 	public interface DieList {
@@ -50,7 +56,7 @@ public class DiceBox {
 		}
 	}
 
-	private static class ScalarDie implements Die {
+	public static class ScalarDie implements Die {
 		private long val;
 
 		public ScalarDie(long vl) {
@@ -69,45 +75,116 @@ public class DiceBox {
 			return val;
 		}
 
+		public long rollSingle() {
+			return val;
+		}
+
 		public String toString() {
 			return Long.toString(val);
 		}
 	}
 
-	private static class SimpleDie implements Die {
-		private long numDice;
-		private long diceSize;
+	public static class SimpleDie implements Die {
+		private Die numDice;
+		private Die diceSize;
 
 		public SimpleDie(long nDice, long size) {
-			numDice = nDice;
+			numDice  = new ScalarDie(nDice);
+			diceSize = new ScalarDie(size);
+		}
+
+		public SimpleDie(Die nDice, long size) {
+			numDice  = nDice;
+			diceSize = new ScalarDie(size);
+		}
+
+		public SimpleDie(long nDice, Die size) {
+			numDice  = new ScalarDie(nDice);
+			diceSize = size;
+		}
+
+		public SimpleDie(Die nDice, Die size) {
+			numDice  = nDice;
 			diceSize = size;
 		}
 
 		public boolean canOptimize() {
-			if(diceSize == 1) return true;
+			if(diceSize.canOptimize() && diceSize.optimize() == 1) return numDice.canOptimize();
 			else return false;
 		}
 
 		public long optimize() {
-			return numDice;
+			return numDice.optimize();
 		}
 
 		public long roll() {
 			long total = 0;
 
-			for(int i = 0; i < numDice; i++) {
-				total += (rng.nextLong() % numDice) + 1;
+			long nDice = numDice.roll();
+			long dSize = diceSize.roll();
+
+			for(int i = 0; i < nDice; i++) {
+				total += (Math.abs(rng.nextLong()) % dSize) + 1;
 			}
 
 			return total;
 		}
 
+		public long rollSingle() {
+			return (Math.abs(rng.nextLong()) % diceSize.roll()) + 1;
+		}
+
 		public String toString() {
 			return numDice + "d" + diceSize;
 		}
 	}
 
-	private static class CompoundDie implements Die {
+	public static class FudgeDie implements Die {
+		private Die numDice;
+
+		public FudgeDie(long nDice) {
+			numDice = new ScalarDie(nDice);
+		}
+
+		public boolean canOptimize() {
+			return false;
+		}
+
+		public long optimize() {
+			return 0;
+		}
+
+		public long roll() {
+			long nDice = numDice.roll();
+
+			long res = 0;
+
+			for(int i = 0; i < nDice; i++) {
+				res += rollSingle();
+			}
+
+			return res;
+		}
+
+		public long rollSingle() {
+			switch(rng.nextInt(3)) {
+				case 0:
+					return -1;
+				case 1:
+					return 0;
+				case 2:
+					return 1;
+				default:
+					return 0;
+			}
+		}
+
+		public String toString() {
+			return numDice + "dF";
+		}
+	}
+
+	public static class CompoundDie implements Die {
 		private Die left;
 		private Die right;
 
@@ -128,12 +205,78 @@ public class DiceBox {
 			return Long.parseLong(left.roll() + "" + right.roll());
 		}
 
+		public long rollSingle() {
+			return roll();
+		}
+
 		public String toString() {
 			return left.toString() + "c" + right.toString();
 		}
 	}
 
-	private static class SimpleDieList implements DieList {
+	public static class CompoundingDie implements Die {
+		private Die source;
+		
+		private Predicate<Long> compoundOn;
+		private String          compoundPattern;
+
+		public CompoundingDie(Die src, Predicate<Long> compound) {
+			this(src, compound, null);
+		}
+		
+		public CompoundingDie(Die src, Predicate<Long> compound, String patt) {
+			source = src;
+
+			compoundOn      = compound;
+			compoundPattern = patt;
+		}
+
+		public boolean canOptimize() {
+			return false;
+		}
+
+		public long optimize() {
+			return 0;
+		}
+
+		public long roll() {
+			long res = source.roll();
+
+			long oldRes = res;
+
+			while(compoundOn.test(oldRes)) {
+				oldRes = source.rollSingle();
+
+				res += oldRes;
+			}
+
+			return res;
+		}
+
+		public long rollSingle() {
+			long res = source.rollSingle();
+
+			long oldRes = res;
+
+			while(compoundOn.test(oldRes)) {
+				oldRes = source.rollSingle();
+
+				res += oldRes;
+			}
+
+			return res;
+		}
+
+		public String toString() {
+			if(compoundPattern == null) {
+				return source + "!!";
+			} else {
+				return source + "!!" + compoundPattern;
+			}
+		}
+	}
+
+	public static class SimpleDieList implements DieList {
 		private Die numDice;
 		private Die size;
 
@@ -179,11 +322,78 @@ public class DiceBox {
 		}
 	}
 
+	public static class ExplodingDice implements DieList {
+		private Die             source;
+
+		private Predicate<Long> explodeOn;
+		private String          explodePattern;
+		private boolean         explodePenetrates;
+
+		public ExplodingDice(Die src, Predicate<Long> explode) {
+			this(src, explode, null, false);
+		}
+
+		public ExplodingDice(Die src, Predicate<Long> explode, boolean penetrate) {
+			this(src, explode, null, penetrate);
+		}
+
+		public ExplodingDice(Die src, Predicate<Long> explode, String patt, boolean penetrate) {
+			source            = src;
+			explodeOn         = explode;
+			explodePattern    = patt;
+			explodePenetrates = penetrate;
+		}
+
+		public boolean canOptimize() {
+			return false;
+		}
+
+		public long[] optimize() {
+			return new long[0];
+		}
+
+		public long[] roll() {
+			long res = source.roll();
+
+			List<Long> resList = new LinkedList<>();
+
+			long oldRes = res;
+
+			while(explodeOn.test(oldRes)) {
+				oldRes = source.rollSingle();
+
+				if(explodePenetrates) oldRes -= 1;
+
+				resList.add(oldRes);
+			}
+
+			long[] newRes = new long[resList.size()+1];
+
+			newRes[0] = res;
+
+			int i = 1;
+			for(long rll : resList) {
+				newRes[i] = rll;
+				i         += 1;
+			}
+
+			return newRes;
+		}
+
+		public String toString() {
+			if(explodePattern == null) {
+				return source + (explodePenetrates ? "p" : "") + "!";
+			} else {
+				return source + (explodePenetrates ? "p" : "") + "!" + explodePattern;
+			}
+		}
+	}
+
 	public static DieExpression parseExpression(String exp) {
 		if(!isValidExpression(exp)) return null;
 
 		if(scalarDiePattern.matcher(exp).matches()) {
-			return new DieExpression(new ScalarDie(Long.parseLong(exp)));
+			return new DieExpression(new ScalarDie(Long.parseLong(exp.substring(0, exp.indexOf('s')))));
 		} else if(simpleDiePattern.matcher(exp).matches()) {
 			String[] dieParts = exp.split("d");
 
@@ -192,28 +402,44 @@ public class DiceBox {
 			} else {
 				return new DieExpression(new SimpleDie(Long.parseLong(dieParts[0]), Long.parseLong(dieParts[1])));
 			}
+		} else if(fudgeDiePattern.matcher(exp).matches()) {
+			String nDice = exp.substring(0, exp.indexOf('d'));
+
+			return new DieExpression(new FudgeDie(Long.parseLong(nDice)));
 		} else if(compoundDiePattern.matcher(exp).matches()) {
 			String[] dieParts = exp.split("c");
 
 			DieExpression left  = parseExpression(dieParts[0]);
 			DieExpression right = parseExpression(dieParts[1]);
 
-			if(left.isList || right.isList) {
-				// @TODO give a specific error message
-				return null;
-			}
-
 			return new DieExpression(new CompoundDie(left.scalar, right.scalar));
+		} else if(compoundingDiePattern.matcher(exp).matches()) {
+			String[] dieParts = exp.split("!!");
+
+			DieExpression   left  = parseExpression(dieParts[0]);
+			Predicate<Long> right = deriveCond(dieParts[1]);
+
+			return new DieExpression(new CompoundingDie(left.scalar, right, dieParts[1]));
+		} else if(explodingDiePattern.matcher(exp).matches()) {
+			String[] dieParts = exp.split("!");
+
+			DieExpression   left  = parseExpression(dieParts[0]);
+			Predicate<Long> right = deriveCond(dieParts[1]);
+
+			return new DieExpression(new ExplodingDice(left.scalar, right, dieParts[1], false));
+		} else if(penetratingDiePattern.matcher(exp).matches()) {
+			String[] dieParts = exp.split("p!");
+
+			DieExpression   left  = parseExpression(dieParts[0]);
+			Predicate<Long> right = deriveCond(dieParts[1]);
+
+			return new DieExpression(new ExplodingDice(left.scalar, right, dieParts[1], true));
 		} else if(diceListPattern.matcher(exp).matches()) {
 			String[] dieParts = exp.split("dl");
 
 			DieExpression left  = parseExpression(dieParts[0]);
 			DieExpression right = parseExpression(dieParts[1]);
 
-			if(left.isList || right.isList) {
-				return null;
-			}
-
 			return new DieExpression(new SimpleDieList(left.scalar, right.scalar));
 		}
 
@@ -221,27 +447,50 @@ public class DiceBox {
 		return null;
 	}
 
-	private static final String  scalarDie          = "[\\+\\-]?\\d+";
+	private static final String comparePoint         = "[<>=]\\d+";
+
+	private static final String  scalarDie          = "[\\+\\-]?\\d+sd";
 	private static final Pattern scalarDiePattern   = Pattern.compile("\\A" + scalarDie + "\\Z");
 
-	private static final String  simpleDie          = "(?:\\d+)?d\\d+";
-	private static final Pattern simpleDiePattern   = Pattern.compile("\\A" + simpleDie + "\\Z");
+	private static final String  simpleDie           = "(?:\\d+)?d\\d+";
+	private static final Pattern simpleDiePattern    = Pattern.compile("\\A" + simpleDie + "\\Z");
+
+	private static final String  fudgeDie            = "(?:\\d+)?dF";
+	private static final Pattern fudgeDiePattern     = Pattern.compile("\\A" + fudgeDie + "\\Z");
+
+	private static final String  compoundDie         = simpleDie + "c(?:(?:" + simpleDie + ")|(?:\\d+))";
+	private static final Pattern compoundDiePattern  = Pattern.compile("\\A" + compoundDie + "\\Z");
+
+	private static final String  compoundGroup       = "(?:(?:\\d+)|(?:" + simpleDie + ")|(?:"
+		+ compoundDie + ")|(?:" + fudgeDie +"))";
+
+	private static final String  compoundingDie        = compoundGroup + "!!" + comparePoint;
+	private static final Pattern compoundingDiePattern = Pattern.compile("\\A" + compoundingDie + "\\Z");
+
+	private static final String  explodingDie        = compoundGroup + "!" + comparePoint;
+	private static final Pattern explodingDiePattern = Pattern.compile("\\A" + explodingDie + "\\Z");
 
-	private static final String  compoundDie        = simpleDie + "c(?:(?:" + simpleDie + ")|(?:\\d+))";
-	private static final Pattern compoundDiePattern = Pattern.compile("\\A" + compoundDie + "\\Z");
+	private static final String  penetratingDie        = compoundGroup + "!" + comparePoint;
+	private static final Pattern penetratingDiePattern = Pattern.compile("\\A" + penetratingDie + "\\Z");
 
-	private static final String  compoundGroup      = "(?:(?:" + scalarDie + ")|(?:" + simpleDie + ")|(?:"
-		+ compoundDie + "))";
+	private static final String  diceList            = compoundGroup + "dl" + compoundGroup;
+	private static final Pattern diceListPattern     = Pattern.compile("\\A" + diceList + "\\Z");
 
-	private static final String  diceList           = compoundGroup + "dl" + compoundGroup;
-	private static final Pattern diceListPattern    = Pattern.compile("\\A" + diceList + "\\Z");
 
 	public static boolean isValidExpression(String exp) {
 		if(scalarDiePattern.matcher(exp).matches()) {
 			return true;
 		} else if(simpleDiePattern.matcher(exp).matches()) {
 			return true;
-		} else if (compoundDiePattern.matcher(exp).matches()) {
+		} else if(fudgeDiePattern.matcher(exp).matches()) {
+			return true;
+		} else if(compoundDiePattern.matcher(exp).matches()) {
+			return true;
+		} else if(compoundingDiePattern.matcher(exp).matches()) {
+			return true;
+		} else if(explodingDiePattern.matcher(exp).matches()) {
+			return true;
+		} else if(penetratingDiePattern.matcher(exp).matches()) {
 			return true;
 		} else if (diceListPattern.matcher(exp).matches()) {
 			return true;
@@ -249,4 +498,19 @@ public class DiceBox {
 			return false;
 		}
 	}
+
+	private static Predicate<Long> deriveCond(String patt) {
+		long            num  = Long.parseLong(patt.substring(1));
+
+		switch(patt.charAt(0)) {
+			case '<':
+				return (roll) -> roll < num;
+			case '=':
+				return (roll) -> roll == num;
+			case '>':
+				return (roll) -> roll > num;
+			default:
+				return (roll) -> false;
+		}
+	}
 }
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java b/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
index 5731877..863bce5 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangConsole.java
@@ -6,6 +6,8 @@ import java.util.Scanner;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
+
 public class DiceLangConsole {
 	private int commandNumber;
 
@@ -13,7 +15,6 @@ public class DiceLangConsole {
 
 	public DiceLangConsole(String[] args) {
 		// @TODO do something with the args
-		
 		commandNumber = 0;
 
 		eng = new DiceLangEngine();
@@ -31,19 +32,15 @@ public class DiceLangConsole {
 			if(comm.startsWith("pragma")) {
 				boolean success = handlePragma(comm.substring(7));
 
-				if(success) 
-					System.out.println("Pragma completed succesfully");
-				else
-					System.out.println("Pragma execution failed");
+				if(success) System.out.println("Pragma completed succesfully");
+				else        System.out.println("Pragma execution failed");
 			} else {
 				System.out.printf("\tRaw command: %s\n", comm);
 
 				boolean success = eng.runCommand(comm);
 
-				if(success) 
-					System.out.println("Command completed succesfully");
-				else
-					System.out.println("Command execution failed");
+				if(success) System.out.println("Command completed succesfully");
+				else        System.out.println("Command execution failed");
 
 				commandNumber += 1;
 			}
@@ -81,7 +78,7 @@ public class DiceLangConsole {
 			case "help":
 				return helpMode(pragma.substring(5));
 			default:
-				System.out.println("\tERROR: Unknown pragma: " + pragma);
+				Errors.inst.printError(EK_CONS_INVPRAG, pragma);
 				return false;
 		}
 
@@ -90,7 +87,20 @@ public class DiceLangConsole {
 	
 	private boolean helpMode(String pragma) {
 		switch(pragma.trim()) {
+			case "help":
+				System.out.println("\tGet help on pragmas");
+				break;
+			case "debug":
+				System.out.println("\tToggle debug mode. (Output stage results)");
+				break;
+			case "postfix":
+				System.out.println("\tToggle postfix mode. (Don't shunt tokens)");
+				break;
+			case "prefix":
+				System.out.println("\tToggle prefix mode. (Reverse token order instead of shunting)");
+				break;
 			case "define":
+				System.out.println("\tAdd a macro rewrite directive.");
 				System.out.println("\tdefine <priority> <type> <recursion> <guard> <circular> <patterns>...");
 				break;
 			default:
@@ -124,22 +134,22 @@ public class DiceLangConsole {
 		int sixthIndex    = defineText.indexOf(' ', fifthIndex + 1);
 
 		if(firstIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no priority)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no priority)");
 			return false;
 		} else if(secondIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no define type)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no define type)");
 			return false;
 		} else if(thirdIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no recursion type)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no recursion type)");
 			return false;
 		} else if(fourthIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no guard type)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no guard type)");
 			return false;
 		} else if(fifthIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no circularity)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no circularity)");
 			return false;
 		} else if(sixthIndex == -1) {
-			System.out.println("\tERROR: Improperly formatted define (no patterns)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no patterns)");
 			return false;
 		}
 
@@ -166,8 +176,7 @@ public class DiceLangConsole {
 				subMode = true;
 				break;
 			default:
-				System.out.println("\tERROR: Unknown define type "
-						+ defineType);
+				Errors.inst.printError(EK_CONS_INVDEFINE, "(unknown type)");
 				return false;
 		}
 
@@ -185,14 +194,16 @@ public class DiceLangConsole {
 
 		if(hasGuard) {
 			if(!patMatcher.find()) {
-				System.out.println("\tERROR: Improperly formatted define (no guard pattern)");
+				Errors.inst.printError(EK_CONS_INVDEFINE, "(no guard pattern)");
+				return false;
 			}
 
 			guardPattern = patMatcher.group(1);
 		}
 
 		if(!patMatcher.find()) {
-			System.out.println("\tERROR: Improperly formatted define (no search pattern)");
+			Errors.inst.printError(EK_CONS_INVDEFINE, "(no search pattern)");
+			return false;
 		}
 
 		String searchPattern = patMatcher.group(1);
@@ -205,6 +216,8 @@ public class DiceLangConsole {
 		Define dfn = new Define(priority, subMode, doRecur, isCircular,
 				guardPattern, searchPattern, replacePatterns);
 		
+		if(dfn.inError) return false;
+
 		if(type == Define.Type.LINE) {
 			eng.addLineDefine(dfn);
 		} else {
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
index 5fbfb3a..07b6b10 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
@@ -20,6 +20,7 @@ import java.util.LinkedList;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
 import static bjc.dicelang.v2.Token.Type.*;
 
 public class DiceLangEngine {
@@ -46,8 +47,8 @@ public class DiceLangEngine {
 	private Evaluator eval;
 
 	// Tables for symbols
-	private IMap<Integer, String> symTable;
-	private IMap<Integer, String> stringLits;
+	public final IMap<Integer, String> symTable;
+	public final IMap<Integer, String> stringLits;
 
 	// Literal tokens for tokenization
 	private IMap<String, Token.Type> litTokens;
@@ -302,7 +303,7 @@ public class DiceLangEngine {
 				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");
+					Errors.inst.printError(EK_ENG_NOOPENING);
 					return false;
 				}
 
@@ -333,6 +334,11 @@ public class DiceLangEngine {
 			}
 		}
 
+		if(curBraceCount > 0) {
+			Errors.inst.printError(EK_ENG_NOCLOSING);
+			return false;
+		}
+
 		if(debugMode && !postfixMode)
 			System.out.printf("\tCommand after pre-shunter removal: %s\n", preparedTokens.toString());
 
@@ -388,7 +394,13 @@ public class DiceLangEngine {
 			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));
+				Evaluator.Result res = eval.evaluate(ast);
+				System.out.printf("\t\tEvaluates to %s", res);
+
+				if(res.type == Evaluator.Result.Type.DICE) {
+					System.out.println(" (sample roll " + res.diceVal.value() + ")");
+				}
+
 				treeNo += 1;
 			}
 		}
@@ -445,7 +457,7 @@ public class DiceLangEngine {
 					tk = new Token(CBRACE, token.length());
 					break;
 				default:
-					System.out.println("\tERROR: Unrecognized grouping token " + token);
+					Errors.inst.printError(EK_TOK_UNGROUP, token);
 					break;
 			}
 		}
@@ -468,8 +480,21 @@ public class DiceLangEngine {
 
 			tk = new Token(INT_LIT, Long.parseLong(newToken.substring(2).toUpperCase(), 16));
 		} else if(flexadecimalMatcher.matcher(token).matches()) {
-			tk = new Token(INT_LIT, Long.parseLong(token.substring(0, token.lastIndexOf('B')),
-						Integer.parseInt(token.substring(token.lastIndexOf('B') + 1))));
+			int parseBase = Integer.parseInt(token.substring(token.lastIndexOf('B') + 1));
+
+			if(parseBase < Character.MIN_RADIX || parseBase > Character.MAX_RADIX) {
+				Errors.inst.printError(EK_TOK_INVBASE, Integer.toString(parseBase));
+				return Token.NIL_TOKEN;
+			}
+
+			String flexNum = token.substring(0, token.lastIndexOf('B'));
+
+			try {
+				tk = new Token(INT_LIT, Long.parseLong(flexNum, parseBase));
+			} catch (NumberFormatException nfex) {
+				Errors.inst.printError(EK_TOK_INVFLEX, flexNum, Integer.toString(parseBase));
+				return Token.NIL_TOKEN;
+			}
 		} else if(DoubleMatcher.floatingLiteral.matcher(token).matches()) {
 			tk = new Token(FLOAT_LIT, Double.parseDouble(token));
 		} else if(DiceBox.isValidExpression(token)) {
diff --git a/dice-lang/src/bjc/dicelang/v2/Errors.java b/dice-lang/src/bjc/dicelang/v2/Errors.java
new file mode 100644
index 0000000..c358214
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/Errors.java
@@ -0,0 +1,232 @@
+package bjc.dicelang.v2;
+
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
+
+public class Errors {
+	public static enum ErrorKey {
+		// Define Errors
+		// Incorrect define guard syntax
+		EK_DFN_PREDSYN,
+		// Incorrect define search syntax
+		EK_DFN_SRCSYN,
+		// Recursive define recursed too many times
+		EK_DFN_RECUR,
+
+		// Console Errors
+		// Unknown console pragma
+		EK_CONS_INVPRAG,
+		// Improperly formatted define
+		EK_CONS_INVDEFINE,
+
+		// Language Engine Errors
+		// Found closing doublebrace w/out opening doublebrace
+		EK_ENG_NOOPENING,
+		// Reached end of command w/out balanced doublebraces
+		EK_ENG_NOCLOSING,
+		
+		// Tokenizer Errors
+		// Found an unexpected grouping token
+		EK_TOK_UNGROUP,
+		// Invalid base for a flexadecimal number
+		EK_TOK_INVBASE,
+		// Invalid flexadecimal number in a given base
+		EK_TOK_INVFLEX,
+		
+		// Evaluator Errors
+		// Unknown node type
+		EK_EVAL_INVNODE,
+		// Incorrect # of args to binary operator
+		EK_EVAL_INVBIN,
+		// Unknown binary operator
+		EK_EVAL_UNBIN,
+		// Math on strings doesn't work
+		EK_EVAL_STRINGMATH,
+		// Attempted divide by zero
+		EK_EVAL_DIVZERO,
+		// Unknown math operator
+		EK_EVAL_UNMATH,
+		// Unknown token reference
+		EK_EVAL_UNTOK,
+		// Unknown dice operator
+		EK_EVAL_UNDICE,
+		// Incorrect type to dice group operator
+		EK_EVAL_INVDGROUP,
+		// Incorrect type to other dice operator
+		EK_EVAL_INVDICE,
+
+		// Parser Error
+		// Group closing where there couldn't be an opener
+		EK_PARSE_NOCLOSE,
+		// Group closing without group opener
+		EK_PARSE_UNCLOSE,
+		// Incorrect # of arguments to binary operator
+		EK_PARSE_BINARY,
+		// Not enough operands to binary operator
+		EK_PARSE_UNOPERAND,
+		// Unrecognized token type
+		EK_PARSE_INVTOKEN,
+
+		// Shunter Error
+		// Unary operator expected a operand, but got an operator
+		EK_SHUNT_NOTADV,
+		// Unary operator expected an operator, but got an operand
+		EK_SHUNT_NOTADJ,
+		// Unary operator expected an operator, but didn't find one
+		EK_SHUNT_NOOP,
+		// Asked for opening grouping operator, but couldn't find one
+		EK_SHUNT_NOGROUP,
+		// No group for group seperator to attach to
+		EK_SHUNT_INVSEP,
+
+		// Stream Errors
+		// Attempted to switch to a non-existant stream
+		EK_STRM_NONEX,
+		// Can't delete the last stream
+		EK_STRM_LAST,
+		// Unknown stream command
+		EK_STRM_INVCOM,
+
+	}
+
+	public static enum ErrorMode {
+		WIZARD, DEV
+	}
+
+	private ErrorMode mode;
+
+	public void printError(ErrorKey key, String... args) {
+		switch(mode) {
+			case WIZARD:
+				System.out.println("\t? " + key.ordinal());
+				break;
+			case DEV:
+				devError(key, args);
+				break;
+			default:
+				System.out.println("\tERROR ERROR: Unknown error mode " + mode);
+		}
+	}
+
+	private void devError(ErrorKey key, String[] args) {
+		switch(key) {
+			case EK_DFN_PREDSYN:
+				System.out.printf("\tERROR: Incorrect define guard syntax %s\n", args[0]);
+				break;
+			case EK_DFN_SRCSYN:
+				System.out.printf("\tERROR: Incorrect define match syntax %s\n", args[0]);
+				break;
+			case EK_DFN_RECUR:
+				System.out.printf("\tERROR: Recursive define didn't converge after %s iterations."
+						+ " Original string was %s, last iteration was %s\n",
+						args[0], args[1], args[2]);
+				break;
+			case EK_CONS_INVPRAG:
+				System.out.printf("\tERROR: Unknown pragma %s\n", args[0]);
+				break;
+			case EK_CONS_INVDEFINE:
+				System.out.printf("\tERROR: Improperly formatted define %s\n", args[0]);
+				break;
+			case EK_ENG_NOOPENING:
+				System.out.printf("\tERROR: Encountered closing doublebrace without"
+						+ " matching opening doublebrace\n");
+				break;
+			case EK_ENG_NOCLOSING:
+				System.out.printf("\tERROR: Reached end of string before closing doublebrace was found\n");
+				break;
+			case EK_TOK_UNGROUP:
+				System.out.printf("\tERROR: Unrecognized grouping token %s\n", args[0]);
+				break;
+			case EK_TOK_INVBASE:
+				System.out.printf("\tERROR: Invalid flexadecimal base %s\n", args[0]);
+				break;
+			case EK_TOK_INVFLEX:
+				System.out.printf("\tERROR: Invalid flexadecimal number %s in base %s\n", args[0], args[1]);
+				break;
+			case EK_EVAL_INVNODE:
+				System.out.printf("\tERROR: Unknown node in evaluator: %s\n", args[0]);
+				break;
+			case EK_EVAL_INVBIN:
+				System.out.printf("\tERROR: Binary operators take 2 operand, not %s\n", args[0]);
+				break;
+			case EK_EVAL_UNBIN:
+				System.out.printf("\tERROR: Unknown binary operator %s\n", args[0]);
+				break;
+			case EK_EVAL_STRINGMATH:
+				System.out.printf("\tERROR: Math operators don't work on strings\n");
+				break;
+			case EK_EVAL_DIVZERO:
+				System.out.printf("\tERROR: Attempted divide by zero\n");
+				break;
+			case EK_EVAL_UNMATH:
+				System.out.printf("\tERROR: Unknown math binary operator: %s\n", args[0]);
+				break;
+			case EK_EVAL_UNTOK:
+				System.out.printf("\tERROR: Unknown token ref %s\n", args[0]);
+				break;
+			case EK_EVAL_UNDICE:
+				System.out.printf("\tERROR: Unknown dice operator %s\n", args[0]);
+				break;
+			case EK_EVAL_INVDGROUP:
+				System.out.printf("\tERROR: Dice group operator expects scalar dice or integers,"
+						+ " not %s\n", args[0]);
+				break;
+			case EK_EVAL_INVDICE:
+				System.out.printf("\tERROR: Dice operators expect scalar dice, not %s\n", args[0]);
+				break;
+			case EK_PARSE_NOCLOSE:
+				System.out.printf("\tERROR: Group closing with no possible group opener\n");
+				break;
+			case EK_PARSE_UNCLOSE:
+				System.out.printf("\tERROR: Found group closer without opener: (closing was %s"
+						+ ", expected %s)\n", args[0], args[1]);
+				break;
+			case EK_PARSE_BINARY:
+				System.out.printf("\tERROR: Expected at least two operands\n");
+				break;
+			case EK_PARSE_UNOPERAND:
+				System.out.printf("\tERROR: Operator %s expected more operands than provided\n", args[0]);
+				break;
+			case EK_PARSE_INVTOKEN:
+				System.out.printf("\tERROR: Unrecognized token type in parsing: %s\n", args[0]);
+				break;
+			case EK_SHUNT_NOTADV:
+				System.out.printf("\tERROR: Unary operator %s is an adjective, not an adverb. It can't be"
+						+ " applied to the operator %s\n", args[0], args[1]);
+				break;
+			case EK_SHUNT_NOTADJ:
+				System.out.printf("\tERROR: Unary operator %s is an adjective, not an adverb. It can't be"
+						+ " applied to the operator %s\n", args[0], args[1]);
+				break;
+			case EK_SHUNT_NOOP:
+				System.out.printf("\tERROR: Unary operator %s is an adverb, but there is no operator"
+						+ " to apply it to\n", args[0]);
+				break;
+			case EK_SHUNT_NOGROUP:
+				System.out.printf("\tERROR: Couldn't find matching grouping %s (expected %s)\n",
+						args[0], args[1]);
+				break;
+			case EK_SHUNT_INVSEP:
+				System.out.printf("\tERROR: Couldn't find grouper for group seperator to attach to\n");
+				break;
+			case EK_STRM_NONEX:
+				System.out.printf("\tERROR: Attempted to switch to non-existent stream\n");
+				break;
+			case EK_STRM_LAST:
+				System.out.printf("\tERROR: Cannot delete last stream\n");
+				break;
+			case EK_STRM_INVCOM:
+				System.out.printf("\tERROR: Unknown stream control command %s\n", args[0]);
+				break;
+			default:
+				System.out.printf("\tERROR ERROR: Unknown error key %s\n", key);
+		}
+	}
+
+	public final static Errors inst;
+
+	static {
+		inst = new Errors();
+
+		inst.mode = ErrorMode.DEV;
+	}
+}
diff --git a/dice-lang/src/bjc/dicelang/v2/Evaluator.java b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
index d9efbea..ef50364 100644
--- a/dice-lang/src/bjc/dicelang/v2/Evaluator.java
+++ b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
@@ -4,11 +4,14 @@ import bjc.utils.data.ITree;
 import bjc.utils.data.Tree;
 import bjc.utils.data.TopDownTransformResult;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
+import static bjc.dicelang.v2.Evaluator.Result.Type.*;
+
 public class Evaluator {
 	public static class Result {
 		public static enum Type {
 			FAILURE,
-			INT, FLOAT, DICE
+			INT, FLOAT, DICE, STRING
 		}
 
 		public final Type type;
@@ -18,6 +21,7 @@ public class Evaluator {
 		public long intVal;
 		public double floatVal;
 		public DiceBox.DieExpression diceVal;
+		public String stringVal;
 
 		public Result(Type typ) {
 			type = typ;
@@ -41,6 +45,24 @@ public class Evaluator {
 			diceVal = dVal;
 		}
 
+		public Result(Type typ, DiceBox.Die dVal) {
+			this(typ);
+
+			diceVal = new DiceBox.DieExpression(dVal);
+		}
+
+		public Result(Type typ, DiceBox.DieList dVal) {
+			this(typ);
+
+			diceVal = new DiceBox.DieExpression(dVal);
+		}
+
+		public Result(Type typ, String strang) {
+			this(typ);
+
+			stringVal = strang;
+		}
+
 		public String toString() {
 			switch(type) {
 				case INT:
@@ -49,6 +71,8 @@ public class Evaluator {
 					return type.toString() + "(" + floatVal + ")";
 				case DICE:
 					return type.toString() + "(" + diceVal + ")";
+				case STRING:
+					return type.toString() + "(" + stringVal + ")";
 				case FAILURE:
 					return type.toString();
 				default:
@@ -57,6 +81,8 @@ public class Evaluator {
 		}
 	}
 
+	private final static Node FAIL = new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE));
+
 	private DiceLangEngine eng;
 
 	public Evaluator(DiceLangEngine en) {
@@ -78,14 +104,16 @@ public class Evaluator {
 		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)));
+				return new Tree<>(FAIL);
 			case BINOP:
 				return evaluateBinaryOp(ast);
 			case TOKREF:
 				return evaluateTokenRef(ast.getHead().tokenVal);
+			case ROOT:
+				return ast.getChild(ast.getChildrenCount() - 1);
 			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)));
+				Errors.inst.printError(EK_EVAL_INVNODE, ast.getHead().type.toString());
+				return new Tree<>(FAIL);
 		}
 	}
 
@@ -93,8 +121,9 @@ public class Evaluator {
 		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)));
+			Errors.inst.printError(EK_EVAL_INVBIN, Integer.toString(ast.getChildrenCount()));
+
+			return new Tree<>(FAIL);
 		}
 
 		ITree<Node> left  = ast.getChild(0);
@@ -107,17 +136,85 @@ public class Evaluator {
 			case DIVIDE:
 			case IDIVIDE:
 				return evaluateMathBinary(binOp, left.getHead().resultVal, right.getHead().resultVal);
+			case DICEGROUP:
+			case DICECONCAT:
+			case DICELIST:
+				return evaluateDiceBinary(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)));
+				Errors.inst.printError(EK_EVAL_UNBIN, binOp.toString());
+				return new Tree<>(FAIL);
 		}
 	}
 
-	private ITree<Node> evaluateMathBinary(Token.Type op, Result left, Result right) {
-		Result.Type resultType;
+	private ITree<Node> evaluateDiceBinary(Token.Type op, Result left, Result right) {
+		Result res = null;
 
+		switch(op) {
+			case DICEGROUP:
+				if(left.type == DICE && !left.diceVal.isList) {
+					if(right.type == DICE && !right.diceVal.isList) {
+						res = new Result(DICE, new DiceBox.SimpleDie(left.diceVal.scalar,
+									right.diceVal.scalar));
+					} else if (right.type == INT) {
+						res = new Result(DICE, new DiceBox.SimpleDie(left.diceVal.scalar, right.intVal));
+					} else {
+						Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
+						return new Tree<>(FAIL);
+					}
+				} else if(left.type == INT) {
+					if(right.type == DICE && !right.diceVal.isList) {
+						res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.diceVal.scalar));
+					} else if (right.type == INT) {
+						res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.intVal));
+					} else {
+						Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
+						return new Tree<>(FAIL);
+					}
+				} else {
+					Errors.inst.printError(EK_EVAL_INVDGROUP, left.type.toString());
+					return new Tree<>(FAIL);
+				}
+			case DICECONCAT:
+				if(left.type != DICE || left.diceVal.isList) {
+					Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString());
+					return new Tree<>(FAIL);
+				} else if(right.type != DICE || right.diceVal.isList) {
+					Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
+					return new Tree<>(FAIL);
+				} else {
+					res = new Result(DICE, new DiceBox.CompoundDie(left.diceVal.scalar,
+								right.diceVal.scalar));
+				}
+				break;
+			case DICELIST:
+				if(left.type != DICE || left.diceVal.isList) {
+					Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString());
+					return new Tree<>(FAIL);
+				} else if(right.type != DICE || right.diceVal.isList) {
+					Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
+					return new Tree<>(FAIL);
+				} else {
+					res = new Result(DICE, new DiceBox.SimpleDieList(left.diceVal.scalar,
+								right.diceVal.scalar));
+				}
+				break;
+			default:
+				Errors.inst.printError(EK_EVAL_UNDICE, op.toString());
+				return new Tree<>(FAIL);
+		}
+
+		return new Tree<>(new Node(Node.Type.RESULT, res));
+	}
+
+	private ITree<Node> evaluateMathBinary(Token.Type op, Result left, Result right) {
 		if(left.type == Result.Type.DICE || right.type == Result.Type.DICE) {
 			System.out.println("\tEVALUATOR ERROR: Math on dice isn't supported yet");
+			return new Tree<>(FAIL);
+		} else if(left.type == Result.Type.STRING || right.type == Result.Type.STRING) {
+			System.out.println("\tERROR: Math operators don't work on strings");
+			return new Tree<>(FAIL);
+		} else if(left.type == Result.Type.FAILURE || right.type == Result.Type.FAILURE) {
+			return new Tree<>(FAIL);
 		}
 
 		Result res = null;
@@ -172,14 +269,14 @@ public class Evaluator {
 				if(left.type == Result.Type.INT) {
 					if(right.type == Result.Type.INT) {
 						if(right.intVal == 0) {
-							System.out.println("\tERROR: Attempted divide by zero");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							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");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							res = new Result(Result.Type.FAILURE);
 						} else {
 							res = new Result(Result.Type.FLOAT, left.intVal / right.floatVal);
@@ -188,14 +285,14 @@ public class Evaluator {
 				} else {
 					if(right.type == Result.Type.INT) {
 						if(right.intVal == 0) {
-							System.out.println("\tERROR: Attempted divide by zero");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							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");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							res = new Result(Result.Type.FAILURE);
 						} else {
 							res = new Result(Result.Type.FLOAT, left.floatVal / right.floatVal);
@@ -207,14 +304,14 @@ public class Evaluator {
 				if(left.type == Result.Type.INT) {
 					if(right.type == Result.Type.INT) {
 						if(right.intVal == 0) {
-							System.out.println("\tERROR: Attempted divide by zero");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							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");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							res = new Result(Result.Type.FAILURE);
 						} else {
 							res = new Result(Result.Type.INT, (int) (left.intVal / right.floatVal));
@@ -223,14 +320,14 @@ public class Evaluator {
 				} else {
 					if(right.type == Result.Type.INT) {
 						if(right.intVal == 0) {
-							System.out.println("\tERROR: Attempted divide by zero");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							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");
+							Errors.inst.printError(EK_EVAL_DIVZERO);
 							res = new Result(Result.Type.FAILURE);
 						} else {
 							res = new Result(Result.Type.INT, (int) (left.floatVal / right.floatVal));
@@ -239,24 +336,34 @@ public class Evaluator {
 				}
 				break;
 			default:
-				System.out.println("\tERROR: Unknown math binary operator: " + op);
-				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+				Errors.inst.printError(EK_EVAL_UNMATH, op.toString());
+				return new Tree<>(FAIL);
 		}
 
 		return new Tree<>(new Node(Node.Type.RESULT, res));
 	}
 
 	private ITree<Node> evaluateTokenRef(Token tk) {
+		Result res = null;
+
 		switch(tk.type) {
 			case INT_LIT:
-				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.INT, tk.intValue)));
+				res = new Result(Result.Type.INT, tk.intValue);
+				break;
 			case FLOAT_LIT:
-				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FLOAT, tk.floatValue)));
+				res = new Result(Result.Type.FLOAT, tk.floatValue);
+				break;
 			case DICE_LIT:
-				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.DICE, tk.diceValue)));
+				res = new Result(Result.Type.DICE, tk.diceValue);
+				break;
+			case STRING_LIT:
+				res = new Result(Result.Type.STRING, eng.stringLits.get((int)(tk.intValue)));
+				break;
 			default:
-				System.out.println("\tERROR: Unknown token ref: " + tk.type);
-				return new Tree<>(new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE)));
+				Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString());
+				res = new Result(Result.Type.FAILURE);
 		}
+
+		return new Tree<>(new Node(Node.Type.RESULT, res));
 	}
 }
diff --git a/dice-lang/src/bjc/dicelang/v2/Parser.java b/dice-lang/src/bjc/dicelang/v2/Parser.java
index 0e778b4..9a873f1 100644
--- a/dice-lang/src/bjc/dicelang/v2/Parser.java
+++ b/dice-lang/src/bjc/dicelang/v2/Parser.java
@@ -7,6 +7,7 @@ import bjc.utils.data.ITree;
 import bjc.utils.data.Tree;
 import bjc.utils.funcdata.IList;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
 import static bjc.dicelang.v2.Node.Type.*;
 import static bjc.dicelang.v2.Token.Type.*;
 
@@ -28,7 +29,7 @@ public class Parser {
 				case CBRACKET:
 				case CBRACE:
 					if(working.size() == 0) {
-						System.out.println("\tERROR: Group closing with no possible group opener");
+						Errors.inst.printError(EK_PARSE_NOCLOSE);
 						return false;
 					}
 					
@@ -54,8 +55,7 @@ public class Parser {
 					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 + ")");
+						Errors.inst.printError(EK_PARSE_UNCLOSE, tk.toString(), matchNode.toString());
 
 						System.out.println("\tCurrent forest is: ");
 
@@ -63,6 +63,7 @@ public class Parser {
 						for(ITree<Node> ast : working) {
 							System.out.println("Tree " + treeNo++ + ": " + ast.toString());
 						}
+
 						return false;
 					} else {
 						Deque<ITree<Node>> childs = new LinkedList<>();
@@ -84,7 +85,8 @@ public class Parser {
 				case LET:
 				case BIND:
 					if(working.size() < 2) {
-						System.out.println("\tERROR: Let and bind require at least two operands");
+						Errors.inst.printError(EK_PARSE_BINARY);
+						return false;
 					} else {
 						ITree<Node> right = working.pop();
 						ITree<Node> left  = working.pop();
@@ -103,7 +105,7 @@ public class Parser {
 				case DICECONCAT:
 				case DICELIST:
 					if(working.size() == 0) {
-						System.out.println("\tERROR: Binary operator " + tk.type + " requires more operands than provided.");
+						Errors.inst.printError(EK_PARSE_UNOPERAND, tk.toString());
 						return false;
 					} else if(working.size() == 1) {
 						ITree<Node> operand = working.pop();
@@ -133,7 +135,7 @@ public class Parser {
 					working.push(new Tree<>(new Node(TOKREF, tk)));
 					break;
 				default:
-					System.out.println("\tERROR: Unrecognized token type in parsing: " + tk.type);
+					Errors.inst.printError(EK_PARSE_INVTOKEN, tk.type.toString());
 					return false;
 			}
 		}
diff --git a/dice-lang/src/bjc/dicelang/v2/Shunter.java b/dice-lang/src/bjc/dicelang/v2/Shunter.java
index 7e17e6f..014be7d 100644
--- a/dice-lang/src/bjc/dicelang/v2/Shunter.java
+++ b/dice-lang/src/bjc/dicelang/v2/Shunter.java
@@ -10,6 +10,7 @@ import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Set;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
 import static bjc.dicelang.v2.Token.Type.*;
 
 public class Shunter {
@@ -73,10 +74,7 @@ public class Shunter {
 						|| unaryAdjectives.contains(tk.type);
 
 					if(isOp) {
-						System.out.printf("\tError: Unary operator %s is an"
-								+ " adjective, not an adverb (can't be applied"
-								+ " to operator %s)\n", currOperator, tk );
-						
+						Errors.inst.printError(EK_SHUNT_NOTADV, currOperator.toString(), tk.toString());
 						return false;
 					}
 
@@ -84,8 +82,8 @@ public class Shunter {
 					currReturned.addLast(unaryOps.pop());
 				} else if (unaryAdverbs.contains(currOperator.type)) {
 					if(opStack.size() < 1) {
-						System.out.printf("\tError: Unary operators %s is an adverb,"
-								+ " but there is no operator to apply it to\n");
+						Errors.inst.printError(EK_SHUNT_NOOP, currOperator.toString());
+						return false;
 					}
 
 					Token currOperand = opStack.peek();
@@ -95,9 +93,9 @@ public class Shunter {
 						|| unaryAdjectives.contains(currOperand.type);
 
 					if(!isOp) {
-						System.out.printf("\tError: Unary operator %s is an adverb,"
-								+ " not an  adjective (can't be applied to operand %s)\n",
-								currOperator, tk);
+						Errors.inst.printError(EK_SHUNT_NOTADJ,
+								currOperator.toString(),
+								tk.toString());
 						
 						return false;
 					}
@@ -140,9 +138,8 @@ public class Shunter {
 					}
 
 					if(!opStack.contains(matching)) {
-						System.out.printf("\tError: Could not find matching grouping "
-								+ tk.type);
-
+						Errors.inst.printError(EK_SHUNT_NOGROUP,
+								tk.toString(), matching.toString());
 						return false;
 					}
 
@@ -167,7 +164,7 @@ public class Shunter {
 					}
 
 					if(currReturned.size() == 0) {
-						System.out.println("\tERROR: Didn't find grouper for group seperator to attach to");
+						Errors.inst.printError(EK_SHUNT_INVSEP);
 						return false;
 					}
 
diff --git a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
index 39bbc0d..8755e19 100644
--- a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
@@ -2,9 +2,12 @@ package bjc.dicelang.v2;
 
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
+import bjc.utils.funcutils.ListUtils;
 import bjc.utils.esodata.SingleTape;
 import bjc.utils.esodata.Tape;
 
+import static bjc.dicelang.v2.Errors.ErrorKey.*;
+
 public class StreamEngine {
 	private DiceLangEngine eng;
 
@@ -25,11 +28,24 @@ public class StreamEngine {
 	public boolean doStreams(String[] toks, IList<String> dest) {
 		init();
 
+		boolean quoteMode = false;
+
 		for(String tk : toks) {
-			if(tk.startsWith("{@S")) {
-				if(!processCommand(tk)) return false;
+			if(tk.startsWith("{@S") && !quoteMode) {
+				if(tk.equals("{@SQ}")) {
+					quoteMode = true;
+				} else if(!processCommand(tk)) {
+					return false;
+				}
+				// Command ran correctly, continue
 			} else {
-				currStream.add(tk);
+				if(tk.equals("{@SU}")) {
+					quoteMode = false;
+				} else if(tk.equals("\\{@SU}")) {
+					currStream.add("{@SU}");
+				} else {
+					currStream.add(tk);
+				}
 			}
 		}
 
@@ -57,7 +73,7 @@ public class StreamEngine {
 					break;
 				case '>':
 					if(!streams.right()) {
-						System.out.println("\tERROR: Attempted to switch to non-existent stream");
+						Errors.inst.printError(EK_STRM_NONEX);
 						return false;
 					}
 
@@ -65,7 +81,7 @@ public class StreamEngine {
 					break;
 				case '<':
 					if(!streams.left()) {
-						System.out.println("\tERROR: Attempted to switch to non-existent stream");
+						Errors.inst.printError(EK_STRM_NONEX);
 						return false;
 					}
 
@@ -73,15 +89,25 @@ public class StreamEngine {
 					break;
 				case '-':
 					if(streams.size() == 1) {
-						System.out.println("\tERROR: Cannot delete last stream");
+						Errors.inst.printError(EK_STRM_LAST);
 						return false;
 					} else {
 						streams.remove();
 						currStream = streams.item();
 					}
 					break;
+				case 'S':
+					if(streams.size() == 1) {
+						Errors.inst.printError(EK_STRM_LAST);
+						return false;
+					} else {
+						IList<String> stringLit = streams.remove();
+						currStream = streams.item();
+						currStream.add(ListUtils.collapseTokens(stringLit, " "));
+					}
+					break;
 				default:
-					System.out.println("\tERROR: Unknown stream control command: " + tk);
+					Errors.inst.printError(EK_STRM_INVCOM, tk);
 					return false;
 			}
 		}
diff --git a/dice-lang/tags b/dice-lang/tags
index 6b1a426..16016c1 100644
--- a/dice-lang/tags
+++ b/dice-lang/tags
@@ -36,11 +36,12 @@ CompoundDice	src/bjc/dicelang/CompoundDice.java	/^	public CompoundDice(String lf
 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
+CompoundDie	src/bjc/dicelang/v2/DiceBox.java	/^	public static class CompoundDie implements Die {$/;"	c	class:DiceBox
 ConstantCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^public class ConstantCollapser implements IOptimizationPass {$/;"	c
+DEV	src/bjc/dicelang/v2/Errors.java	/^		WIZARD, DEV$/;"	e	enum:Errors.ErrorMode	file:
 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:
+DICE	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE, STRING$/;"	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:
@@ -97,16 +98,61 @@ Digits	src/bjc/dicelang/v2/DoubleMatcher.java	/^	private static final String Dig
 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
+EK_CONS_INVDEFINE	src/bjc/dicelang/v2/Errors.java	/^		EK_CONS_INVDEFINE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_CONS_INVPRAG	src/bjc/dicelang/v2/Errors.java	/^		EK_CONS_INVPRAG,$/;"	e	enum:Errors.ErrorKey	file:
+EK_DFN_PREDSYN	src/bjc/dicelang/v2/Errors.java	/^		EK_DFN_PREDSYN,$/;"	e	enum:Errors.ErrorKey	file:
+EK_DFN_RECUR	src/bjc/dicelang/v2/Errors.java	/^		EK_DFN_RECUR,$/;"	e	enum:Errors.ErrorKey	file:
+EK_DFN_SRCSYN	src/bjc/dicelang/v2/Errors.java	/^		EK_DFN_SRCSYN,$/;"	e	enum:Errors.ErrorKey	file:
+EK_ENG_NOCLOSING	src/bjc/dicelang/v2/Errors.java	/^		EK_ENG_NOCLOSING,$/;"	e	enum:Errors.ErrorKey	file:
+EK_ENG_NOOPENING	src/bjc/dicelang/v2/Errors.java	/^		EK_ENG_NOOPENING,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_DIVZERO	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_DIVZERO,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_INVBIN	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_INVBIN,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_INVDGROUP	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_INVDGROUP,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_INVDICE	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_INVDICE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_INVNODE	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_INVNODE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_STRINGMATH	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_STRINGMATH,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_UNBIN	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_UNBIN,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_UNDICE	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_UNDICE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_UNMATH	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_UNMATH,$/;"	e	enum:Errors.ErrorKey	file:
+EK_EVAL_UNTOK	src/bjc/dicelang/v2/Errors.java	/^		EK_EVAL_UNTOK,$/;"	e	enum:Errors.ErrorKey	file:
+EK_PARSE_BINARY	src/bjc/dicelang/v2/Errors.java	/^		EK_PARSE_BINARY,$/;"	e	enum:Errors.ErrorKey	file:
+EK_PARSE_INVTOKEN	src/bjc/dicelang/v2/Errors.java	/^		EK_PARSE_INVTOKEN,$/;"	e	enum:Errors.ErrorKey	file:
+EK_PARSE_NOCLOSE	src/bjc/dicelang/v2/Errors.java	/^		EK_PARSE_NOCLOSE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_PARSE_UNCLOSE	src/bjc/dicelang/v2/Errors.java	/^		EK_PARSE_UNCLOSE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_PARSE_UNOPERAND	src/bjc/dicelang/v2/Errors.java	/^		EK_PARSE_UNOPERAND,$/;"	e	enum:Errors.ErrorKey	file:
+EK_SHUNT_INVSEP	src/bjc/dicelang/v2/Errors.java	/^		EK_SHUNT_INVSEP,$/;"	e	enum:Errors.ErrorKey	file:
+EK_SHUNT_NOGROUP	src/bjc/dicelang/v2/Errors.java	/^		EK_SHUNT_NOGROUP,$/;"	e	enum:Errors.ErrorKey	file:
+EK_SHUNT_NOOP	src/bjc/dicelang/v2/Errors.java	/^		EK_SHUNT_NOOP,$/;"	e	enum:Errors.ErrorKey	file:
+EK_SHUNT_NOTADJ	src/bjc/dicelang/v2/Errors.java	/^		EK_SHUNT_NOTADJ,$/;"	e	enum:Errors.ErrorKey	file:
+EK_SHUNT_NOTADV	src/bjc/dicelang/v2/Errors.java	/^		EK_SHUNT_NOTADV,$/;"	e	enum:Errors.ErrorKey	file:
+EK_STRM_INVCOM	src/bjc/dicelang/v2/Errors.java	/^		EK_STRM_INVCOM,$/;"	e	enum:Errors.ErrorKey	file:
+EK_STRM_LAST	src/bjc/dicelang/v2/Errors.java	/^		EK_STRM_LAST,$/;"	e	enum:Errors.ErrorKey	file:
+EK_STRM_NONEX	src/bjc/dicelang/v2/Errors.java	/^		EK_STRM_NONEX,$/;"	e	enum:Errors.ErrorKey	file:
+EK_TOK_INVBASE	src/bjc/dicelang/v2/Errors.java	/^		EK_TOK_INVBASE,$/;"	e	enum:Errors.ErrorKey	file:
+EK_TOK_INVFLEX	src/bjc/dicelang/v2/Errors.java	/^		EK_TOK_INVFLEX,$/;"	e	enum:Errors.ErrorKey	file:
+EK_TOK_UNGROUP	src/bjc/dicelang/v2/Errors.java	/^		EK_TOK_UNGROUP,$/;"	e	enum:Errors.ErrorKey	file:
 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:
+ErrorKey	src/bjc/dicelang/v2/Errors.java	/^	public static enum ErrorKey {$/;"	g	class:Errors
+ErrorMode	src/bjc/dicelang/v2/Errors.java	/^	public static enum ErrorMode {$/;"	g	class:Errors
+Errors	src/bjc/dicelang/v2/Errors.java	/^public class Errors {$/;"	c
 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:
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^		public ExplodingDice(Die src, Predicate<Long> explode) {$/;"	m	class:DiceBox.ExplodingDice
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^		public ExplodingDice(Die src, Predicate<Long> explode, String patt, boolean penetrate) {$/;"	m	class:DiceBox.ExplodingDice
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^		public ExplodingDice(Die src, Predicate<Long> explode, boolean penetrate) {$/;"	m	class:DiceBox.ExplodingDice
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^		public ExplodingDice(Die src, String patt) {$/;"	m	class:DiceBox.ExplodingDice
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^		public ExplodingDice(Die src, String patt, boolean penetrate) {$/;"	m	class:DiceBox.ExplodingDice
+ExplodingDice	src/bjc/dicelang/v2/DiceBox.java	/^	public class ExplodingDice implements DieList {$/;"	c	class:DiceBox
+FAIL	src/bjc/dicelang/v2/Evaluator.java	/^	private final static Node FAIL = new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE));$/;"	f	class:Evaluator	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	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE, STRING$/;"	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:
+FudgeDie	src/bjc/dicelang/v2/DiceBox.java	/^		public FudgeDie(long nDice) {$/;"	m	class:DiceBox.FudgeDie
+FudgeDie	src/bjc/dicelang/v2/DiceBox.java	/^	public static class FudgeDie implements Die {$/;"	c	class:DiceBox
 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:
@@ -116,7 +162,7 @@ IDIVIDE	src/bjc/dicelang/v2/Token.java	/^		DIVIDE,   IDIVIDE,$/;"	e	enum:Token.T
 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:
+INT	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE, STRING$/;"	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:
@@ -135,6 +181,7 @@ MATH	src/bjc/dicelang/ast/nodes/DiceOperatorType.java	/^	MATH,$/;"	e	enum:DiceOp
 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:
+MAX_RECURS	src/bjc/dicelang/v2/Define.java	/^	public static final int MAX_RECURS = 10;$/;"	f	class:Define
 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:
@@ -165,11 +212,15 @@ ROOT	src/bjc/dicelang/v2/Node.java	/^		 ROOT,    TOKREF,$/;"	e	enum:Node.Type	fi
 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.Die dVal) {$/;"	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, DiceBox.DieList dVal) {$/;"	m	class:Evaluator.Result
+Result	src/bjc/dicelang/v2/Evaluator.java	/^		public Result(Type typ, String strang) {$/;"	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	src/bjc/dicelang/v2/Evaluator.java	/^			INT, FLOAT, DICE, STRING$/;"	e	enum:Evaluator.Result.Type	file:
 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:
@@ -177,13 +228,16 @@ SUBTRACT	src/bjc/dicelang/v2/Token.java	/^		ADD,      SUBTRACT,$/;"	e	enum:Token
 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
+ScalarDie	src/bjc/dicelang/v2/DiceBox.java	/^	public 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(Die nDice, Die size) {$/;"	m	class:DiceBox.SimpleDie
+SimpleDie	src/bjc/dicelang/v2/DiceBox.java	/^		public SimpleDie(Die nDice, long size) {$/;"	m	class:DiceBox.SimpleDie
+SimpleDie	src/bjc/dicelang/v2/DiceBox.java	/^		public SimpleDie(long nDice, Die size) {$/;"	m	class:DiceBox.SimpleDie
 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
+SimpleDie	src/bjc/dicelang/v2/DiceBox.java	/^	public 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
+SimpleDieList	src/bjc/dicelang/v2/DiceBox.java	/^	public 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:
@@ -205,6 +259,7 @@ VARIABLE	src/bjc/dicelang/ast/nodes/DiceASTType.java	/^	VARIABLE;$/;"	e	enum:Dic
 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
+WIZARD	src/bjc/dicelang/v2/Errors.java	/^		WIZARD, DEV$/;"	e	enum:Errors.ErrorMode	file:
 accept	src/bjc/dicelang/ast/DiceASTReferenceChecker.java	/^	public void accept(IDiceASTNode astNode) {$/;"	m	class:DiceASTReferenceChecker
 actions	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	private static IMap<String, DiceASTPragma>	actions;$/;"	f	class:DiceASTLanguageTest	file:
 acts	src/bjc/dicelang/examples/DiceLanguageTest.java	/^	private static Map<String, BiConsumer<String, DiceLanguageState>> acts;$/;"	f	class:DiceLanguageTest	file:
@@ -273,6 +328,7 @@ bjc.dicelang.v2	src/bjc/dicelang/v2/DiceBox.java	/^package bjc.dicelang.v2;$/;"
 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/Errors.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
@@ -291,16 +347,19 @@ canOptimize	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public boolean
 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.ExplodingDice
+canOptimize	src/bjc/dicelang/v2/DiceBox.java	/^		public boolean canOptimize() {$/;"	m	class:DiceBox.FudgeDie
 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:
+comparePoint	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String comparePoint         = "[<>=]\\\\d+";$/;"	f	class:DiceBox	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:
+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       = "(?:(?:\\\\d+)|(?:" + 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:
@@ -326,9 +385,11 @@ deaffixationList	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private List<IPair<S
 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:
+deriveCond	src/bjc/dicelang/v2/DiceBox.java	/^		private Predicate<Long> deriveCond(String patt) {$/;"	m	class:DiceBox.ExplodingDice	file:
+devError	src/bjc/dicelang/v2/Errors.java	/^	private void devError(ErrorKey key, String[] args) {$/;"	m	class:Errors	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 Die 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:
@@ -355,10 +416,15 @@ eval	src/bjc/dicelang/v2/DiceLangEngine.java	/^	private Evaluator eval;$/;"	f	cl
 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:
+evaluateDiceBinary	src/bjc/dicelang/v2/Evaluator.java	/^	private ITree<Node> evaluateDiceBinary(Token.Type op, Result left, Result right) {$/;"	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:
+evaluateMathBinary	src/bjc/dicelang/v2/Evaluator.java	/^	private ITree<Node> evaluateMathBinary(Token.Type op, Result left, Result right) {$/;"	m	class:Evaluator	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:
+explodeOn	src/bjc/dicelang/v2/DiceBox.java	/^		private Predicate<Long> explodeOn;$/;"	f	class:DiceBox.ExplodingDice	file:
+explodePattern	src/bjc/dicelang/v2/DiceBox.java	/^		private String          explodePattern;$/;"	f	class:DiceBox.ExplodingDice	file:
+explodePenetrates	src/bjc/dicelang/v2/DiceBox.java	/^		private boolean         explodePenetrates;$/;"	f	class:DiceBox.ExplodingDice	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:
@@ -368,6 +434,8 @@ floatingLiteral	src/bjc/dicelang/v2/DoubleMatcher.java	/^	public static final Pa
 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
+fudgeDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  fudgeDie            = "(?:\\\\d+)?dF";$/;"	f	class:DiceBox	file:
+fudgeDiePattern	src/bjc/dicelang/v2/DiceBox.java	/^	private static final Pattern fudgeDiePattern     = Pattern.compile("\\\\A" + fudgeDie + "\\\\Z");$/;"	f	class:DiceBox	file:
 getData	src/bjc/dicelang/ast/DummyResult.java	/^	public String getData() {$/;"	m	class:DummyResult
 getLiteralType	src/bjc/dicelang/ast/nodes/DiceLiteralNode.java	/^	public DiceLiteralType getLiteralType() {$/;"	m	class:DiceLiteralNode
 getLiteralType	src/bjc/dicelang/ast/nodes/ILiteralDiceNode.java	/^	DiceLiteralType getLiteralType();$/;"	m	interface:ILiteralDiceNode
@@ -395,11 +463,13 @@ handlePragma	src/bjc/dicelang/v2/DiceLangConsole.java	/^	private boolean handleP
 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:
+inError	src/bjc/dicelang/v2/Define.java	/^	public final boolean inError;$/;"	f	class:Define
 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:
+inst	src/bjc/dicelang/v2/Errors.java	/^	public final static Errors inst;$/;"	f	class:Errors
 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
@@ -426,6 +496,7 @@ main	src/bjc/dicelang/examples/DiceASTLanguageTest.java	/^	public static void ma
 main	src/bjc/dicelang/examples/DiceExpressionParserTest.java	/^	public static void main(String[] args) {$/;"	m	class:DiceExpressionParserTest
 main	src/bjc/dicelang/examples/DiceLanguageTest.java	/^	public static void main(String[] args) {$/;"	m	class:DiceLanguageTest
 main	src/bjc/dicelang/v2/DiceLangConsole.java	/^	public static void main(String[] args) {$/;"	m	class:DiceLangConsole
+mode	src/bjc/dicelang/v2/Errors.java	/^	private ErrorMode mode;$/;"	f	class:Errors	file:
 multiply	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder multiply(IDiceExpression exp) {$/;"	m	class:DiceExpressionBuilder
 multiply	src/bjc/dicelang/DiceExpressionBuilder.java	/^	public DiceExpressionBuilder multiply(int num) {$/;"	m	class:DiceExpressionBuilder
 multiplyCollapser	src/bjc/dicelang/ast/optimization/ConstantCollapser.java	/^	private static final ArithmeticCollapser	multiplyCollapser	= new ArithmeticCollapser($/;"	f	class:ConstantCollapser	file:
@@ -436,8 +507,9 @@ name	src/bjc/dicelang/ReferenceDiceExpression.java	/^	private String							name;
 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.FudgeDie	file:
+numDice	src/bjc/dicelang/v2/DiceBox.java	/^		private Die numDice;$/;"	f	class:DiceBox.SimpleDie	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:
 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
@@ -453,8 +525,10 @@ optimize	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public int optimi
 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.FudgeDie
 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.ExplodingDice
 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
@@ -479,6 +553,7 @@ predicate	src/bjc/dicelang/v2/Define.java	/^	private Pattern predicate;$/;"	f	cl
 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:
+printError	src/bjc/dicelang/v2/Errors.java	/^	public void printError(ErrorKey key, String... args) {$/;"	m	class:Errors
 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:
@@ -504,15 +579,22 @@ roll	src/bjc/dicelang/ScalarDie.java	/^	public int roll() {$/;"	m	class:ScalarDi
 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.FudgeDie
 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.ExplodingDice
 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:
+rollSingle	src/bjc/dicelang/v2/DiceBox.java	/^		long rollSingle();$/;"	m	interface:DiceBox.Die
+rollSingle	src/bjc/dicelang/v2/DiceBox.java	/^		public long rollSingle() {$/;"	m	class:DiceBox.CompoundDie
+rollSingle	src/bjc/dicelang/v2/DiceBox.java	/^		public long rollSingle() {$/;"	m	class:DiceBox.FudgeDie
+rollSingle	src/bjc/dicelang/v2/DiceBox.java	/^		public long rollSingle() {$/;"	m	class:DiceBox.ScalarDie
+rollSingle	src/bjc/dicelang/v2/DiceBox.java	/^		public long rollSingle() {$/;"	m	class:DiceBox.SimpleDie
 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:
+scalarDie	src/bjc/dicelang/v2/DiceBox.java	/^	private static final String  scalarDie          = "[\\\\+\\\\-]?\\\\d+sd";$/;"	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
@@ -520,21 +602,23 @@ shouldContinuePopping	src/bjc/dicelang/ast/DiceASTParser.java	/^		private static
 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:
+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
+source	src/bjc/dicelang/v2/DiceBox.java	/^		private Die             source;$/;"	f	class:DiceBox.ExplodingDice	file:
 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:
+stringLits	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public final IMap<Integer, String> stringLits;$/;"	f	class:DiceLangEngine
+stringVal	src/bjc/dicelang/v2/Evaluator.java	/^		public String stringVal;$/;"	f	class:Evaluator.Result
 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:
+symTable	src/bjc/dicelang/v2/DiceLangEngine.java	/^	public final IMap<Integer, String> symTable;$/;"	f	class:DiceLangEngine
 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
@@ -553,6 +637,8 @@ toString	src/bjc/dicelang/ast/nodes/IntegerLiteralNode.java	/^	public String toS
 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.ExplodingDice
+toString	src/bjc/dicelang/v2/DiceBox.java	/^		public String toString() {$/;"	m	class:DiceBox.FudgeDie
 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