diff options
Diffstat (limited to 'RGens/src/main')
5 files changed, 404 insertions, 236 deletions
diff --git a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java index 279ef42..5b1615d 100644 --- a/RGens/src/main/java/bjc/RGens/ZadronsPouch.java +++ b/RGens/src/main/java/bjc/RGens/ZadronsPouch.java @@ -1,7 +1,7 @@ package bjc.RGens; import bjc.utils.funcdata.FunctionalStringTokenizer; -import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.IList; import bjc.utils.funcdata.FunctionalList; import bjc.utils.gen.RandomGrammar; @@ -22,7 +22,7 @@ public class ZadronsPouch { ZadronsPouch zp = new ZadronsPouch(); for (int i = 0; i < 100; i++) { - IFunctionalList<String> ls = zp.grammar + IList<String> ls = zp.grammar .generateListValues("<item>", " "); StringBuilder sb = new StringBuilder(); @@ -156,7 +156,7 @@ public class ZadronsPouch { } private void addRule(String rule, String... cases) { - IFunctionalList<IFunctionalList<String>> cses = new FunctionalList<>(); + IList<IList<String>> cses = new FunctionalList<>(); for (String strang : cases) { cses.add(FunctionalStringTokenizer.fromString(strang) diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java index c24b479..abf9d1f 100644 --- a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java +++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderApp.java @@ -1,7 +1,6 @@ package bjc.RGens.parser; import java.io.File; -import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.PrintStream; @@ -9,6 +8,7 @@ import java.io.PrintStream; import javax.swing.UIManager; import javax.swing.UnsupportedLookAndFeelException; +import bjc.utils.funcutils.ListUtils; import bjc.utils.gen.WeightedGrammar; import bjc.utils.gui.SimpleDialogs; import bjc.utils.gui.awt.SimpleFileDialog; @@ -42,55 +42,52 @@ public class GrammarReaderApp { File gramFile = SimpleFileDialog.getOpenFile(null, "Choose Grammar File", ".gram"); - WeightedGrammar<String> wg = null; + WeightedGrammar<String> grammar = null; + + try { + grammar = RBGrammarReader.fromPath(gramFile.toPath()); + } catch (IOException ioex) { + ioex.printStackTrace(); - try (FileInputStream fStream = new FileInputStream(gramFile)) { - wg = RBGrammarReader.fromStream(fStream); - } catch (IOException e) { - e.printStackTrace(); System.exit(1); } String initRule = ""; - if (!wg.hasInitialRule()) { - wg.getRuleNames().sort((leftString, rightString) -> { + if (!grammar.hasInitialRule()) { + grammar.getRuleNames().sort((leftString, rightString) -> { return leftString.compareTo(rightString); }); initRule = SimpleDialogs.getChoice(null, "Pick a initial rule", "Pick a initial rule to generate choices from", - wg.getRuleNames().toArray(new String[0])); + grammar.getRuleNames().toArray(new String[0])); } else { - initRule = wg.getInitialRule(); + initRule = grammar.getInitialRule(); } int count = SimpleDialogs.getWhole(null, "Enter number of repititions", "Enter the number of items to generate from the rule"); - File outpFile = SimpleFileDialog.getSaveFile(null, + File outputFile = SimpleFileDialog.getSaveFile(null, "Choose Grammar File"); - PrintStream ps = null; + PrintStream outputStream = null; try { - ps = new PrintStream(outpFile); + outputStream = new PrintStream(outputFile); } catch (FileNotFoundException e) { e.printStackTrace(); } for (int i = 0; i < count; i++) { - String s = wg.generateListValues(initRule, " ") - .reduceAux(new StringBuilder(), - (strang, strangBuilder) -> strangBuilder - .append(strang), - t -> t.toString()) - .replaceAll("\\s+", " "); - - ps.println(s); + String ruleResult = ListUtils.collapseTokens( + grammar.generateListValues(initRule, " ")); + + outputStream.println(ruleResult.replaceAll("\\s+", " ")); } - - ps.close(); + + outputStream.close(); } } diff --git a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderCLI.java b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderCLI.java index 96d2f25..8d8a334 100644 --- a/RGens/src/main/java/bjc/RGens/parser/GrammarReaderCLI.java +++ b/RGens/src/main/java/bjc/RGens/parser/GrammarReaderCLI.java @@ -2,7 +2,9 @@ package bjc.RGens.parser; import java.io.FileInputStream; import java.io.IOException; +import java.nio.file.Paths; +import bjc.utils.funcutils.ListUtils; import bjc.utils.gen.WeightedGrammar; /** @@ -12,7 +14,7 @@ import bjc.utils.gen.WeightedGrammar; * */ public class GrammarReaderCLI { - private static WeightedGrammar<String> wg = null; + private static WeightedGrammar<String> grammar = null; /** * Main application method @@ -32,32 +34,27 @@ public class GrammarReaderCLI { System.exit(0); } - String rName = args[1]; + String ruleName = args[1]; try (FileInputStream fStream = new FileInputStream(fName)) { - wg = GrammarReader.fromStream(fStream); + grammar = RBGrammarReader.fromPath(Paths.get(fName, "")); } catch (IOException e) { e.printStackTrace(); } - if (rName.equalsIgnoreCase("--list-rules")) { - for (String rn : wg.getRuleNames().toIterable()) { - System.out.println(rn); - } + if (ruleName.equalsIgnoreCase("--list-rules")) { + grammar.getRuleNames().forEach(System.out::println); + System.exit(0); } int rCount = Integer.parseInt(args[2]); for (int i = 0; i < rCount; i++) { - String s = wg.generateListValues(rName, " ") - .reduceAux(new StringBuilder(), - (strang, strangBuilder) -> strangBuilder - .append(strang), - t -> t.toString()) - .replaceAll("\\s+", " "); + String ruleResult = ListUtils.collapseTokens( + grammar.generateListValues(ruleName, " ")); - System.out.println(s); + System.out.println(ruleResult.replaceAll("\\s+", " ")); } } } diff --git a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java index 7f1af27..af03da0 100644 --- a/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java +++ b/RGens/src/main/java/bjc/RGens/parser/RBGrammarReader.java @@ -2,11 +2,7 @@ package bjc.RGens.parser; import java.io.FileInputStream; import java.io.IOException; -import java.io.InputStream; -import java.util.Hashtable; -import java.util.Map; -import java.util.StringTokenizer; -import java.util.function.BiConsumer; +import java.nio.file.Path; import bjc.utils.funcdata.FunctionalStringTokenizer; import bjc.utils.gen.WeightedGrammar; @@ -19,218 +15,214 @@ import bjc.utils.parserutils.RuleBasedConfigReader; * */ public class RBGrammarReader { - private static Map<String, BiConsumer<StringTokenizer, ReaderState>> pragmaMap; + private static RuleBasedConfigReader<ReaderState> reader; static { - initPragmas(); + setupReader(); + initPragmas(); } private static void addSubgrammarPragmas() { - pragmaMap.put("edit-sub-grammar", RBGrammarReader::editSubGrammar); - pragmaMap.put("edit-parent", (stk, rs) -> rs.popGrammar()); + reader.addPragma("new-sub-grammar", (tokenizer, state) -> { + state.startNewSubgrammar(); + }); - pragmaMap.put("load-sub-grammar", RBGrammarReader::loadSubGrammar); + reader.addPragma("load-sub-grammar", + RBGrammarReader::loadSubGrammar); + reader.addPragma("save-sub-grammar", RBGrammarReader::saveGrammar); - pragmaMap.put("new-sub-grammar", - (stk, rs) -> rs.pushGrammar(new WeightedGrammar<>())); + reader.addPragma("edit-sub-grammar", + RBGrammarReader::editSubGrammar); + reader.addPragma("edit-parent", (tokenizer, state) -> { + state.editParent(); + }); - pragmaMap.put("promote", RBGrammarReader::promoteGrammar); + reader.addPragma("promote", RBGrammarReader::promoteGrammar); + reader.addPragma("subordinate", + RBGrammarReader::subordinateGrammar); - pragmaMap.put("remove-sub-grammar", + reader.addPragma("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( - @SuppressWarnings("unused") StringTokenizer stk, - ReaderState rs) { + private static void debugGrammar(ReaderState state) { System.out.println("Printing rule names: "); - for (String rul : rs.currGrammar().getRuleNames().toIterable()) { - System.out.println("\t" + rul); + for (String currentRule : state.getRuleNames().toIterable()) { + System.out.println("\t" + currentRule); } System.out.println(); } - private static void doCase(StringTokenizer stk, ReaderState rs) { - int prob = 1; + private static void doCase(FunctionalStringTokenizer tokenizer, + ReaderState state) { + int ruleProbability = readOptionalProbability(tokenizer, state); - if (!rs.isUniform()) { - prob = Integer.parseInt(stk.nextToken()); - } - - rs.currGrammar().addCase(rs.getRule(), prob, - new FunctionalStringTokenizer(stk).toList(s -> s)); + state.addCase(ruleProbability, tokenizer.toList()); } - private static void editSubGrammar(StringTokenizer stk, - ReaderState rs) { - String sgName = stk.nextToken(); - rs.pushGrammar(rs.currGrammar().getSubgrammar(sgName)); + private static void editSubGrammar(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String subgrammarName = tokenizer.nextToken(); + + state.editSubgrammar(subgrammarName); } /** - * Read a grammar from a stream + * Read a grammar from a path + * + * @param inputPath + * The path to load the grammar from * - * @param is - * The stream to read from * @return A grammar read from the stream * - * TODO redo the implementation for this + * @throws IOException + * If something goes wrong during file reading + * */ - public static WeightedGrammar<String> fromStream(InputStream is) { - ReaderState rs = new ReaderState(); - rs.toggleUniformity(); + public static WeightedGrammar<String> fromPath(Path inputPath) + throws IOException { + ReaderState initialState = new ReaderState(inputPath); + + try (FileInputStream inputStream = new FileInputStream( + inputPath.toFile())) { + return reader.fromStream(inputStream, initialState) + .getGrammar(); + } catch (IOException ioex) { + throw ioex; + } + } - RuleBasedConfigReader<ReaderState> reader = new RuleBasedConfigReader<>( - null, null, null); + private static void importRule(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String ruleName = tokenizer.nextToken(); + String subgrammarName = tokenizer.nextToken(); - reader.setStartRule((stk, par) -> par.doWith((left, right) -> { - rs.currGrammar().addRule(left); - rs.setRule(left); + state.addGrammarAlias(subgrammarName, ruleName); + } - doCase(stk.getInternal(), right); - })); + private static void initialRule(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String initialRuleName = tokenizer.nextToken(); - reader.setContinueRule((stk, ras) -> { - doCase(stk.getInternal(), ras); - }); + state.setInitialRule(initialRuleName); + } - reader.setEndRule((ras) -> { - ras.setRule(null); + private static void initPragmas() { + addSubgrammarPragmas(); + + reader.addPragma("debug", (tokenizer, state) -> { + debugGrammar(state); }); - pragmaMap.forEach((name, act) -> { - reader.addPragma(name, (tokn, stat) -> { - act.accept(tokn.getInternal(), stat); - }); + reader.addPragma("uniform", (tokenizer, state) -> { + state.toggleUniformity(); }); - return reader.fromStream(is, rs).currGrammar(); - } + reader.addPragma("initial-rule", RBGrammarReader::initialRule); + + reader.addPragma("import-rule", RBGrammarReader::importRule); - private static void importRule(StringTokenizer stk, ReaderState rs) { - String ruleName = stk.nextToken(); - String sgName = stk.nextToken(); + reader.addPragma("remove-rule", RBGrammarReader::removeRule); - rs.currGrammar().addGrammarAlias(sgName, ruleName); + reader.addPragma("prefix-with", RBGrammarReader::prefixRule); + reader.addPragma("suffix-with", RBGrammarReader::suffixRule); } - private static void initialRule(StringTokenizer stk, ReaderState rs) { - String rName = stk.nextToken(); + private static void loadSubGrammar(FunctionalStringTokenizer stk, + ReaderState rs) { + String subgrammarName = stk.nextToken(); + String subgrammarPath = stk.nextToken(); - rs.setInitialRule(rName); + rs.loadSubgrammar(subgrammarName, subgrammarPath); } - private static void initPragmas() { - pragmaMap = new Hashtable<>(); + private static void prefixRule(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String ruleName = tokenizer.nextToken(); + String prefixToken = tokenizer.nextToken(); - addSubgrammarPragmas(); + int additionalProbability = readOptionalProbability(tokenizer, + state); - pragmaMap.put("debug", RBGrammarReader::debugGrammar); - pragmaMap.put("import-rule", RBGrammarReader::importRule); - pragmaMap.put("initial-rule", RBGrammarReader::initialRule); - pragmaMap.put("uniform", (stk, rs) -> rs.toggleUniformity()); + state.prefixRule(ruleName, prefixToken, additionalProbability); + } - pragmaMap.put("multi-prefix-with", - RBGrammarReader::multiPrefixRule); - pragmaMap.put("multi-suffix-with", - RBGrammarReader::multiSuffixRule); + private static void promoteGrammar(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String subgrammarName = tokenizer.nextToken(); + String subordinateName = tokenizer.nextToken(); - pragmaMap.put("prefix-with", RBGrammarReader::prefixRule); - pragmaMap.put("suffix-with", RBGrammarReader::suffixRule); + state.promoteGrammar(subgrammarName, subordinateName); } - private static void loadSubGrammar(StringTokenizer stk, - ReaderState rs) { - String sgName = stk.nextToken(); - String fName = stk.nextToken(); + private static int readOptionalProbability( + FunctionalStringTokenizer tokenizer, ReaderState state) { + if (state.isUniform()) { + return 0; + } - try (FileInputStream fStream = new FileInputStream(fName)) { - rs.currGrammar().addSubgrammar(sgName, fromStream(fStream)); - } catch (IOException e) { - PragmaErrorException peex = new PragmaErrorException( - "Could not load subgrammar " + sgName + " from file " - + fName); + return Integer.parseInt(tokenizer.nextToken()); + } - peex.initCause(e); + private static void removeRule(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String ruleName = tokenizer.nextToken(); - throw peex; - } + state.deleteRule(ruleName); } - @SuppressWarnings("unused") - private static void multiPrefixRule(StringTokenizer stk, - ReaderState rs) { - // TODO implement me :) - } + private static void removeSubGrammar( + FunctionalStringTokenizer tokenizer, ReaderState state) { + String subgrammarName = tokenizer.nextToken(); - @SuppressWarnings("unused") - private static void multiSuffixRule(StringTokenizer stk, - ReaderState rs) { - // TODO implement me :) + state.deleteSubgrammar(subgrammarName); } - 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()); + private static void saveGrammar(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String subgrammarName = tokenizer.nextToken(); - rs.currGrammar().prefixRule(rName, prefixToken, addProb); + state.saveSubgrammar(subgrammarName); } - private static void promoteGrammar(StringTokenizer stk, - ReaderState rs) { - String gName = stk.nextToken(); - String rName = stk.nextToken(); + private static void setupReader() { + reader = new RuleBasedConfigReader<>(null, null, null); - WeightedGrammar<String> nwg = rs.currGrammar() - .getSubgrammar(gName); - rs.currGrammar().deleteSubgrammar(gName); + reader.setStartRule((tokenizer, stateTokenPair) -> { + stateTokenPair.doWith((initToken, state) -> { + state.startNewRule(initToken); - nwg.addSubgrammar(rName, rs.currGrammar()); - rs.setRules(nwg); - } + doCase(tokenizer, state); + }); + }); - private static void removeRule(StringTokenizer stk, ReaderState rs) { - String rName = stk.nextToken(); + reader.setContinueRule((tokenizer, state) -> { + doCase(tokenizer, state); + }); - rs.currGrammar().deleteRule(rName); + reader.setEndRule((tokenizer) -> { + tokenizer.setCurrentRule(null); + }); } - private static void removeSubGrammar(StringTokenizer stk, - ReaderState rs) { - String sgName = stk.nextToken(); - rs.currGrammar().deleteSubgrammar(sgName); - } + private static void subordinateGrammar( + FunctionalStringTokenizer tokenizer, ReaderState state) { + String grammarName = tokenizer.nextToken(); - private static void saveGrammar(StringTokenizer stk, ReaderState rs) { - String sgName = stk.nextToken(); - WeightedGrammar<String> sg = rs.popGrammar(); - rs.currGrammar().addSubgrammar(sgName, sg); + state.subordinateGrammar(grammarName); } - private static void subordinateGrammar(StringTokenizer stk, - ReaderState rs) { - String gName = stk.nextToken(); - WeightedGrammar<String> nwg = new WeightedGrammar<>(); - - nwg.addSubgrammar(gName, rs.currGrammar()); - rs.setRules(nwg); - } + private static void suffixRule(FunctionalStringTokenizer tokenizer, + ReaderState state) { + String ruleName = tokenizer.nextToken(); + String suffixToken = tokenizer.nextToken(); - 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()); + int additionalProbability = readOptionalProbability(tokenizer, + state); - rs.currGrammar().suffixRule(rName, prefixToken, addProb); + state.suffixRule(ruleName, suffixToken, additionalProbability); } } diff --git a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java index e115530..680f67b 100644 --- a/RGens/src/main/java/bjc/RGens/parser/ReaderState.java +++ b/RGens/src/main/java/bjc/RGens/parser/ReaderState.java @@ -1,7 +1,10 @@ package bjc.RGens.parser; +import java.io.IOException; +import java.nio.file.Path; import java.util.Stack; +import bjc.utils.funcdata.IList; import bjc.utils.gen.WeightedGrammar; /** @@ -11,112 +14,291 @@ import bjc.utils.gen.WeightedGrammar; * */ public class ReaderState { - private String currRule = ""; + private WeightedGrammar<String> currentGrammar; - // Pragma settings - private boolean isUniform = false; + private Stack<WeightedGrammar<String>> grammarStack; - private Stack<WeightedGrammar<String>> wg; + private String currentRule; + + private boolean isUniform; + + private Path currentDirectory; /** * Create a new reader state + * + * @param inputPath + * The path to this grammar */ - public ReaderState() { - wg = new Stack<>(); - wg.push(new WeightedGrammar<>()); + public ReaderState(Path inputPath) { + grammarStack = new Stack<>(); + + currentGrammar = new WeightedGrammar<>(); + + // Grammars start out uniform + isUniform = true; + + currentDirectory = inputPath.getParent(); } /** - * Get the current grammar + * Get the rule names for the current grammar * - * @return The current grammar + * @return The rule names for the current grammar */ - public WeightedGrammar<String> currGrammar() { - return wg.peek(); + public IList<String> getRuleNames() { + return currentGrammar.getRuleNames(); } /** - * Get the current rule + * Check if this reader is currently in uniform mode * - * @return The current rule + * @return Whether this grammar is in uniform mode */ - public String getRule() { - return currRule; + public boolean isUniform() { + return isUniform; } /** - * Use {@link #currGrammar()} instead + * Set the current grammar to be the specified one * - * @return The current grammar + * @param newWorkingGrammar + * The new grammar to use */ - @Deprecated - public WeightedGrammar<String> getRules() { - return wg.peek(); + public void setCurrentGrammar( + WeightedGrammar<String> newWorkingGrammar) { + currentGrammar = newWorkingGrammar; } /** - * Check if this reader is currently in uniform mode + * Set the rule currently being worked on * - * @return Whether this grammar is in uniform mode + * @param ruleName + * The rule currently being worked on */ - public boolean isUniform() { - return isUniform; + public void setCurrentRule(String ruleName) { + currentRule = ruleName; } /** - * Pop the grammar currently being worked on + * Set the initial rule of this grammar * - * @return The grammar currently being worked on + * @param ruleName + * The initial rule of this grammar */ - public WeightedGrammar<String> popGrammar() { - return wg.pop(); + public void setInitialRule(String ruleName) { + currentGrammar.setInitialRule(ruleName); } /** - * Push a new grammar to work on + * Toggle this uniformity setting for this grammar + */ + public void toggleUniformity() { + isUniform = !isUniform; + } + + /** + * Start work on a new sub-grammar of the previous grammar + */ + public void startNewSubgrammar() { + grammarStack.push(currentGrammar); + + currentGrammar = new WeightedGrammar<>(); + } + + /** + * Move to editing the grammar that is the parent of this current one + */ + public void editParent() { + currentGrammar = grammarStack.pop(); + } + + /** + * Add a case to the current grammar * - * @param nwg - * The new grammar to work on + * @param ruleProbability + * The probability for this case to occur + * @param ruleParts + * The parts that make up this case */ - public void pushGrammar(WeightedGrammar<String> nwg) { - wg.push(nwg); + public void addCase(int ruleProbability, + IList<String> ruleParts) { + currentGrammar.addCase(currentRule, ruleProbability, ruleParts); } /** - * Set the initial rule of this grammar + * Edit a subgrammar of the current grammar * - * @param rName - * The initial rule of this grammar + * @param subgrammarName + * The name of the subgrammar to edit */ - public void setInitialRule(String rName) { - wg.peek().setInitialRule(rName); + public void editSubgrammar(String subgrammarName) { + WeightedGrammar<String> subgrammar = currentGrammar + .getSubgrammar(subgrammarName); + + grammarStack.push(currentGrammar); + + currentGrammar = subgrammar; } /** - * Set the rule currently being worked on + * Start editing a new rule in the current grammar * - * @param r - * The rule currently being worked on + * @param ruleName + * The name of the new rule to edit */ - public void setRule(String r) { - currRule = r; + public void startNewRule(String ruleName) { + currentGrammar.addRule(ruleName); } /** - * Set the current grammar to be the specified one + * Convert this package of state into a weighted grammar * - * @param nwg - * The new grammar to use + * @return The grammar represented by this state */ - public void setRules(WeightedGrammar<String> nwg) { - wg.pop(); - wg.push(nwg); + public WeightedGrammar<String> getGrammar() { + return currentGrammar; } /** - * Toggle this grammars uniformity setting + * Alias a current subgrammar to a new name + * + * @param subgrammarName + * The name of the subgrammar to alias + * @param subgrammarAlias + * The name of the alias for the subgrammar */ - public void toggleUniformity() { - isUniform = !isUniform; + public void addGrammarAlias(String subgrammarName, + String subgrammarAlias) { + currentGrammar.addGrammarAlias(subgrammarName, subgrammarAlias); + } + + /** + * Load a subgrammar into this one. + * + * @param subgrammarName + * The name to assign to the subgrammar + * @param subgrammarPath + * The path to load the subgrammar from + */ + public void loadSubgrammar(String subgrammarName, + String subgrammarPath) { + Path loadPath = currentDirectory.resolve(subgrammarPath); + + try { + WeightedGrammar<String> subgrammar = RBGrammarReader + .fromPath(loadPath); + + currentGrammar.addSubgrammar(subgrammarName, subgrammar); + } catch (IOException ioex) { + PragmaErrorException peex = new PragmaErrorException( + "Couldn't load subgrammar " + subgrammarName + " from " + + subgrammarPath); + + peex.initCause(ioex); + + throw peex; + } + } + + /** + * Prefix a token onto all of the cases for the specified rule + * + * @param ruleName + * The rule to do prefixing on + * @param prefixToken + * The token to prefix onto each case + * @param additionalProbability + * The probability modification of the prefixed cases + */ + public void prefixRule(String ruleName, String prefixToken, + int additionalProbability) { + currentGrammar.prefixRule(ruleName, prefixToken, + additionalProbability); + } + + /** + * Promote the specified subgrammar above the current grammar + * + * @param subgrammarName + * The name of the subgrammar to promote + * @param subordinateName + * The name to bind this grammar to the subgrammar under + */ + public void promoteGrammar(String subgrammarName, + String subordinateName) { + WeightedGrammar<String> subgrammar = currentGrammar + .getSubgrammar(subgrammarName); + + currentGrammar.deleteSubgrammar(subgrammarName); + + subgrammar.addSubgrammar(subordinateName, currentGrammar); + + currentGrammar = subgrammar; + } + + /** + * Delete a rule from the current subgrammar + * + * @param ruleName + * The name of the rule to delete + */ + public void deleteRule(String ruleName) { + currentGrammar.deleteRule(ruleName); + } + + /** + * Delete a subgrammar from the current grammar + * + * @param subgrammarName + * The name of the subgrammar to delete + */ + public void deleteSubgrammar(String subgrammarName) { + currentGrammar.deleteSubgrammar(subgrammarName); + } + + /** + * Save the current grammar as a subgrammar of the previous one + * + * @param subgrammarName + * The name of the subgrammar to save this under + */ + public void saveSubgrammar(String subgrammarName) { + WeightedGrammar<String> newWorkingGrammar = grammarStack.pop(); + + newWorkingGrammar.addSubgrammar(subgrammarName, currentGrammar); + + currentGrammar = newWorkingGrammar; + } + + /** + * Subordinate this grammar as a subgrammar to a new grammar + * + * @param grammarName + * The name for the subgrammar to bind the current grammar + * to + */ + public void subordinateGrammar(String grammarName) { + WeightedGrammar<String> newWorkingGrammar = new WeightedGrammar<>(); + + newWorkingGrammar.addSubgrammar(grammarName, currentGrammar); + + currentGrammar = newWorkingGrammar; + } + + /** + * Suffix a token onto all of the cases for the specified rule + * + * @param ruleName + * The rule to do suffixing on + * @param suffixToken + * The token to suffix onto each case + * @param additionalProbability + * The probability modification of the suffixed cases + */ + public void suffixRule(String ruleName, String suffixToken, + int additionalProbability) { + currentGrammar.suffixRule(ruleName, suffixToken, + additionalProbability); } } |