Move things around, and start on new parser.

1 files changed, 141 insertions, 0 deletions

diff --git a/RGens/src/main/java/bjc/rgens/server/CLIArgsParser.java b/RGens/src/main/java/bjc/rgens/server/CLIArgsParser.java
new file mode 100644
index 0000000..fa0d399
--- /dev/null
+++ b/RGens/src/main/java/bjc/rgens/server/CLIArgsParser.java
@@ -0,0 +1,141 @@
+package bjc.rgens.server;
+
+import java.io.File;
+
+public class CLIArgsParser {
+	public static void parseArgs(String[] args, GrammarServerEngine eng) {
+		boolean didTerminalOp = false;
+		boolean forceInteractive = false;
+
+		// @TODO report error status
+		boolean didError = false;
+
+		if(args.length < 0) return;
+		
+		if(args.length == 1 && args[0].equals("--help")) {
+			// @TODO show help
+		} else {
+			for(int i = 0; i < args.length; i++) {
+				String arg = args[i];
+
+				switch(arg) {
+					case "-lc":
+					case "--load-config-file":
+						String configFileName = args[++i];
+
+						eng.doLoadConfig(configFileName);
+						break;
+					case "-lg":
+					case "--load-grammar-file":
+						String grammarFileName = args[++i];
+
+						File grammarFile = new File(grammarFileName);
+
+						String ruleName = grammarFile.getName();
+						ruleName = ruleName.substring(0, ruleName.lastIndexOf('.'));
+
+						if(!args[i+1].startsWith("-")) {
+							ruleName = args[++i];
+						}
+
+						eng.doLoadGrammar(ruleName, grammarFileName);
+
+						break;
+					case "-ll":
+					case "--load-long-file":
+						String longRuleFileName = args[++i];
+
+						File longRuleFile = new File(longRuleFileName);
+
+						String longRuleName = longRuleFile.getName();
+						longRuleName = longRuleName.substring(0, longRuleName.lastIndexOf('.'));
+
+						if(!args[i+1].startsWith("-")) {
+							longRuleName = args[++i];
+						}
+
+						eng.doLoadLongRule(longRuleName, longRuleFileName);
+
+						break;
+					case "-ge":
+					case "--generate-exported-rule":
+						String exportedRuleName = args[++i];
+
+						if(eng.hasExportedRule(exportedRuleName)) {
+							eng.doGenerateExportedRule(exportedRuleName);
+							didTerminalOp = true;
+						} else {
+							System.out.printf("Error: No exported rule named %s\n", exportedRuleName);
+						}
+						break;
+					case "-gg":
+					case "--generate-grammar-rule":
+						String grammarName = args[++i];
+						
+						if(!eng.hasLoadedGrammar(grammarName)) {
+							System.out.printf("Error: No grammar named %s\n", grammarName);
+						} else {
+							String ruleToGenerate = "";
+
+							if(!args[i+1].startsWith("-")) {
+								ruleToGenerate = args[++i];
+							} else if(eng.hasInitialRule(grammarName)) {
+								ruleToGenerate = eng.getInitialRule(grammarName);
+							} else {
+								System.out.printf("Error: Grammar %s has no initial rule. A "
+										+ "rule must be provided.",grammarName);
+							}
+
+							eng.doGenerateGrammar(grammarName, ruleToGenerate);
+							didTerminalOp = true;
+						}
+						break;
+					case "-st":
+					case "--stress-test":
+						String thingToTest = args[++i];
+
+						// @TODO support testing rules from grammars
+						// 		 as well as a specified number of times
+						if(thingToTest.equals("*")) {
+							eng.doStressTest(10000);
+						} else {
+							eng.doStressTest(thingToTest, 1000);
+						}
+
+						didTerminalOp = true;
+
+						break;
+					case "-d":
+					case "--debug":
+						if(eng.debugMode) {
+							System.out.println("Warning: debug mode is already on. Use -nd or --no-debug"
+									+ " to turn it off");
+						} else {
+							eng.debugMode = true;
+						}
+						break;
+					case "-nd":
+					case "--no-debug":
+						if(!eng.debugMode) {
+							System.out.println("Warning: debug mode is already off. Use -d or --debug"
+									+ " to turn it on");
+						} else {
+							eng.debugMode = false;
+						}
+						break;
+					case "-i":
+					case "--interactive":
+						forceInteractive = true;
+						break;
+					default:
+						System.out.println("Error: Unrecognized argument " + arg);
+						break;
+				}
+			}
+		}
+
+		if(!forceInteractive && didTerminalOp) {
+			System.exit(didError ? 1 : 0);
+		}
+	}
+}