diff options
Diffstat (limited to 'RGens/src/main/java')
| -rw-r--r-- | RGens/src/main/java/bjc/RGens/server/GrammarServer.java | 249 | ||||
| -rw-r--r-- | RGens/src/main/java/bjc/RGens/server/ServerGrammarReader.java | 319 |
2 files changed, 305 insertions, 263 deletions
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) { |