Switched to using new rule-based skeleton

4 files changed, 278 insertions, 77 deletions

diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java
index f6aa383..c325ac1 100644
--- a/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java
+++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java
@@ -11,6 +11,7 @@ import java.util.function.BiConsumer;
 
 import bjc.utils.funcdata.FunctionalStringTokenizer;
 import bjc.utils.gen.WeightedGrammar;
+import bjc.utils.parserutils.UnknownPragmaException;
 
 public class GrammarReader {
 	private static Map<String, BiConsumer<StringTokenizer, ReaderState>>	actMap;
@@ -29,6 +30,35 @@ public class GrammarReader {
 		actMap.put("\t", GrammarReader::doCase);
 	}
 
+	private static void addSubgrammarPragmas() {
+		pragmaMap.put("edit-sub-grammar", GrammarReader::editSubGrammar);
+		pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar());
+
+		pragmaMap.put("load-sub-grammar", GrammarReader::loadSubGrammar);
+
+		pragmaMap.put("new-sub-grammar",
+				(stk, rs) -> rs.pushGrammar(new WeightedGrammar<>()));
+
+		pragmaMap.put("promote", GrammarReader::promoteGrammar);
+
+		pragmaMap.put("remove-sub-grammar",
+				GrammarReader::removeSubGrammar);
+		pragmaMap.put("remove-rule", GrammarReader::removeRule);
+
+		pragmaMap.put("save-sub-grammar", GrammarReader::saveGrammar);
+		pragmaMap.put("subordinate", GrammarReader::subordinateGrammar);
+	}
+
+	private static void debugGrammar(StringTokenizer stk, ReaderState rs) {
+		System.out.println("Printing rule names: ");
+
+		for (String rul : rs.getRules().ruleNames()) {
+			System.out.println("\t" + rul);
+		}
+
+		System.out.println();
+	}
+
 	private static void doCase(StringTokenizer stk, ReaderState rs) {
 		int prob = 1;
 
@@ -90,6 +120,19 @@ public class GrammarReader {
 		return rs.getRules();
 	}
 
+	private static void importRule(StringTokenizer stk, ReaderState rs) {
+		String ruleName = stk.nextToken();
+		String sgName = stk.nextToken();
+
+		rs.getRules().addGrammarAlias(sgName, ruleName);
+	}
+
+	private static void initialRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+
+		rs.setInitialRule(rName);
+	}
+
 	private static void initPragmas() {
 		pragmaMap = new Hashtable<>();
 
@@ -107,46 +150,28 @@ public class GrammarReader {
 		pragmaMap.put("suffix-with", GrammarReader::suffixRule);
 	}
 
-	private static void multiPrefixRule(StringTokenizer stk,
+	private static void loadSubGrammar(StringTokenizer stk,
 			ReaderState rs) {
+		String sgName = stk.nextToken();
+		String fName = stk.nextToken();
 
+		try {
+			rs.getRules().addSubGrammar(sgName,
+					fromStream(new FileInputStream(fName)));
+		} catch (FileNotFoundException e) {
+			throw new PragmaErrorException("Could not load subgrammar "
+					+ sgName + " from file " + fName);
+		}
 	}
 
-	private static void multiSuffixRule(StringTokenizer stk,
+	private static void multiPrefixRule(StringTokenizer stk,
 			ReaderState rs) {
 
 	}
 
-	private static void addSubgrammarPragmas() {
-		pragmaMap.put("edit-sub-grammar", GrammarReader::editSubGrammar);
-		pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar());
-
-		pragmaMap.put("load-sub-grammar", GrammarReader::loadSubGrammar);
-
-		pragmaMap.put("new-sub-grammar",
-				(stk, rs) -> rs.pushGrammar(new WeightedGrammar<>()));
-
-		pragmaMap.put("promote", GrammarReader::promoteGrammar);
-
-		pragmaMap.put("remove-sub-grammar",
-				GrammarReader::removeSubGrammar);
-		pragmaMap.put("remove-rule", GrammarReader::removeRule);
-
-		pragmaMap.put("save-sub-grammar", GrammarReader::saveGrammar);
-		pragmaMap.put("subordinate", GrammarReader::subordinateGrammar);
-	}
-
-	private static void initialRule(StringTokenizer stk, ReaderState rs) {
-		String rName = stk.nextToken();
-
-		rs.setInitialRule(rName);
-	}
-
-	private static void importRule(StringTokenizer stk, ReaderState rs) {
-		String ruleName = stk.nextToken();
-		String sgName = stk.nextToken();
+	private static void multiSuffixRule(StringTokenizer stk,
+			ReaderState rs) {
 
-		rs.getRules().addGrammarAlias(sgName, ruleName);
 	}
 
 	private static void prefixRule(StringTokenizer stk, ReaderState rs) {
@@ -158,39 +183,6 @@ public class GrammarReader {
 		rs.getRules().prefixRule(rName, prefixToken, addProb);
 	}
 
-	private static void suffixRule(StringTokenizer stk, ReaderState rs) {
-		String rName = stk.nextToken();
-		String prefixToken = stk.nextToken();
-		int addProb = rs.isUniform() ? 0
-				: Integer.parseInt(stk.nextToken());
-
-		rs.getRules().suffixRule(rName, prefixToken, addProb);
-	}
-
-	private static void debugGrammar(StringTokenizer stk, ReaderState rs) {
-		System.out.println("Printing rule names: ");
-
-		for (String rul : rs.getRules().ruleNames()) {
-			System.out.println("\t" + rul);
-		}
-
-		System.out.println();
-	}
-
-	private static void loadSubGrammar(StringTokenizer stk,
-			ReaderState rs) {
-		String sgName = stk.nextToken();
-		String fName = stk.nextToken();
-
-		try {
-			rs.getRules().addSubGrammar(sgName,
-					fromStream(new FileInputStream(fName)));
-		} catch (FileNotFoundException e) {
-			throw new PragmaErrorException("Could not load subgrammar "
-					+ sgName + " from file " + fName);
-		}
-	}
-
 	private static void promoteGrammar(StringTokenizer stk,
 			ReaderState rs) {
 		String gName = stk.nextToken();
@@ -229,4 +221,13 @@ public class GrammarReader {
 		nwg.addSubGrammar(gName, rs.getRules());
 		rs.setRules(nwg);
 	}
+
+	private static void suffixRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+		String prefixToken = stk.nextToken();
+		int addProb = rs.isUniform() ? 0
+				: Integer.parseInt(stk.nextToken());
+
+		rs.getRules().suffixRule(rName, prefixToken, addProb);
+	}
 }
diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java
index 5770d55..28f1587 100644
--- a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java
+++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java
@@ -31,7 +31,7 @@ public class GrammarReaderApp {
 		WeightedGrammar<String> wg = null;
 
 		try {
-			wg = GrammarReader.fromStream(new FileInputStream(gramFile));
+			wg = RBGrammarReader.fromStream(new FileInputStream(gramFile));
 		} catch (FileNotFoundException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
diff --git a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java
new file mode 100644
index 0000000..4276781
--- /dev/null
+++ b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java
@@ -0,0 +1,212 @@
+package bjc.RGens.parser;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.util.Hashtable;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.function.BiConsumer;
+
+import bjc.utils.funcdata.FunctionalStringTokenizer;
+import bjc.utils.gen.WeightedGrammar;
+import bjc.utils.parserutils.RuleBasedConfigReader;
+
+public class RBGrammarReader {
+	private static Map<String, BiConsumer<StringTokenizer, ReaderState>> pragmaMap;
+
+	static {
+		initPragmas();
+
+	}
+
+	private static void addSubgrammarPragmas() {
+		pragmaMap.put("edit-sub-grammar", RBGrammarReader::editSubGrammar);
+		pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar());
+
+		pragmaMap.put("load-sub-grammar", RBGrammarReader::loadSubGrammar);
+
+		pragmaMap.put("new-sub-grammar",
+				(stk, rs) -> rs.pushGrammar(new WeightedGrammar<>()));
+
+		pragmaMap.put("promote", RBGrammarReader::promoteGrammar);
+
+		pragmaMap.put("remove-sub-grammar",
+				RBGrammarReader::removeSubGrammar);
+		pragmaMap.put("remove-rule", RBGrammarReader::removeRule);
+
+		pragmaMap.put("save-sub-grammar", RBGrammarReader::saveGrammar);
+		pragmaMap.put("subordinate", RBGrammarReader::subordinateGrammar);
+	}
+
+	private static void debugGrammar(StringTokenizer stk, ReaderState rs) {
+		System.out.println("Printing rule names: ");
+
+		for (String rul : rs.getRules().ruleNames()) {
+			System.out.println("\t" + rul);
+		}
+
+		System.out.println();
+	}
+
+	private static void doCase(StringTokenizer stk, ReaderState rs) {
+		int prob = 1;
+
+		if (!rs.isUniform()) {
+			prob = Integer.parseInt(stk.nextToken());
+		}
+
+		rs.getRules().addCase(rs.getRule(), prob,
+				new FunctionalStringTokenizer(stk).toList(s -> s));
+	}
+
+	private static void editSubGrammar(StringTokenizer stk,
+			ReaderState rs) {
+		String sgName = stk.nextToken();
+		rs.pushGrammar(rs.getRules().getSubGrammar(sgName));
+	}
+
+	public static WeightedGrammar<String> fromStream(InputStream is) {
+		ReaderState rs = new ReaderState();
+		rs.toggleUniformity();
+
+		RuleBasedConfigReader<ReaderState> reader = new RuleBasedConfigReader<>(
+				null, null, null);
+
+		reader.setStartRule((stk, par) -> {
+			rs.getRules().addRule(par.l);
+			rs.setRule(par.l);
+
+			doCase(stk.getInternal(), par.r);
+		});
+
+		reader.setContinueRule((stk, ras) -> {
+			doCase(stk.getInternal(), ras);
+		});
+
+		reader.setEndRule((ras) -> {
+			ras.setRule(null);
+		});
+
+		pragmaMap.forEach((name, act) -> {
+			reader.addPragma(name, (tokn, stat) -> {
+				act.accept(tokn.getInternal(), stat);
+			});
+		});
+
+		return reader.fromStream(is, rs).getRules();
+	}
+
+	private static void importRule(StringTokenizer stk, ReaderState rs) {
+		String ruleName = stk.nextToken();
+		String sgName = stk.nextToken();
+
+		rs.getRules().addGrammarAlias(sgName, ruleName);
+	}
+
+	private static void initialRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+
+		rs.setInitialRule(rName);
+	}
+
+	private static void initPragmas() {
+		pragmaMap = new Hashtable<>();
+
+		addSubgrammarPragmas();
+
+		pragmaMap.put("debug", RBGrammarReader::debugGrammar);
+		pragmaMap.put("import-rule", RBGrammarReader::importRule);
+		pragmaMap.put("initial-rule", RBGrammarReader::initialRule);
+		pragmaMap.put("uniform", (stk, rs) -> rs.toggleUniformity());
+
+		pragmaMap.put("multi-prefix-with",
+				RBGrammarReader::multiPrefixRule);
+		pragmaMap.put("multi-suffix-with",
+				RBGrammarReader::multiSuffixRule);
+
+		pragmaMap.put("prefix-with", RBGrammarReader::prefixRule);
+		pragmaMap.put("suffix-with", RBGrammarReader::suffixRule);
+	}
+
+	private static void loadSubGrammar(StringTokenizer stk,
+			ReaderState rs) {
+		String sgName = stk.nextToken();
+		String fName = stk.nextToken();
+
+		try {
+			rs.getRules().addSubGrammar(sgName,
+					fromStream(new FileInputStream(fName)));
+		} catch (FileNotFoundException e) {
+			throw new PragmaErrorException("Could not load subgrammar "
+					+ sgName + " from file " + fName);
+		}
+	}
+
+	private static void multiPrefixRule(StringTokenizer stk,
+			ReaderState rs) {
+		// TODO implement me :)
+	}
+
+	private static void multiSuffixRule(StringTokenizer stk,
+			ReaderState rs) {
+		// TODO implement me :)
+	}
+
+	private static void prefixRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+		String prefixToken = stk.nextToken();
+		int addProb = rs.isUniform() ? 0
+				: Integer.parseInt(stk.nextToken());
+
+		rs.getRules().prefixRule(rName, prefixToken, addProb);
+	}
+
+	private static void promoteGrammar(StringTokenizer stk,
+			ReaderState rs) {
+		String gName = stk.nextToken();
+		String rName = stk.nextToken();
+
+		WeightedGrammar<String> nwg = rs.getRules().getSubGrammar(gName);
+		rs.getRules().removeSubgrammar(gName);
+
+		nwg.addSubGrammar(rName, rs.getRules());
+		rs.setRules(nwg);
+	}
+
+	private static void removeRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+
+		rs.getRules().removeRule(rName);
+	}
+
+	private static void removeSubGrammar(StringTokenizer stk,
+			ReaderState rs) {
+		String sgName = stk.nextToken();
+		rs.getRules().removeSubgrammar(sgName);
+	}
+
+	private static void saveGrammar(StringTokenizer stk, ReaderState rs) {
+		String sgName = stk.nextToken();
+		WeightedGrammar<String> sg = rs.popGrammar();
+		rs.getRules().addSubGrammar(sgName, sg);
+	}
+
+	private static void subordinateGrammar(StringTokenizer stk,
+			ReaderState rs) {
+		String gName = stk.nextToken();
+		WeightedGrammar<String> nwg = new WeightedGrammar<>();
+
+		nwg.addSubGrammar(gName, rs.getRules());
+		rs.setRules(nwg);
+	}
+
+	private static void suffixRule(StringTokenizer stk, ReaderState rs) {
+		String rName = stk.nextToken();
+		String prefixToken = stk.nextToken();
+		int addProb = rs.isUniform() ? 0
+				: Integer.parseInt(stk.nextToken());
+
+		rs.getRules().suffixRule(rName, prefixToken, addProb);
+	}
+}
diff --git a/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java b/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java
deleted file mode 100644
index 62d5b9f..0000000
--- a/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java
+++ /dev/null
@@ -1,12 +0,0 @@
-package bjc.RGens.parser;
-
-import java.util.InputMismatchException;
-
-public class UnknownPragmaException extends InputMismatchException {
-	public UnknownPragmaException(String m) {
-		super(m);
-	}
-
-	private static final long serialVersionUID = -4277573484926638662L;
-
-}