From f1943c74de8fe61f4990def15cbcfe6e83bea00a Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 14 Jan 2016 14:00:59 -0500 Subject: Lots of work on stuff --- RGens/src/main/java/bjc/RGens/ZadronsPouch.java | 28 +-- .../main/java/bjc/RGens/parser/GrammarReader.java | 202 +++++++++++++++++++++ .../bjc/RGens/parser/PragmaErrorException.java | 9 + .../main/java/bjc/RGens/parser/ReaderState.java | 56 ++++++ .../bjc/RGens/parser/UnknownPragmaException.java | 12 ++ .../main/java/bjc/RGens/text/GrammarReader.java | 153 ---------------- .../java/bjc/RGens/text/PragmaErrorException.java | 9 - .../src/main/java/bjc/RGens/text/ReaderState.java | 47 ----- .../bjc/RGens/text/UnknownPragmaException.java | 12 -- 9 files changed, 295 insertions(+), 233 deletions(-) create mode 100644 RGens/src/main/java/bjc/RGens/parser/GrammarReader.java create mode 100644 RGens/src/main/java/bjc/RGens/parser/PragmaErrorException.java create mode 100644 RGens/src/main/java/bjc/RGens/parser/ReaderState.java create mode 100644 RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java delete mode 100644 RGens/src/main/java/bjc/RGens/text/GrammarReader.java delete mode 100644 RGens/src/main/java/bjc/RGens/text/PragmaErrorException.java delete mode 100644 RGens/src/main/java/bjc/RGens/text/ReaderState.java delete mode 100644 RGens/src/main/java/bjc/RGens/text/UnknownPragmaException.java (limited to 'RGens/src/main/java/bjc') diff --git a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java index fd2b65c..240e967 100644 --- a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java +++ b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java @@ -17,6 +17,10 @@ public class ZadronsPouch { System.out.println(sb.toString().replaceAll("\\s+", " ")); } + + System.out.println(); + System.out.println(); + System.out.println(); } private RandomGrammar wg; @@ -53,18 +57,6 @@ public class ZadronsPouch { addWandRules(); } - private void addWandRules() { - addRule("", " wand", "wand of ", - "canceling wand"); - addRule("", "magic missile", "", "", - "gusting", "life-detecting", "zadron"); - addRule("", "frost", "fire", "lightning", "fear", - "illumination", "polymorphing", "conjuration", - "paralyzing"); - addRule("", " detecting"); - addRule("", "magic", "enemy", "secret door/trap"); - } - private void addBagRules() { addRule("", "bag of ", " sack", " purse"); @@ -170,4 +162,16 @@ public class ZadronsPouch { "blank potion"); addRule("", "iron"); } + + private void addWandRules() { + addRule("", " wand", "wand of ", + "canceling wand"); + addRule("", "magic missile", "", "", + "gusting", "life-detecting", "zadron"); + addRule("", "frost", "fire", "lightning", "fear", + "illumination", "polymorphing", "conjuration", + "paralyzing"); + addRule("", " detecting"); + addRule("", "magic", "enemy", "secret door/trap"); + } } diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java new file mode 100644 index 0000000..e83eede --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReader.java @@ -0,0 +1,202 @@ +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.Scanner; +import java.util.StringTokenizer; +import java.util.function.BiConsumer; + +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.gen.WeightedGrammar; + +public class GrammarReader { + private static Map> actMap; + private static Map> pragmaMap; + + static { + initPragmas(); + + actMap = new Hashtable<>(); + + actMap.put("#", (stk, rs) -> { + return; + }); + + actMap.put("pragma", GrammarReader::doPragmas); + actMap.put("\t", GrammarReader::doCase); + } + + 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 doPragmas(StringTokenizer stk, ReaderState rs) { + String tk = stk.nextToken(); + + pragmaMap.getOrDefault(tk, (strk, ras) -> { + throw new UnknownPragmaException("Unknown pragma " + tk); + }).accept(stk, rs); + } + + private static void doRule(String tk, StringTokenizer stk, + ReaderState rs) { + rs.getRules().addRule(tk); + rs.setRule(tk); + + doCase(stk, rs); + } + + private static void editSubGrammar(StringTokenizer stk, + ReaderState rs) { + String sgName = stk.nextToken(); + rs.pushGrammar(rs.getRules().getSubGrammar(sgName)); + } + + public static WeightedGrammar fromStream(InputStream is) { + ReaderState rs = new ReaderState(); + rs.toggleUniformity(); + + Scanner scn = new Scanner(is); + + while (scn.hasNextLine()) { + String ln = scn.nextLine(); + + if (ln.equals("")) { + rs.setRule(null); + continue; + } else if (ln.startsWith("\t")) { + doCase(new StringTokenizer(ln.substring(1), " "), rs); + } else { + StringTokenizer stk = new StringTokenizer(ln, " "); + + String nxtToken = stk.nextToken(); + actMap.getOrDefault(nxtToken, + (stak, ras) -> doRule(nxtToken, stak, ras)) + .accept(stk, rs); + } + } + + scn.close(); + return rs.getRules(); + } + + private static void initPragmas() { + pragmaMap = new Hashtable<>(); + + pragmaMap.put("uniform", (stk, rs) -> rs.toggleUniformity()); + pragmaMap.put("subordinate", GrammarReader::subordinateGrammar); + pragmaMap.put("promote", GrammarReader::promoteGrammar); + pragmaMap.put("remove-sub-grammar", + GrammarReader::removeSubGrammar); + pragmaMap.put("remove-rule", GrammarReader::removeRule); + pragmaMap.put("load-sub-grammar", GrammarReader::loadSubGrammar); + pragmaMap.put("new-sub-grammar", + (stk, rs) -> rs.pushGrammar(new WeightedGrammar<>())); + pragmaMap.put("edit-sub-grammar", GrammarReader::editSubGrammar); + pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar()); + pragmaMap.put("save-sub-grammar", GrammarReader::saveGrammar); + pragmaMap.put("debug", GrammarReader::debugGrammar); + pragmaMap.put("prefix-with", GrammarReader::prefixRule); + pragmaMap.put("suffix-with", GrammarReader::suffixRule); + pragmaMap.put("import-rule", GrammarReader::importRule); + } + + + private static void importRule(StringTokenizer stk, ReaderState rs) { + String ruleName = stk.nextToken(); + String sgName = stk.nextToken(); + + rs.getRules().addGrammarAlias(sgName, ruleName); + } + + 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 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(); + String rName = stk.nextToken(); + + WeightedGrammar 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 sg = rs.popGrammar(); + rs.getRules().addSubGrammar(sgName, sg); + } + + private static void subordinateGrammar(StringTokenizer stk, + ReaderState rs) { + String gName = stk.nextToken(); + WeightedGrammar nwg = new WeightedGrammar<>(); + + nwg.addSubGrammar(gName, rs.getRules()); + rs.setRules(nwg); + } +} diff --git a/RGens/src/main/java/bjc/RGens/parser/PragmaErrorException.java b/RGens/src/main/java/bjc/RGens/parser/PragmaErrorException.java new file mode 100644 index 0000000..bede82a --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/PragmaErrorException.java @@ -0,0 +1,9 @@ +package bjc.RGens.parser; + +public class PragmaErrorException extends RuntimeException { + private static final long serialVersionUID = 7245421182038076899L; + + public PragmaErrorException(String message) { + super(message); + } +} diff --git a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java new file mode 100644 index 0000000..1487822 --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java @@ -0,0 +1,56 @@ +package bjc.RGens.parser; + +import java.util.Stack; + +import bjc.utils.gen.WeightedGrammar; + +public class ReaderState { + private String currRule = ""; + + // Pragma settings + private boolean isUniform = false; + + private Stack> wg; + + public ReaderState() { + wg = new Stack>(); + wg.push(new WeightedGrammar<>()); + } + + public WeightedGrammar currGrammar() { + return wg.peek(); + } + + public String getRule() { + return currRule; + } + + public WeightedGrammar getRules() { + return wg.peek(); + } + + public boolean isUniform() { + return isUniform; + } + + public WeightedGrammar popGrammar() { + return wg.pop(); + } + + public void pushGrammar(WeightedGrammar nwg) { + wg.push(nwg); + } + + public void setRule(String r) { + currRule = r; + } + + public void setRules(WeightedGrammar nwg) { + wg.pop(); + wg.push(nwg); + } + + public void toggleUniformity() { + isUniform = !isUniform; + } +} diff --git a/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java b/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java new file mode 100644 index 0000000..62d5b9f --- /dev/null +++ b/RGens/src/main/java/bjc/RGens/parser/UnknownPragmaException.java @@ -0,0 +1,12 @@ +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; + +} diff --git a/RGens/src/main/java/bjc/RGens/text/GrammarReader.java b/RGens/src/main/java/bjc/RGens/text/GrammarReader.java deleted file mode 100644 index df633de..0000000 --- a/RGens/src/main/java/bjc/RGens/text/GrammarReader.java +++ /dev/null @@ -1,153 +0,0 @@ -package bjc.RGens.text; - -import java.io.FileInputStream; -import java.io.FileNotFoundException; -import java.io.InputStream; -import java.util.HashMap; -import java.util.Map; -import java.util.Scanner; -import java.util.StringTokenizer; -import java.util.function.BiConsumer; - -import bjc.utils.funcdata.FunctionalStringTokenizer; -import bjc.utils.gen.WeightedGrammar; - -public class GrammarReader { - private static Map> actMap; - private static Map> pragmaMap; - - static { - initPragmas(); - - actMap = new HashMap<>(); - - actMap.put("#", (stk, rs) -> { - return; - }); - - actMap.put("pragma", GrammarReader::doPragmas); - actMap.put("\t", GrammarReader::doCase); - } - - 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 doPragmas(StringTokenizer stk, ReaderState rs) { - String tk = stk.nextToken(); - - pragmaMap.getOrDefault(tk, (strk, ras) -> { - throw new UnknownPragmaException("Unknown pragma " + tk); - }).accept(stk, rs); - } - - private static void doRule(String tk, StringTokenizer stk, - ReaderState rs) { - rs.getRules().addRule(tk); - - doCase(stk, rs); - } - - private static void editSubGrammar(StringTokenizer stk, - ReaderState rs) { - String sgName = stk.nextToken(); - rs.pushGrammar(rs.getRules().getSubGrammar(sgName)); - } - - public static WeightedGrammar fromStream(InputStream is) { - ReaderState rs = new ReaderState(); - - Scanner scn = new Scanner(is); - - while (scn.hasNextLine()) { - String ln = scn.nextLine(); - - if (ln.equals("")) { - rs.setRule(null); - continue; - } - - StringTokenizer stk = new StringTokenizer(ln, " "); - - actMap.getOrDefault(stk.nextToken(), (stak, ras) -> doRule(stk.nextToken(), stak, ras)) - .accept(stk, rs); - } - - scn.close(); - return rs.getRules(); - } - - private static void initPragmas() { - pragmaMap = new HashMap<>(); - - pragmaMap.put("uniform", (stk, rs) -> rs.toggleUniformity()); - pragmaMap.put("subordinate", GrammarReader::subordinateGrammar); - pragmaMap.put("promote", GrammarReader::promoteGrammar); - pragmaMap.put("remove-sub-grammar", - GrammarReader::removeSubGrammar); - pragmaMap.put("remove-rule", GrammarReader::removeRule); - pragmaMap.put("load-sub-grammar", GrammarReader::loadSubGrammar); - pragmaMap.put("new-sub-grammar", - (stk, rs) -> rs.pushGrammar(new WeightedGrammar<>())); - pragmaMap.put("edit-sub-grammar", GrammarReader::editSubGrammar); - pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar()); - pragmaMap.put("save-sub-grammar", GrammarReader::saveGrammar); - } - - 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(); - String rName = stk.nextToken(); - - WeightedGrammar nwg = rs.getRules().getSubGrammar(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 sg = rs.popGrammar(); - rs.getRules().addSubGrammar(sgName, sg); - } - - private static void subordinateGrammar(StringTokenizer stk, - ReaderState rs) { - String gName = stk.nextToken(); - WeightedGrammar nwg = new WeightedGrammar<>(); - - nwg.addSubGrammar(gName, rs.getRules()); - rs.setRules(nwg); - } -} diff --git a/RGens/src/main/java/bjc/RGens/text/PragmaErrorException.java b/RGens/src/main/java/bjc/RGens/text/PragmaErrorException.java deleted file mode 100644 index 0f9cdc7..0000000 --- a/RGens/src/main/java/bjc/RGens/text/PragmaErrorException.java +++ /dev/null @@ -1,9 +0,0 @@ -package bjc.RGens.text; - -public class PragmaErrorException extends RuntimeException { - private static final long serialVersionUID = 7245421182038076899L; - - public PragmaErrorException(String message) { - super(message); - } -} diff --git a/RGens/src/main/java/bjc/RGens/text/ReaderState.java b/RGens/src/main/java/bjc/RGens/text/ReaderState.java deleted file mode 100644 index 1a2a36a..0000000 --- a/RGens/src/main/java/bjc/RGens/text/ReaderState.java +++ /dev/null @@ -1,47 +0,0 @@ -package bjc.RGens.text; - -import java.util.Stack; - -import bjc.utils.gen.WeightedGrammar; - -public class ReaderState { - private Stack> wg = new Stack>(); - - private String currRule = ""; - - // Pragma settings - private boolean isUniform = false; - - public void toggleUniformity() { - isUniform = !isUniform; - } - - public boolean isUniform() { - return isUniform; - } - - public WeightedGrammar getRules() { - return wg.peek(); - } - - public void setRule(String r) { - currRule = r; - } - - public String getRule() { - return currRule; - } - - public void setRules(WeightedGrammar nwg) { - wg.pop(); - wg.push(nwg); - } - - public void pushGrammar(WeightedGrammar nwg) { - wg.push(nwg); - } - - public WeightedGrammar popGrammar() { - return wg.pop(); - } -} diff --git a/RGens/src/main/java/bjc/RGens/text/UnknownPragmaException.java b/RGens/src/main/java/bjc/RGens/text/UnknownPragmaException.java deleted file mode 100644 index d02e3c0..0000000 --- a/RGens/src/main/java/bjc/RGens/text/UnknownPragmaException.java +++ /dev/null @@ -1,12 +0,0 @@ -package bjc.RGens.text; - -import java.util.InputMismatchException; - -public class UnknownPragmaException extends InputMismatchException { - public UnknownPragmaException(String m) { - super(m); - } - - private static final long serialVersionUID = -4277573484926638662L; - -} -- cgit v1.2.3