Lexer/shunter work

1 files changed, 130 insertions, 13 deletions

diff --git a/dice-lang/src/bjc/dicelang/v2/DiceBox.java b/dice-lang/src/bjc/dicelang/v2/DiceBox.java
index ac452e4..164530c 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceBox.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceBox.java
@@ -1,5 +1,6 @@
 package bjc.dicelang.v2;
 
+import java.util.Arrays;
 import java.util.Random;
 import java.util.regex.Pattern;
 
@@ -13,6 +14,42 @@ public class DiceBox {
 		int roll();
 	}
 
+	public interface DieList {
+		boolean canOptimize();
+		int[] optimize();
+
+		int[] roll();
+	}
+
+	public static class DieExpression {
+		public final boolean isList;
+
+		public Die     scalar;
+		public DieList list;
+
+		public DieExpression(Die scal) {
+			isList = false;
+
+			scalar = scal;
+		}
+
+		public DieExpression(DieList lst) {
+			isList = true;
+
+			list   = lst;
+		}
+
+		public String toString() {
+			if(isList) return list.toString();
+			else       return scalar.toString();
+		}
+
+		public String value() {
+			if(isList) return Arrays.toString(list.roll());
+			else       return Integer.toString(scalar.roll());
+		}
+	}
+
 	private static class ScalarDie implements Die {
 		private int val;
 
@@ -59,7 +96,7 @@ public class DiceBox {
 			int total = 0;
 
 			for(int i = 0; i < numDice; i++) {
-				total += rng.nextInt(i) + 1;
+				total += rng.nextInt(diceSize) + 1;
 			}
 
 			return total;
@@ -84,42 +121,120 @@ public class DiceBox {
 		}
 
 		public int optimize() {
-			return left.optimize() + "" + right.optimize();
+			return Integer.parseInt(left.optimize() + "" + right.optimize());
 		}
 
 		public int roll() {
 			return Integer.parseInt(left.roll() + "" + right.roll());
 		}
+
+		public String toString() {
+			return left.toString() + "c" + right.toString();
+		}
+	}
+
+	private static class SimpleDieList implements DieList {
+		private Die numDice;
+		private Die size;
+
+		public SimpleDieList(Die nDice, Die sze) {
+			numDice = nDice;
+			size = sze;
+		}
+
+		public boolean canOptimize() {
+			if(size.canOptimize() && size.optimize() == 1) {
+				return numDice.canOptimize();
+			} else {
+				return false;
+			}
+		}
+
+		public int[] optimize() {
+			int[] ret = new int[numDice.optimize()];
+
+			int optSize = size.optimize();
+
+			for(int i = 0; i < optSize; i++) {
+				ret[i] = 1;
+			}
+
+			return ret;
+		}
+
+		public int[] roll() {
+			int num = numDice.roll();
+
+			int[] ret = new int[num];
+
+			for(int i = 0; i < num; i++) {
+				ret[i] = size.roll();
+			}
+
+			return ret;
+		}
+
+		public String toString() {
+			return numDice.toString() + "dl" + size.toString();
+		}
 	}
 
-	public static Die parseExpression(String exp) {
+	public static DieExpression parseExpression(String exp) {
 		if(!isValidExpression(exp)) return null;
 
 		if(scalarDiePattern.matcher(exp).matches()) {
-			return new ScalarDie(Integer.parseInt(exp));
+			return new DieExpression(new ScalarDie(Integer.parseInt(exp)));
 		} else if(simpleDiePattern.matcher(exp).matches()) {
 			String[] dieParts = exp.split("d");
 
 			if(dieParts[0].equals("")) {
-				return new SimpleDie(1, Integer.parseInt(dieParts[1]));
+				return new DieExpression(new SimpleDie(1, Integer.parseInt(dieParts[1])));
 			} else {
-				return new SimpleDie(Integer.parseInt(dieParts[0]), Integer.parseInt(dieParts[1]));
+				return new DieExpression(new SimpleDie(Integer.parseInt(dieParts[0]), Integer.parseInt(dieParts[1])));
 			}
 		} else if(compoundDiePattern.matcher(exp).matches()) {
 			String[] dieParts = exp.split("c");
 
-			return new CompoundDie(parseExpression(dieParts[0]), parseExpression(dieParts[1]));
+			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(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));
 		}
 
+		// @TODO give a specific error message
 		return null;
 	}
 
-	private static final Pattern scalarDiePattern   = Pattern.compile(
-			"[\\+\\-]?\\d+");
-	private static final Pattern simpleDiePattern   = Pattern.compile(
-			"(?:\\d+)?d\\d+");
-	private static final Pattern compoundDiePattern = Pattern.compile(
-			simpleDiePattern + "c(?:(?:" + simpleDiePattern + ")|(?:\\d+))";
+	private static final String  scalarDie          = "[\\+\\-]?\\d+";
+	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  compoundDie        = simpleDie + "c(?:(?:" + simpleDie + ")|(?:\\d+))";
+	private static final Pattern compoundDiePattern = Pattern.compile("\\A" + compoundDie + "\\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");
 
 	public static boolean isValidExpression(String exp) {
 		if(scalarDiePattern.matcher(exp).matches()) {
@@ -128,6 +243,8 @@ public class DiceBox {
 			return true;
 		} else if (compoundDiePattern.matcher(exp).matches()) {
 			return true;
+		} else if (diceListPattern.matcher(exp).matches()) {
+			return true;
 		} else {
 			return false;
 		}