Update

3 files changed, 305 insertions, 263 deletions

diff --git a/RGens/src/main/.DS_Store b/RGens/src/main/.DS_Store
index 63b728b..8db16a3 100644
--- a/RGens/src/main/.DS_Store
+++ b/RGens/src/main/.DS_Store
diff --git a/RGens/src/main/java/bjc/RGens/server/GrammarServer.java b/RGens/src/main/java/bjc/RGens/server/GrammarServer.java
index afeb120..8c438c3 100644
--- a/RGens/src/main/java/bjc/RGens/server/GrammarServer.java
+++ b/RGens/src/main/java/bjc/RGens/server/GrammarServer.java
@@ -2,29 +2,28 @@ package bjc.RGens.server;
 
 import bjc.utils.funcdata.FunctionalMap;
 import bjc.utils.funcdata.IMap;
-import bjc.utils.funcdata.IList;
-import bjc.utils.funcutils.ListUtils;
 import bjc.utils.gen.WeightedGrammar;
 
 import java.io.File;
-import java.io.IOException;
-import java.io.FileInputStream;
 
 import java.util.Scanner;
 
 public class GrammarServer {
 	private Scanner scn;
 
-	public final IMap<String, WeightedGrammar<String>> loadedGrammars;
-
-	public final IMap<String, WeightedGrammar<String>> exportedRules;
-
+	private IMap<String, WeightedGrammar<String>> loadedGrammars;
+	private IMap<String, WeightedGrammar<String>> exportedRules;
+	
+	private GrammarServerEngine eng;
+	
 	public GrammarServer(Scanner scn) {
 		this.scn = scn;
 
 		this.loadedGrammars = new FunctionalMap<>();
 		this.exportedRules  = new FunctionalMap<>();
 
+		eng = new GrammarServerEngine(loadedGrammars, exportedRules);
+		
 		ServerGrammarReader.setExportedRules(exportedRules);
 	}
 
@@ -35,6 +34,8 @@ public class GrammarServer {
 
 		GrammarServer serv = new GrammarServer(scn);
 
+		CLIArgsParser.parseArgs(args, serv.eng);
+
 		System.out.print("Enter a command (m for help): ");
 
 		char comm = scn.nextLine().charAt(0);
@@ -50,7 +51,7 @@ public class GrammarServer {
 					System.out.println("\tg: Generate text");
 					break;
 				case 'g':
-					serv.generateText();
+					serv.generateMode();
 					break;
 				case 's':
 					serv.showMode();
@@ -70,10 +71,12 @@ public class GrammarServer {
 		System.out.println("GrammarServer exiting");
 	}
 
+	
+
 	private void loadMode() {
 		System.out.println("Entering Load Mode");
 
-		System.out.print("(Load Mode) Enter a command (m for help):");
+		System.out.print("(Load Mode) Enter a command (m for help): ");
 		char comm = scn.nextLine().charAt(0);
 
 		while(comm != 'e') {
@@ -81,8 +84,9 @@ public class GrammarServer {
 				case 'm':
 					System.out.println("GrammarServer Load Mode Commands");
 					System.out.println("\tm: Show command help");
-					System.out.println("\te: Exit Generate Mode");
+					System.out.println("\te: Exit Load Mode");
 					System.out.println("\tg: Load grammar from a file");
+					System.out.println("\tl: Load long rule from a file");
 					System.out.println("\tc: Load configuration from a file");
 					break;
 				case 'g':
@@ -91,39 +95,71 @@ public class GrammarServer {
 				case 'c':
 					loadConfig();
 					break;
+				case 'l':
+					loadLongRule();
+					break;
 				default:
 					System.out.println("? Unrecognized Command");
 			}
 
-			System.out.print("(Load Mode) Enter a command (m for help):");
+			System.out.print("(Load Mode) Enter a command (m for help): ");
 			comm = scn.nextLine().charAt(0);
 		}
 
 		System.out.println("Exiting Load Mode");
 	}
 
-	private void loadConfig() {
-		System.out.print("Enter the file to load configuration from: ");
-		
+	private void loadGrammar() {
+		System.out.print("Enter path to load grammar from: ");
+	
+		String grammarPath = scn.nextLine().trim();
+	
+		File grammarFile = new File(grammarPath);
+	
+		String grammarName = grammarFile.getName().trim();
+	
+		grammarName = grammarName.substring(0, grammarName.lastIndexOf("."));
+	
+		System.out.printf("Enter grammar name or press enter for"
+				+ " the default (%s): ", grammarName);
+	
+		String inputName = scn.nextLine();
+	
+		if(!inputName.equals("")) {
+			grammarName = inputName;
+		}
+	
+		eng.doLoadGrammar(grammarName, grammarPath);
+	
+		return;
+	}
+
+	private void loadLongRule() {
+		System.out.print("Enter the file to load a long rule from: ");
+
 		String fileName = scn.nextLine().trim();
+		File ruleFile = new File(fileName);
 
-		File inputFile = new File(fileName);
+		String tempName = ruleFile.getName();
+		tempName = tempName.substring(0, tempName.lastIndexOf('.'));
 
-		try(FileInputStream inputStream = new FileInputStream(inputFile)) {
-			try(Scanner fle = new Scanner(inputStream)) {
-				while(fle.hasNextLine()) {
-					String line = fle.nextLine().trim();
+		System.out.printf("Enter the name for the long rule (default %s): ", tempName);
 
-					String gramName = line.substring(0, line.indexOf(' '));
-					String gramPath = line.substring(line.indexOf(' ') + 1, line.length());
+		String ruleName = scn.nextLine().trim();
 
-					loadGrammar(gramName, gramPath);
-				}
-			}
-		} catch(IOException ioex) {
-			System.out.printf("? Error reading configuration from file"
-					+ " (reason: %s)", ioex.getMessage());
+		if(ruleName.equals("")) {
+			ruleName = tempName;
 		}
+
+		eng.doLoadLongRule(ruleName, fileName);
+	}
+
+	private void loadConfig() {
+		System.out.print("Enter the file to load configuration from: ");
+		
+		String fileName = scn.nextLine().trim();
+
+		eng.doLoadConfig(fileName);
 	}
 
 	private void showMode() {
@@ -147,20 +183,10 @@ public class GrammarServer {
 					showGrammarRules();
 					break;
 				case 'x':
-					System.out.printf("Currently exported rules (%d total):\n",
-							exportedRules.getSize());
-
-					exportedRules.forEachKey(key -> {
-						System.out.println("\t" + key);
-					});
+					eng.doShowExportedRules();
 					break;
 				case 'l':
-					System.out.printf("Currently loaded grammars (%d total):\n",
-							loadedGrammars.getSize());
-
-					loadedGrammars.forEachKey(key -> {
-						System.out.println("\t" + key);
-					});
+					eng.doShowLoadedGrammars();
 					break;
 				default:
 					System.out.println("? Unrecognized command");
@@ -177,42 +203,7 @@ public class GrammarServer {
 		System.out.println("Exiting Show Mode");
 	}
 
-	private void showGrammarRules() {
-		System.out.print("Enter the name of the grammar (l to list): ");
-		String gramName = scn.nextLine().trim();
-
-		do {
-			if(gramName.equals("")) break;
-
-			if(gramName.equals("l")) {
-				System.out.printf("Currently loaded grammars (%d total):\n",
-						loadedGrammars.getSize());
-
-				loadedGrammars.forEachKey(key -> {
-					System.out.println("\t" + key);
-				});
-			} else if (loadedGrammars.containsKey(gramName)) {
-				WeightedGrammar<String> gram = loadedGrammars.get(gramName);
-
-				IList<String> ruleNames = gram.getRuleNames();
-
-				System.out.printf("Rules for grammar %s (%d total)\n",
-						gramName, ruleNames.getSize());
-
-				ruleNames.forEach(rule -> {
-					System.out.println("\t" + rule);
-				});
-				break;
-			} else {
-				System.out.println("? Unrecognized grammar name");
-			}
-
-			System.out.print("Enter the name of the grammar (l to list): ");
-			gramName = scn.nextLine().trim();
-		} while(true);
-	}
-
-	private void generateText() {
+	private void generateMode() {
 		System.out.println("Entering Generate Mode");
 
 		System.out.print("(Generate Mode) Enter a command (m for help): ");
@@ -225,11 +216,15 @@ public class GrammarServer {
 					System.out.println("GrammarServer Generate Mode Commands: ");
 					System.out.println("\tm: Show command help");
 					System.out.println("\tx: Generate from exported rules");
+					System.out.println("\tr: Generate from a grammar");
 					System.out.println("\te: Exit Generate Mode");
 					break;
 				case 'x':
 					generateExportedRule();
 					break;
+				case 'r':
+					generateGrammar();
+					break;
 				default:
 					System.out.println("? Unrecognized command");
 			}
@@ -252,17 +247,9 @@ public class GrammarServer {
 			if(ruleName.equals("")) break;
 
 			if(ruleName.equals("l")) {
-				System.out.println("Current exported rules: ");
-				exportedRules.forEachKey(key -> {
-					System.out.println("\t" + key);
-				});
+				eng.doShowExportedRules();
 			} else if (exportedRules.containsKey(ruleName)) {
-				String ruleResult = ListUtils.collapseTokens(
-						exportedRules.get(ruleName)
-						.generateListValues(ruleName, " "));
-
-				System.out.println("Generated Result: ");
-				System.out.println("\t" + ruleResult.replaceAll("\\s+", " "));
+				eng.doGenerateExportedRule(ruleName);
 
 				System.out.print("Generate again from this rule? (yes/no) (yes by default): ");
 
@@ -282,52 +269,78 @@ public class GrammarServer {
 		}
 	}
 
-	private void loadGrammar() {
-		System.out.print("Enter path to load grammar from: ");
+	private void generateGrammar() {
+		System.out.print("Enter the name of the grammar to generate from (l to list, enter to cancel): ");
 
-		String grammarPath = scn.nextLine().trim();
+		String grammarName = scn.nextLine().trim();
 
-		File grammarFile = new File(grammarPath);
-
-		String grammarName = grammarFile.getName().trim();
+		while(true) {
+			if(grammarName.equals("")) break;
 
-		grammarName = grammarName.substring(0, grammarName.lastIndexOf("."));
+			if(grammarName.equals("l")) {
+				eng.doShowLoadedGrammars();
+			} else if(loadedGrammars.containsKey(grammarName)) {
+				WeightedGrammar<String> currentGram = loadedGrammars.get(grammarName);
 
-		System.out.printf("Enter grammar name or press enter for"
-				+ " the default (%s): ", grammarName);
+				System.out.print("Enter the name of the rule to generate"
+						+ " (l to list, enter to cancel): ");
 
-		String inputName = scn.nextLine();
+				String ruleName = scn.nextLine().trim();
 
-		if(!inputName.equals("")) {
-			grammarName = inputName;
-		}
+				while(true) {
+					if(ruleName.equals("")) break;
 
-		doLoadGrammar(grammarName, grammarPath);
+					if(ruleName.equals("l")) {
+						eng.doShowGrammarRules(grammarName);
+					} else if (currentGram.hasRule(ruleName)) {
+						eng.doGenerateGrammar(currentGram, ruleName);
 
-		return;
-	}
+						System.out.print("Generate again from this rule? (yes/no) (yes by default): ");
 
-	private void doLoadGrammar(String grammarName, String grammarPath) {
-		System.out.printf("Loading grammar (named %s) from path %s\n",
-				grammarName, grammarPath);
+						String resp = scn.nextLine().trim();
 
-		try (FileInputStream inputStream = new FileInputStream(grammarPath)) {
-			WeightedGrammar<String> newGram = 
-				ServerGrammarReader.fromStream(inputStream).merge((gram, exports) -> {
-					for(String export : exports.toIterable()) {
-						exportedRules.put(export, gram);
+						if(resp.equalsIgnoreCase("yes") || resp.equals("")) {
+							continue;
+						}
+					} else {
+						System.out.println("? Unrecognized grammar rule");
 					}
 
-					return gram;
-				});
+					System.out.print("Enter the name of the rule to generate"
+							+ " (l to list, enter to cancel): ");
 
-			loadedGrammars.put(grammarName, newGram);
-		} catch (IOException ioex) {
-			System.out.printf("? Error reading grammar from file"
-					+ " (reason: %s)", ioex.getMessage());
+					ruleName = scn.nextLine().trim();
+				}
+
+			} else {
+				System.out.println("? Unrecognized grammar name");
+			}
+
+			System.out.print("Enter the name of the grammar to generate from "
+					+ "(l to list, enter to cancel): ");
+
+			grammarName = scn.nextLine().trim();
 		}
+	}
 
-		System.out.printf("Loaded grammar (named %s) from path %s\n",
-				grammarName, grammarPath);
+	private void showGrammarRules() {
+		System.out.print("Enter the name of the grammar (l to list): ");
+		String gramName = scn.nextLine().trim();
+	
+		do {
+			if(gramName.equals("")) break;
+	
+			if(gramName.equals("l")) {
+				eng.doShowLoadedGrammars();
+			} else if (loadedGrammars.containsKey(gramName)) {
+				eng.doShowGrammarRules(gramName);
+				break;
+			} else {
+				System.out.println("? Unrecognized grammar name");
+			}
+	
+			System.out.print("Enter the name of the grammar (l to list): ");
+			gramName = scn.nextLine().trim();
+		} while(true);
 	}
 }
diff --git a/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java b/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java
index 9314c0c..62c59ff 100644
--- a/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java
+++ b/RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java
@@ -25,36 +25,20 @@ import bjc.utils.parserutils.RuleBasedConfigReader;
  *
  */
 public class ServerGrammarReader {
-	private static RuleBasedConfigReader<ReaderState> reader;
-
-	private static Random numgen = new Random();
-
-	private static IMap<String, WeightedGrammar<String>> exportedRules;
-
-	public static void setExportedRules(IMap<String, WeightedGrammar<String>> rules) {
-		exportedRules = rules;
-	}
-
 	static {
 		setupReader();
-
+	
 		initPragmas();
 	}
 
-	private static void debugGrammar(ReaderState state) {
-		System.out.println("Printing rule names: ");
-
-		for (String currentRule : state.getRuleNames().toIterable()) {
-			System.out.println("\t" + currentRule);
-		}
+	private static RuleBasedConfigReader<ReaderState> reader;
 
-		System.out.println();
-	}
+	private static Random numgen = new Random();
 
-	private static void doCase(FunctionalStringTokenizer tokenizer, ReaderState state) {
-		int ruleProbability = readOptionalProbability(tokenizer, state);
+	private static IMap<String, WeightedGrammar<String>> exportedRules;
 
-		state.addCase(ruleProbability, tokenizer.toList());
+	public static void setExportedRules(IMap<String, WeightedGrammar<String>> rules) {
+		exportedRules = rules;
 	}
 
 	/**
@@ -69,150 +53,206 @@ public class ServerGrammarReader {
 	public static IPair<WeightedGrammar<String>, IList<String>>
 		fromStream(InputStream inputStream) {
 			ReaderState initialState = new ReaderState();
-
+	
 			WeightedGrammar<String> gram = reader.fromStream(inputStream, initialState).getGrammar();
-
+	
 			IMap<String, IList<String>> vars = new FunctionalMap<>();
-
+	
 			Predicate<String> specialPredicate = (strang) -> {
-				if(strang.matches("\\{\\S+\\}") || strang.matches("\\[\\S+\\}")) {
+				if(strang.matches("\\[\\S+\\]")) {
 					return true;
 				}
-
+	
 				return false;
 			};
-
+	
 			BiFunction<String, WeightedGrammar<String>, IList<String>> 
 				specialAction = (strang, gramm) -> {
-					IList<String> retList = new FunctionalList<>();
-
-					if(strang.matches("\\{\\S+\\}")) {
-						if(strang.matches("\\{\\S+:=\\S+\\}")) {
-							String[] varParts = strang.split(":=");
-
-							String varName = varParts[0].substring(1);
-							String ruleName = varParts[1].substring(0, varParts[1].length());
-
-							IList<String> varValue = gramm.generateGenericValues(
-									ruleName, (s) -> s, " ");
-
-							vars.put(varName, varValue);
-						} else if(strang.matches("\\{\\S+=\\S+\\}")) {
-							String[] varParts = strang.split("=");
-
-							String varName = varParts[0].substring(1);
-							String varValue = varParts[1].substring(0, varParts[1].length());
-
-							vars.put(varName, new FunctionalList<>(varValue));
-						} else {
-							// @FIXME notify the user they did something wrong
-							retList.add(strang);
-						}
-					} else {
-						if(strang.matches("\\[\\$\\S+\\]")) {
-							String varName = strang.substring(2, strang.length());
-
-							retList = vars.get(varName);
-						} else if(strang.matches("\\[\\$\\S+\\-\\S+\\]")) {
-							String[] varParts = strang.substring(1, strang.length()).split("-");
-
-							StringBuilder actualName = new StringBuilder("[");
-
-							for(String varPart : varParts) {
-								if(varPart.startsWith("$")) {
-									IList<String> varName = vars.get(varPart.substring(1));
-
-									if(varName.getSize() != 1) {
-										// @FIXME notify the user they did something wrong
-									}
-
-									actualName.append(varName.first() + "-");
-								} else {
-									actualName.append(varPart + "-");
-								}
-							}
-
-							// Trim trailing -
-							actualName.deleteCharAt(actualName.length() - 1);
-							actualName.append("]");
-
-							retList = gramm.generateGenericValues(actualName.toString(), (s) -> s, " ");
-						} else if (exportedRules.containsKey(strang)) {
-							return exportedRules.get(strang)
-								.generateGenericValues(strang, (s) -> s, " ");
-						} else {
-							// @FIXME notify the user they did something wrong
-							retList.add(strang);
-						}
-					}
-
-					return retList;
+					return handleSpecialRule(vars, strang, gramm);
 				};
-
+	
 			gram.configureSpecial(specialPredicate, specialAction);
-
-			return new Pair<>(gram, initialState.getExports());
-	}
-
-	private static void initialRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
-		String initialRuleName = tokenizer.nextToken();
-
-		state.setInitialRule(initialRuleName);
+	
+			IList<String> exports = initialState.getExports();
+	
+			if(gram.getInitialRule() != null && !exports.contains(gram.getInitialRule())) {
+				exports.add(gram.getInitialRule());
+			}
+	
+			return new Pair<>(gram, exports);
 	}
 
 	private static void initPragmas() {
 		reader.addPragma("debug", (tokenizer, state) -> {
 			debugGrammar(state);
 		});
-
+	
 		reader.addPragma("uniform", (tokenizer, state) -> {
 			state.toggleUniformity();
 		});
-
+	
 		reader.addPragma("initial-rule", ServerGrammarReader::initialRule);
-
+	
 		reader.addPragma("remove-rule", ServerGrammarReader::removeRule);
-
+	
 		reader.addPragma("prefix-with", ServerGrammarReader::prefixRule);
 		reader.addPragma("suffix-with", ServerGrammarReader::suffixRule);
-
-		reader.addPragma("regex-rule", (tokenizer, state) -> {
+	
+		reader.addPragma("regex-rule", ServerGrammarReader::handleRegexRule);
+	
+		reader.addPragma("range-rule", ServerGrammarReader::handleRangeRule);
+	
+		reader.addPragma("export-rule", (tokenizer, state) -> {
 			String ruleName = tokenizer.nextToken();
+	
+			state.addExport(ruleName);
+		});
+	}
 
-			IList<String> regx = tokenizer.toList();
-			Generex regex = new Generex(ListUtils.collapseTokens(regx));
-
-			state.addSpecialRule(ruleName, () -> {
-				return new FunctionalList<>(regex.random().split(" "));
+	private static void setupReader() {
+		reader = new RuleBasedConfigReader<>(null, null, null);
+	
+		reader.setStartRule((tokenizer, stateTokenPair) -> {
+			stateTokenPair.doWith((initToken, state) -> {
+				state.startNewRule(initToken);
+	
+				doCase(tokenizer, state);
 			});
 		});
+	
+		reader.setContinueRule((tokenizer, state) -> {
+			doCase(tokenizer, state);
+		});
+	
+		reader.setEndRule((tokenizer) -> {
+			tokenizer.setCurrentRule(null);
+		});
+	}
 
-		reader.addPragma("range-rule", (tokenizer, state) -> {
-			String ruleName = tokenizer.nextToken();
+	private static void debugGrammar(ReaderState state) {
+		System.out.println("Printing rule names: ");
 
-			int start = Integer.parseInt(tokenizer.nextToken());
-			int end = Integer.parseInt(tokenizer.nextToken());
+		for (String currentRule : state.getRuleNames().toIterable()) {
+			System.out.println("\t" + currentRule);
+		}
 
-			state.addSpecialRule(ruleName, () -> {
-				return new FunctionalList<>(Integer.toString(
-							numgen.nextInt((end - start) + 1) + start));
-			});
-		});
+		System.out.println();
+	}
 
-		reader.addPragma("export-rule", (tokenizer, state) -> {
-			String ruleName = tokenizer.nextToken();
+	private static void doCase(FunctionalStringTokenizer tokenizer, ReaderState state) {
+		int ruleProbability = readOptionalProbability(tokenizer, state);
 
-			state.addExport(ruleName);
+		state.addCase(ruleProbability, tokenizer.toList());
+	}
+
+	private static void initialRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
+		String initialRuleName = tokenizer.nextToken();
+
+		state.setInitialRule(initialRuleName);
+	}
+
+	private static IList<String> handleSpecialRule(IMap<String, IList<String>> vars, String strang,
+			WeightedGrammar<String> gramm) {
+		IList<String> retList = new FunctionalList<>();
+	
+		if(strang.matches("\\[\\[\\S+\\]\\]")) {
+			if(strang.matches("\\[\\S+:=\\S+\\]")) {
+				String[] varParts = strang.split(":=");
+	
+				String varName = varParts[0].substring(1);
+				String ruleName = varParts[1].substring(0, varParts[1].length());
+	
+				IList<String> varValue = gramm.generateGenericValues(
+						ruleName, (s) -> s, " ");
+	
+				vars.put(varName, varValue);
+			} else if(strang.matches("\\[\\[\\S+=\\S+\\]\\]")) {
+				String[] varParts = strang.split("=");
+	
+				String varName = varParts[0].substring(1);
+				String varValue = varParts[1].substring(0, varParts[1].length());
+	
+				vars.put(varName, new FunctionalList<>(varValue));
+			} else if(strang.matches("\\[\\[\\S+\\]\\]")) {
+				String ruleName = strang.substring(1, strang.length() - 1);
+
+				IList<String> ruleValue = gramm.generateGenericValues(
+						ruleName, (s) -> s, "");
+
+				retList.add(ListUtils.collapseTokens(ruleValue));
+			} else {
+				// @FIXME notify the user they did something wrong
+				retList.add(strang);
+			}
+		} else {
+			if(strang.matches("\\[\\$\\S+\\]")) {
+				String varName = strang.substring(2, strang.length());
+	
+				retList = vars.get(varName);
+			} else if(strang.matches("\\[\\$\\S+\\-\\S+\\]")) {
+				String[] varParts = strang.substring(1, strang.length()).split("-");
+	
+				StringBuilder actualName = new StringBuilder("[");
+	
+				for(String varPart : varParts) {
+					if(varPart.startsWith("$")) {
+						IList<String> varName = vars.get(varPart.substring(1));
+	
+						if(varName.getSize() != 1) {
+							// @FIXME notify the user they did something wrong
+						}
+	
+						actualName.append(varName.first() + "-");
+					} else {
+						actualName.append(varPart + "-");
+					}
+				}
+	
+				// Trim trailing -
+				actualName.deleteCharAt(actualName.length() - 1);
+				actualName.append("]");
+	
+				retList = gramm.generateGenericValues(actualName.toString(), (s) -> s, " ");
+			} else if (exportedRules.containsKey(strang) && 
+					exportedRules.get(strang) != gramm &&
+					!gramm.hasRule(strang)) {
+				// Only pick external rules if they are both 
+				// a) in a different grammar
+				// b) not shadowed in the current grammar
+				WeightedGrammar<String> exportGram = exportedRules.get(strang);
+	
+				retList = exportGram.generateGenericValues(strang, (s) -> s, " ");
+			} else {
+				// @FIXME notify the user they did something wrong
+				retList.add(strang);
+			}
+		}
+	
+		return retList;
+	}
+
+	private static void handleRangeRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
+		String ruleName = tokenizer.nextToken();
+
+		int start = Integer.parseInt(tokenizer.nextToken());
+		int end = Integer.parseInt(tokenizer.nextToken());
+
+		state.addSpecialRule(ruleName, () -> {
+			int genNum = numgen.nextInt((end - start) + 1) + start;
+			
+			return new FunctionalList<>(Integer.toString(genNum));
 		});
 	}
 
-	private static void prefixRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
+	private static void handleRegexRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
 		String ruleName = tokenizer.nextToken();
-		String prefixToken = tokenizer.nextToken();
 
-		int additionalProbability = readOptionalProbability(tokenizer, state);
+		IList<String> regx = tokenizer.toList();
+		Generex regex = new Generex(ListUtils.collapseTokens(regx));
 
-		state.prefixRule(ruleName, prefixToken, additionalProbability);
+		state.addSpecialRule(ruleName, () -> {
+			return new FunctionalList<>(regex.random().split(" "));
+		});
 	}
 
 	private static int readOptionalProbability(FunctionalStringTokenizer tokenizer, ReaderState state) {
@@ -229,24 +269,13 @@ public class ServerGrammarReader {
 		state.deleteRule(ruleName);
 	}
 
-	private static void setupReader() {
-		reader = new RuleBasedConfigReader<>(null, null, null);
-
-		reader.setStartRule((tokenizer, stateTokenPair) -> {
-			stateTokenPair.doWith((initToken, state) -> {
-				state.startNewRule(initToken);
-
-				doCase(tokenizer, state);
-			});
-		});
-
-		reader.setContinueRule((tokenizer, state) -> {
-			doCase(tokenizer, state);
-		});
-
-		reader.setEndRule((tokenizer) -> {
-			tokenizer.setCurrentRule(null);
-		});
+	private static void prefixRule(FunctionalStringTokenizer tokenizer, ReaderState state) {
+		String ruleName = tokenizer.nextToken();
+		String prefixToken = tokenizer.nextToken();
+	
+		int additionalProbability = readOptionalProbability(tokenizer, state);
+	
+		state.prefixRule(ruleName, prefixToken, additionalProbability);
 	}
 
 	private static void suffixRule(FunctionalStringTokenizer tokenizer, ReaderState state) {