General cleanup

19 files changed, 103 insertions, 145 deletions

diff --git a/src/main/java/bjc/rgens/parser/ConfigLoader.java b/src/main/java/bjc/rgens/parser/ConfigLoader.java
index 97ca257..980a878 100644
--- a/src/main/java/bjc/rgens/parser/ConfigLoader.java
+++ b/src/main/java/bjc/rgens/parser/ConfigLoader.java
@@ -1,7 +1,7 @@
 package bjc.rgens.parser;
 
 import bjc.utils.funcutils.FileUtils;
-import bjc.utils.funcutils.StringUtils;
+import bjc.utils.ioutils.LevelSplitter;
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -57,7 +57,7 @@ public class ConfigLoader {
 					if (ln.startsWith("#")) continue;
 
 					ln = ln.replaceAll("\\s+", " ");
-					String[] parts = StringUtils.levelSplit(ln, " ").toArray(new String[0]);
+					String[] parts = LevelSplitter.def.levelSplit(ln, " ").toArray(new String[0]);
 
 					/* Get line type */
 					if(parts.length < 1) {
diff --git a/src/main/java/bjc/rgens/parser/GenerationState.java b/src/main/java/bjc/rgens/parser/GenerationState.java
index 35d831d..3a6f827 100644
--- a/src/main/java/bjc/rgens/parser/GenerationState.java
+++ b/src/main/java/bjc/rgens/parser/GenerationState.java
@@ -1,8 +1,6 @@
 package bjc.rgens.parser;
 
 import bjc.utils.esodata.MapSet;
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
 import bjc.utils.ioutils.ReportWriter;
 
 import java.io.IOException;
@@ -13,6 +11,7 @@ import java.util.Map;
 import java.util.Random;
 
 import static bjc.rgens.parser.RGrammarLogging.*;
+
 /* 
  * The current state during generation.
  *
@@ -39,28 +38,32 @@ public class GenerationState {
 	/**
 	 * Create a new generation state.
 	 * 
-	 * @param cont
-	 *            The string being generated.
+	 * @param rw
+	 *                The place to write the string.
 	 *
 	 * @param rand
-	 *            The RNG to use.
+	 *                The RNG to use.
 	 *
 	 * @param vs
-	 *            The variables to use.
+	 *                The variables to use.
+	 * @param rvs
+	 *                The rule variables to use.
+	 * @param gram
+	 *                The current grammar.
 	 */
-	public GenerationState(ReportWriter rw, Random rand, Map<String, String> vs,
-			Map<String, Rule> rvs, RGrammar gram) {
-		vars   = new MapSet<>();
+	public GenerationState(ReportWriter rw, Random rand, Map<String, String> vs, Map<String, Rule> rvs,
+			RGrammar gram) {
+		vars = new MapSet<>();
 		rlVars = new MapSet<>();
 
 		contents = rw;
-		rnd      = rand;
+		rnd = rand;
 
 		vars.setPutMap(gram.name, vs);
 		rlVars.setPutMap(gram.name, rvs);
 
 		this.gram = gram;
-	
+
 		this.rules = gram.getRules();
 		this.importRules = gram.getImportRules();
 	}
@@ -76,12 +79,12 @@ public class GenerationState {
 	}
 
 	public void swapGrammar(RGrammar gram) {
-		if(this.gram == gram) return;
+		if (this.gram == gram) return;
 
 		this.gram = gram;
 
 		rules = gram.getRules();
-		
+
 		importRules = gram.getImportRules();
 
 		vars.setCreateMap(gram.name);
@@ -109,63 +112,58 @@ public class GenerationState {
 	 * are imported, and which aren't
 	 */
 	public Rule findRule(String ruleName, boolean allowImports) {
-		if(rules.containsKey(ruleName)) {
+		if (rules.containsKey(ruleName)) {
 			return rules.get(ruleName);
 		}
 
-		if(allowImports) return findImport(ruleName);
+		if (allowImports) return findImport(ruleName);
 
 		return null;
 	}
 
 	public Rule findImport(String ruleName) {
-		if(importRules.containsKey(ruleName)) {
-			return  importRules.get(ruleName);
+		if (importRules.containsKey(ruleName)) {
+			return importRules.get(ruleName);
 		}
 
 		return null;
 	}
 
 	public void defineVar(String name, String val) {
-		if(vars.containsKey(name)) 
-			warn("Shadowing variable %s with value %s (old value %s)",
-					name, val, vars.get(name));
+		if (vars.containsKey(name))
+			warn("Shadowing variable %s with value %s (old value %s)", name, val, vars.get(name));
 		else if (gram.autoVars.containsKey(name))
-			warn("Shadowing autovariable %s with value %s (defn. %s)",
-					name, val, gram.autoVars.get(name));
+			warn("Shadowing autovariable %s with value %s (defn. %s)", name, val, gram.autoVars.get(name));
 
 		vars.put(name, val);
 	}
 
 	public void defineRuleVar(String name, Rule rle) {
-		if(rlVars.containsKey(name))
-			warn("Shadowing rule variable %s with value %s (old value %s)",
-					name, rlVars.get(name), rle);
+		if (rlVars.containsKey(name))
+			warn("Shadowing rule variable %s with value %s (old value %s)", name, rlVars.get(name), rle);
 		else if (gram.autoRlVars.containsKey(name))
-			warn("Shadowing rule autovariable %s with value %s (defn. %s)",
-					name, rle, gram.autoRlVars.get(name));
+			warn("Shadowing rule autovariable %s with value %s (defn. %s)", name, rle,
+					gram.autoRlVars.get(name));
 
 		rlVars.put(name, rle);
 	}
 
 	public String findVar(String name) {
-		if(!vars.containsKey(name)) 
-			if(gram.autoVars.containsKey(name)) {
-				gram.autoVars.get(name).generate(this);
-			} else {
-				throw new GrammarException(String.format("Variable %s not defined", name));
-			}
+		if (!vars.containsKey(name)) if (gram.autoVars.containsKey(name)) {
+			gram.autoVars.get(name).generate(this);
+		} else {
+			throw new GrammarException(String.format("Variable %s not defined", name));
+		}
 
 		return vars.get(name);
 	}
 
 	public Rule findRuleVar(String name) {
-		if(!rlVars.containsKey(name))
-			if(gram.autoRlVars.containsKey(name)) {
-				gram.autoRlVars.get(name).generate(this);
-			} else {
-				throw new GrammarException(String.format("Rule variable %s not defined", name));
-			}
+		if (!rlVars.containsKey(name)) if (gram.autoRlVars.containsKey(name)) {
+			gram.autoRlVars.get(name).generate(this);
+		} else {
+			throw new GrammarException(String.format("Rule variable %s not defined", name));
+		}
 
 		return rlVars.get(name);
 	}
diff --git a/src/main/java/bjc/rgens/parser/RGrammar.java b/src/main/java/bjc/rgens/parser/RGrammar.java
index 20ce320..1286d1b 100755
--- a/src/main/java/bjc/rgens/parser/RGrammar.java
+++ b/src/main/java/bjc/rgens/parser/RGrammar.java
@@ -1,34 +1,26 @@
 package bjc.rgens.parser;
 
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
-import bjc.utils.funcutils.StringUtils;
-import bjc.utils.ioutils.ReportWriter;
-
-import bjc.rgens.parser.elements.*;
+import static bjc.utils.data.IPair.pair;
 
 import java.io.StringWriter;
-
-import java.util.Arrays;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;
 import java.util.Set;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 import org.apache.commons.text.similarity.LevenshteinDistance;
 
+import bjc.rgens.parser.elements.CaseElement;
+import bjc.utils.data.IPair;
+import bjc.utils.ioutils.ReportWriter;
 import edu.gatech.gtri.bktree.BkTreeSearcher;
-import edu.gatech.gtri.bktree.BkTreeSearcher.Match;
 import edu.gatech.gtri.bktree.Metric;
 import edu.gatech.gtri.bktree.MutableBkTree;
 
-import static bjc.utils.data.IPair.pair;
-
 /**
  * Represents a randomized grammar.
  *
@@ -229,7 +221,7 @@ public class RGrammar {
 		Rule rl = state.findRule(fromRule, false);
 
 		if(rl == null)
-			throw new GrammarException("Could not find rule " + rl.name);
+			throw new GrammarException("Could not find rule " + fromRule);
 
 		rl.generate(state);
 
diff --git a/src/main/java/bjc/rgens/parser/RGrammarBuilder.java b/src/main/java/bjc/rgens/parser/RGrammarBuilder.java
index 535d818..14b524f 100755
--- a/src/main/java/bjc/rgens/parser/RGrammarBuilder.java
+++ b/src/main/java/bjc/rgens/parser/RGrammarBuilder.java
@@ -1,8 +1,6 @@
 package bjc.rgens.parser;
 
 import bjc.rgens.parser.elements.CaseElement;
-import bjc.rgens.parser.elements.VariableDefCaseElement;
-
 import bjc.utils.data.IPair;
 import bjc.utils.data.Pair;
 import bjc.utils.funcdata.FunctionalList;
@@ -150,8 +148,8 @@ public class RGrammarBuilder {
 	 * @param ruleName
 	 * 	The rule to suffix.
 	 *
-	 * @param suffix
-	 * 	The suffix to add.
+	 * @param suffixes
+	 * 	The suffixes to add.
 	 *
 	 * @throws IllegalArgumentException
 	 * 	If the rule name is either invalid or not defined by this
@@ -168,8 +166,8 @@ public class RGrammarBuilder {
 	 * @param ruleName
 	 * 	The rule to prefix.
 	 *
-	 * @param prefix
-	 * 	The prefix to add.
+	 * @param prefixes
+	 * 	The prefixes to add.
 	 *
 	 * @throws IllegalArgumentException
 	 * 	If the rule name is either invalid or not defined by this
@@ -185,8 +183,8 @@ public class RGrammarBuilder {
 	 * @param ruleName
 	 * 	The rule to prefix and suffix.
 	 *
-	 * @param prefix
-	 * 	The prefix/suffix to add.
+	 * @param prefixes
+	 * 	The prefixes/suffixes to add.
 	 *
 	 * @throws IllegalArgumentException
 	 * 	If the rule name is either invalid or not defined by this
diff --git a/src/main/java/bjc/rgens/parser/RGrammarParser.java b/src/main/java/bjc/rgens/parser/RGrammarParser.java
index a95cefc..94c9976 100755
--- a/src/main/java/bjc/rgens/parser/RGrammarParser.java
+++ b/src/main/java/bjc/rgens/parser/RGrammarParser.java
@@ -1,31 +1,26 @@
 package bjc.rgens.parser;
 
-import bjc.rgens.parser.elements.*;
+import static bjc.rgens.parser.RGrammarLogging.warn;
 
-import bjc.utils.data.IPair;
+import java.io.Reader;
+import java.io.StringReader;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import bjc.rgens.parser.RGrammarBuilder.AffixType;
+import bjc.rgens.parser.elements.CaseElement;
+import bjc.rgens.parser.elements.ChanceCaseElement;
+import bjc.rgens.parser.elements.SerialCaseElement;
+import bjc.rgens.parser.elements.VariableDefCaseElement;
 import bjc.utils.data.Pair;
 import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
-import bjc.utils.funcutils.ListUtils;
-import bjc.utils.funcutils.SetUtils;
-import bjc.utils.funcutils.StringUtils;
 import bjc.utils.funcutils.TriConsumer;
+import bjc.utils.ioutils.LevelSplitter;
 import bjc.utils.ioutils.blocks.Block;
 import bjc.utils.ioutils.blocks.BlockReader;
 import bjc.utils.ioutils.blocks.SimpleBlockReader;
-
-import java.io.Reader;
-import java.io.StringReader;
-import java.util.Arrays;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.LinkedList;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-
-import static bjc.rgens.parser.RGrammarLogging.*;
-import static bjc.rgens.parser.RGrammarBuilder.AffixType;
 /**
  * Reads {@link RGrammar} from a input stream.
  *
@@ -61,7 +56,7 @@ public class RGrammarParser {
 		pragmas = new HashMap<>();
 
 		pragmas.put("initial-rule", (body, build, level) -> {
-			List<String> bits = StringUtils.levelSplit(body, " ");
+			List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 			if (bits.size() != 1) {
 				String msg = "Must specify initial rule";
@@ -72,7 +67,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("grammar-name", (body, build, level) -> {
-			List<String> bits = StringUtils.levelSplit(body, " ");
+			List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 			if (bits.size() != 1) {
 				String msg = "Must specify grammar name";
@@ -83,7 +78,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("despace-rule", (body, build, level) -> {
-			List<String> bits = StringUtils.levelSplit(body, " ");
+			List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 			if (bits.size() < 1) {
 				throw new GrammarException("Must specify rules to despace");
@@ -95,7 +90,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("export-rule", (body, build, level) -> {
-			List<String> exports = StringUtils.levelSplit(body, " ");
+			List<String> exports = LevelSplitter.def.levelSplit(body, " ");
 
 			if(exports.size() < 1) {
 				throw new GrammarException("Must specify rules to export");
@@ -107,7 +102,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("recur-limit", (body, build, level) -> {
-			List<String> parts = StringUtils.levelSplit(body, " ");
+			List<String> parts = LevelSplitter.def.levelSplit(body, " ");
 
 			if(parts.size() != 2) {
 				throw new GrammarException("Recur-limit pragma takes two arguments: the name of the rule to set the limit for, and the new value of the limit");
@@ -121,7 +116,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("enable-weight", (body, build, level) -> {
-			List<String> parts = StringUtils.levelSplit(body, " ");
+			List<String> parts = LevelSplitter.def.levelSplit(body, " ");
 
 			if(parts.size() != 1) {
 				throw new GrammarException("Enable-weight pragma takes one argument: the name of the rule to set the weight factor for");
@@ -131,7 +126,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("enable-descent", (body, build, level) -> {
-			List<String> parts = StringUtils.levelSplit(body, " ");
+			List<String> parts = LevelSplitter.def.levelSplit(body, " ");
 
 			if(parts.size() != 2) {
 				throw new GrammarException("Enable-descent pragma takes two arguments: the name of the rule to set the descent factor for, and the new value of the factor");
@@ -150,7 +145,7 @@ public class RGrammarParser {
 			// This can be kind of hard to read right off. Is there
 			// a format to put stuff in that looks better and is
 			// more readable?
-			List<String> parts = StringUtils.levelSplit(body, " ");
+			List<String> parts = LevelSplitter.def.levelSplit(body, " ");
 
 			if(parts.size() != 4) {
 				throw new GrammarException("Enable-descent pragma takes four arguments: the name of the rule to set the binomial factors for, and the three binomial parameters (target, bound trials)");
@@ -178,7 +173,7 @@ public class RGrammarParser {
 		 * extra power. No examples are apparent at the moment.
 		 */
 		pragmas.put("find-replace-rule", (body, build, level) -> {
-			List<String> bits = StringUtils.levelSplit(body, " ");
+			List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 			if(bits.size() != 3) {
 				throw new GrammarException("Regex-rule pragma takes three arguments: the name of the rule to process, then the find/replace pair to apply after the rule has been generated.");
@@ -188,7 +183,7 @@ public class RGrammarParser {
 		});
 
 		pragmas.put("reject-rule", (body, build, level) -> {
-			List<String> bits = StringUtils.levelSplit(body, " ");
+			List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 			if(bits.size() != 3) {
 				throw new GrammarException("Reject-rule pragma takes two arguments: the name of the rule to process, then the rejection pattern to apply after the rule has been generated.");
@@ -273,7 +268,7 @@ public class RGrammarParser {
 	}
 
 	private static void doAutoVar(String body, RGrammarBuilder build, int level, boolean isRule) {
-		List<String> bits = StringUtils.levelSplit(body, " ");
+		List<String> bits = LevelSplitter.def.levelSplit(body, " ");
 
 		if (bits.size() < 1) {
 			String msg = "Must specify name of variable and definition to autovivify";
@@ -559,7 +554,6 @@ public class RGrammarParser {
 				String ctxDelim = String.format(TMPL_TOPLEVEL_BLOCK_DELIM, level + 1);
 
 				try (BlockReader bodyReader = new SimpleBlockReader(ctxDelim, ctxReader)) {
-					@SuppressWarnings("unused")
 					Block whereBody = whereReader.next();
 					whereBody.lineOffset = lineOffset + whereCtx.startLine;
 
@@ -590,7 +584,7 @@ public class RGrammarParser {
 		 * as groupers breaks certain grammars. Maybe it can be used if
 		 * some sort of way to set which groupers to use is added?
 		 *
-		 *  List<String> cseList = StringUtils.levelSplit(cses.trim(), " ");
+		 *  List<String> cseList = LevelSplitter.def.levelSplit(cses.trim(), " ");
 		 *
 		 *  return parseElementString(cseList.toArray(new String[0]));
 		 */
diff --git a/src/main/java/bjc/rgens/parser/RGrammarSet.java b/src/main/java/bjc/rgens/parser/RGrammarSet.java
index 30f08a4..1ea61b1 100755
--- a/src/main/java/bjc/rgens/parser/RGrammarSet.java
+++ b/src/main/java/bjc/rgens/parser/RGrammarSet.java
@@ -2,7 +2,6 @@ package bjc.rgens.parser;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.TreeMap;
 import java.util.Set;
 
 import static bjc.rgens.parser.RGrammarLogging.*;
diff --git a/src/main/java/bjc/rgens/parser/RegexRuleCase.java b/src/main/java/bjc/rgens/parser/RegexRuleCase.java
index 3c57489..9522428 100755
--- a/src/main/java/bjc/rgens/parser/RegexRuleCase.java
+++ b/src/main/java/bjc/rgens/parser/RegexRuleCase.java
@@ -3,9 +3,6 @@ package bjc.rgens.parser;
 import bjc.rgens.parser.elements.CaseElement;
 import bjc.utils.funcdata.IList;
 
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-
 /*
  * @TODO
  *
@@ -18,7 +15,7 @@ public class RegexRuleCase extends RuleCase {
 	}
 
 	public void generate(GenerationState state) {
-
+		// TODO
 	}
 
 	public RegexRuleCase withElements(IList<CaseElement> elements) {
diff --git a/src/main/java/bjc/rgens/parser/Rule.java b/src/main/java/bjc/rgens/parser/Rule.java
index 1a74352..a24bb1c 100755
--- a/src/main/java/bjc/rgens/parser/Rule.java
+++ b/src/main/java/bjc/rgens/parser/Rule.java
@@ -1,7 +1,6 @@
 package bjc.rgens.parser;
 
 import bjc.utils.data.IPair;
-import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
 import bjc.utils.gen.WeightedRandom;
 
diff --git a/src/main/java/bjc/rgens/parser/elements/BlankCaseElement.java b/src/main/java/bjc/rgens/parser/elements/BlankCaseElement.java
index 66ff310..7229e92 100755
--- a/src/main/java/bjc/rgens/parser/elements/BlankCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/BlankCaseElement.java
@@ -1,7 +1,5 @@
 package bjc.rgens.parser.elements;
 
-import bjc.rgens.parser.GenerationState;
-
 public class BlankCaseElement extends LiteralCaseElement {
 	public BlankCaseElement() {
 		super("");
diff --git a/src/main/java/bjc/rgens/parser/elements/CaseElement.java b/src/main/java/bjc/rgens/parser/elements/CaseElement.java
index fa398e7..9c23ef2 100755
--- a/src/main/java/bjc/rgens/parser/elements/CaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/CaseElement.java
@@ -1,7 +1,6 @@
 package bjc.rgens.parser.elements;
 
-import bjc.utils.funcutils.StringUtils;
-
+import bjc.utils.ioutils.LevelSplitter;
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 
@@ -85,7 +84,7 @@ public abstract class CaseElement {
 			String specialBody = csepart.substring(1, csepart.length() - 1);
 
 			if (specialBody.matches("\\S+:\\S=\\S+")) {
-				String[] parts = StringUtils.levelSplit(specialBody, "=").toArray(new String[0]);
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
 
 				if(parts.length != 2) {
 					throw new GrammarException("Colon variables must have a name and a definition");
@@ -102,7 +101,7 @@ public abstract class CaseElement {
 
 				return VariableDefCaseElement.parseVariable(varName, parts[1], op, true);
 			} else if (specialBody.matches("\\S+:=\\S+")) {
-				String[] parts = StringUtils.levelSplit(specialBody, "=").toArray(new String[0]);
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
 
 				if(parts.length != 2) {
 					throw new GrammarException("Colon variables must have a name and a definition");
@@ -114,7 +113,7 @@ public abstract class CaseElement {
 
 				return VariableDefCaseElement.parseVariable(varName, parts[1], ' ', true);
 			} else if (specialBody.matches("\\S+=\\S+")) {
-				String[] parts = StringUtils.levelSplit(specialBody, "=").toArray(new String[0]);
+				String[] parts = LevelSplitter.def.levelSplit(specialBody, "=").toArray(new String[0]);
 				if(parts.length != 2) {
 					throw new GrammarException("Variables must have a name and a definition");
 				}
@@ -136,16 +135,16 @@ public abstract class CaseElement {
 
 				return new RangeCaseElement(firstNum, secondNum);
 			} else if(rawCase.contains("||")) {
-				String[] elms = StringUtils.levelSplit(rawCase, "||").toArray(new String[0]);
+				String[] elms = LevelSplitter.def.levelSplit(rawCase, "||").toArray(new String[0]);
 
 				return new InlineRuleCaseElement(elms);
 			} else if(rawCase.contains("|")) {
 				throw new GrammarException("Inline rule using | found, they use || now");
 
-				// String[] elms = StringUtils.levelSplit(rawCase, "|").toArray(new String[0]);
+				// String[] elms = LevelSplitter.def.levelSplit(rawCase, "|").toArray(new String[0]);
 				// return new InlineRuleCaseElement(elms);
-			} else if (StringUtils.levelContains(rawCase, ".")) {
-				String[] parts = StringUtils.levelSplit(rawCase, ".").toArray(new String[0]);
+			} else if (LevelSplitter.def.levelContains(rawCase, ".")) {
+				String[] parts = LevelSplitter.def.levelSplit(rawCase, ".").toArray(new String[0]);
 
 				CaseElement base = createElement(parts[0]);
 
diff --git a/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java
index c221f4a..03eebe3 100755
--- a/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/ExpVariableCaseElement.java
@@ -1,13 +1,9 @@
 package bjc.rgens.parser.elements;
 
-import bjc.utils.data.IPair;
-
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
-import bjc.rgens.parser.RecurLimitException;
 import bjc.rgens.parser.RGrammar;
 import bjc.rgens.parser.Rule;
-import bjc.rgens.parser.RuleCase;
 
 public class ExpVariableCaseElement extends VariableDefCaseElement {
 	public ExpVariableCaseElement(String name, String def) {
diff --git a/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java b/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
index 917dd33..82bc6ee 100644
--- a/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/InlineRuleCaseElement.java
@@ -2,12 +2,10 @@ package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.RGrammarParser;
-
 import bjc.utils.data.IPair;
-import bjc.utils.funcdata.FunctionalList;
 import bjc.utils.funcdata.IList;
-import bjc.utils.funcutils.StringUtils;
 import bjc.utils.gen.WeightedRandom;
+import bjc.utils.ioutils.LevelSplitter;
 
 public class InlineRuleCaseElement extends CaseElement {
 	public final WeightedRandom<CaseElement> elements;
@@ -20,8 +18,8 @@ public class InlineRuleCaseElement extends CaseElement {
 		for(String part : parts) {
 			String[] partArr;
 
-			if(StringUtils.levelContains(part, "|")) {
-				partArr = StringUtils.levelSplit(part, "||").toArray(new String[0]);
+			if(LevelSplitter.def.levelContains(part, "|")) {
+				partArr = LevelSplitter.def.levelSplit(part, "||").toArray(new String[0]);
 			} else {
 				partArr = new String[] {part};
 			}
diff --git a/src/main/java/bjc/rgens/parser/elements/MethodCaseElement.java b/src/main/java/bjc/rgens/parser/elements/MethodCaseElement.java
index 13f58e9..342d407 100644
--- a/src/main/java/bjc/rgens/parser/elements/MethodCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/MethodCaseElement.java
@@ -1,7 +1,6 @@
 package bjc.rgens.parser.elements;
 
 import bjc.rgens.parser.GenerationState;
-import bjc.rgens.parser.GrammarException;
 import bjc.rgens.parser.elements.CaseElement;
 import bjc.rgens.parser.elements.methods.MethodElement;
 
diff --git a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
index e42647c..1a2cf85 100755
--- a/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/RuleCaseElement.java
@@ -1,15 +1,12 @@
 package bjc.rgens.parser.elements;
 
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
-
-import bjc.rgens.parser.*;
-import bjc.rgens.parser.elements.vars.*;
-
-import java.util.ArrayList;
 import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
+
+import bjc.rgens.parser.GenerationState;
+import bjc.rgens.parser.GrammarException;
+import bjc.rgens.parser.RGrammar;
+import bjc.rgens.parser.Rule;
+import bjc.rgens.parser.elements.vars.VariableElement;
 
 public class RuleCaseElement extends CaseElement {
 	public List<VariableElement> elements;
@@ -46,11 +43,13 @@ public class RuleCaseElement extends CaseElement {
 		}
 	}
 
-	protected void doGenerate(String actName, GenerationState state) {
+	protected void doGenerate(String acName, GenerationState state) {
 		GenerationState newState = state.newBuf();
 
 		Rule rl;
 
+		String actName = acName;
+		
 		if (actName.startsWith("[^")) {
 			actName = "[" + actName.substring(2);
 
diff --git a/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java b/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
index a7fdbec..d344162 100644
--- a/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/RuleVariableCaseElement.java
@@ -1,13 +1,8 @@
 package bjc.rgens.parser.elements;
 
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
-
 import bjc.rgens.parser.GrammarException;
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.Rule;
-import bjc.rgens.parser.RGrammar;
-
 import static bjc.rgens.parser.RGrammarLogging.*;
 
 public class RuleVariableCaseElement extends VariableDefCaseElement {
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/ARefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/ARefVariableElement.java
index 17db660..5df0f46 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/ARefVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/ARefVariableElement.java
@@ -1,7 +1,6 @@
 package bjc.rgens.parser.elements.vars;
 
 import bjc.rgens.parser.GenerationState;
-import bjc.rgens.parser.GrammarException;
 import bjc.rgens.parser.Rule;
 
 public class ARefVariableElement extends VariableElement {
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
index a33d78c..c753dfe 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/TRefVariableElement.java
@@ -1,8 +1,6 @@
 package bjc.rgens.parser.elements.vars;
 
 import bjc.rgens.parser.GenerationState;
-import bjc.rgens.parser.GrammarException;
-import bjc.rgens.parser.templates.GrammarTemplate;
 
 /*
  * @TODO
diff --git a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
index 2193b3c..916ac3d 100644
--- a/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
+++ b/src/main/java/bjc/rgens/parser/elements/vars/VariableElement.java
@@ -1,7 +1,6 @@
 package bjc.rgens.parser.elements.vars;
 
-import bjc.utils.funcutils.StringUtils;
-
+import bjc.utils.ioutils.LevelSplitter;
 import bjc.rgens.parser.GenerationState;
 import bjc.rgens.parser.GrammarException;
 
@@ -18,12 +17,12 @@ public abstract class VariableElement {
 	public abstract void generate(GenerationState state);
 
 	public static List<VariableElement> parseElementString(String varElm) {
-		boolean forbidSpaces = StringUtils.levelContains(varElm, "-", "+");
+		boolean forbidSpaces = LevelSplitter.def.levelContains(varElm, "-", "+");
 
 		String[] parts;
 
 		if(forbidSpaces) {
-			parts = StringUtils.levelSplit(varElm, true, "-", "+").toArray(new String[0]);
+			parts = LevelSplitter.def.levelSplit(varElm, true, "-", "+").toArray(new String[0]);
 		} else {
 			parts = new String[] { varElm };
 		}
diff --git a/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java b/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
index 8a99188..a7c6cdc 100644
--- a/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
+++ b/src/main/java/bjc/rgens/parser/templates/GrammarTemplate.java
@@ -54,7 +54,8 @@ public class GrammarTemplate {
 			}
 		}
 
-
+		scn.close();
+		
 		return template;
 	}
 
@@ -70,6 +71,6 @@ public class GrammarTemplate {
 	}
 
 	private static void handlePragma(List<TemplateElement> elements, GrammarTemplate template, String ln) {
-
+		// TODO
 	}
 }