Formatting

17 files changed, 435 insertions, 380 deletions

diff --git a/RGens/src/main/java/bjc/rgens/ZadronsPouch.java b/RGens/src/main/java/bjc/rgens/ZadronsPouch.java
index 7160bdd..5634385 100644
--- a/RGens/src/main/java/bjc/rgens/ZadronsPouch.java
+++ b/RGens/src/main/java/bjc/rgens/ZadronsPouch.java
@@ -7,14 +7,14 @@ import bjc.utils.gen.RandomGrammar;
 
 /**
  * Example showing code manipulate of random grammars
- * 
+ *
  * @author ben
  *
  */
 public class ZadronsPouch {
 	/**
 	 * Main method for running application
-	 * 
+	 *
 	 * @param args
 	 *            Unused CLI args
 	 */
@@ -41,9 +41,9 @@ public class ZadronsPouch {
 		grammar = new RandomGrammar<>();
 
 		addRule("[item]",
-				"[egg]", "[glove]", "[crys-sphere]", "[rock]",
-				"[figurine]", "[vial]", "[mini-weapon]", "[bag]",
-				"[card]", "[rope]", "[box]", "[wand]");
+		        "[egg]", "[glove]", "[crys-sphere]", "[rock]",
+		        "[figurine]", "[vial]", "[mini-weapon]", "[bag]",
+		        "[card]", "[rope]", "[box]", "[wand]");
 
 		addEggRules();
 		addGloveRules();
@@ -63,118 +63,118 @@ public class ZadronsPouch {
 
 	private void addBagRules() {
 		addRule("[bag]",
-				"bag of [bag-type]", "[sack-type] sack", "[purse-type] purse");
+		        "bag of [bag-type]", "[sack-type] sack", "[purse-type] purse");
 		addRule("[bag-type]",
-				"holding", "tricks", "useful items",
-				"devouring", "dwarf-kind", "invisible cloth",
-				"monster summoning");
+		        "holding", "tricks", "useful items",
+		        "devouring", "dwarf-kind", "invisible cloth",
+		        "monster summoning");
 		addRule("[sack-type]",
-				"lunch", "recursive");
+		        "lunch", "recursive");
 		addRule("[purse-type]",
-				"everfull");
+		        "everfull");
 	}
 
 	private void addBoxRules() {
 		addRule("[box]",
-				"[box-type] box", "cube of [box-type]");
+		        "[box-type] box", "cube of [box-type]");
 		addRule("[box-type]",
-				"limited-force", "frost-resisting", "morphing",
-				"self-destructing", "pandora", "panicking");
+		        "limited-force", "frost-resisting", "morphing",
+		        "self-destructing", "pandora", "panicking");
 	}
 
 	private void addCardRules() {
 		addRule("[card]",
-				"card of [card-type]", "[card-type] card");
+		        "card of [card-type]", "[card-type] card");
 		addRule("[card-type]",
-				"fate", "teleporting", "elusive treasure", "spell-storing",
-				"many-things", "imprisoning", "messaging", "bounty");
+		        "fate", "teleporting", "elusive treasure", "spell-storing",
+		        "many-things", "imprisoning", "messaging", "bounty");
 	}
 
 	private void addCrysSphereRules() {
 		addRule("[crys-sphere]",
-				"[sphere-type] spheres", "[sphere-type] sphere",
-				"lens of [lens-type]", "[crystal-type] crystal",
-				"crystal of [crystal-type]", "crystal ball",
-				"crystal ball of [crys-suffix]");
+		        "[sphere-type] spheres", "[sphere-type] sphere",
+		        "lens of [lens-type]", "[crystal-type] crystal",
+		        "crystal of [crystal-type]", "crystal ball",
+		        "crystal ball of [crys-suffix]");
 		addRule("[sphere-type]",
-				"microphonic", "seeing-eye");
+		        "microphonic", "seeing-eye");
 		addRule("[lens-type]",
-				"detection");
+		        "detection");
 		addRule("[crystal-type]",
-				"prison", "radar");
+		        "prison", "radar");
 		addRule("[crys-suffix]",
-				"jumping");
+		        "jumping");
 	}
 
 	private void addEggRules() {
 		addRule("[egg]",
-				"[egg-type] egg");
+		        "[egg-type] egg");
 		addRule("[egg-type]",
-				"copper", "stone", "golden",
-				"white", "white/pink", "glass");
+		        "copper", "stone", "golden",
+		        "white", "white/pink", "glass");
 	}
 
 	private void addFigurineRules() {
 		addRule("[figurine]",
-				"[fig-material] [fig-animal]");
+		        "[fig-material] [fig-animal]");
 		addRule("[fig-material]",
-				"golden", "onyx", "serpentine", "ivory",
-				"marble", "bronze", "jade", "limestone");
+		        "golden", "onyx", "serpentine", "ivory",
+		        "marble", "bronze", "jade", "limestone");
 		addRule("[fig-animal]",
-				"lion", "dog", "owl", "goat",
-				"elephant", "warrior", "palace", "leprechaun");
+		        "lion", "dog", "owl", "goat",
+		        "elephant", "warrior", "palace", "leprechaun");
 	}
 
 	private void addGloveRules() {
-		addRule("[glove]", 
-				"gauntlets of [gauntlet-type]",
-				"gloves of [glove-type]",
-				"[glove-type] gloves");
+		addRule("[glove]",
+		        "gauntlets of [gauntlet-type]",
+		        "gloves of [glove-type]",
+		        "[glove-type] gloves");
 		addRule("[gauntlet-type]",
-				"dexterity", "power");
+		        "dexterity", "power");
 		addRule("[glove-type]",
-				"pushing", "choking", "bigby", "stunning");
+		        "pushing", "choking", "bigby", "stunning");
 	}
 
 	private void addMiniWeaponRules() {
 		addRule("[mini-weapon]",
-				"minature [weapon-type]", "small [weapon-type]",
-				"tiny [weapon-type]", "[sling-type] sling",
-				"[weapon-type]");
+		        "minature [weapon-type]", "small [weapon-type]",
+		        "tiny [weapon-type]", "[sling-type] sling",
+		        "[weapon-type]");
 		addRule("[weapon-type]",
-				"boomerang", "arrow", "net",
-				"catapult", "hammer", "sword", "club");
+		        "boomerang", "arrow", "net",
+		        "catapult", "hammer", "sword", "club");
 		addRule("[sling-type]",
-				"seeking");
+		        "seeking");
 	}
 
 	private void addRockRules() {
 		addRule("[rock]",
-				"[pebble-type] pebble", "stone of [stone-type]",
-				"[stone-type] stone", "brick of [brick-type]",
-				"[geode-type] geode");
+		        "[pebble-type] pebble", "stone of [stone-type]",
+		        "[stone-type] stone", "brick of [brick-type]",
+		        "[geode-type] geode");
 		addRule("[pebble-type]",
-				"inscribed", "elemental control");
+		        "inscribed", "elemental control");
 		addRule("[stone-type]",
-				"good-luck", "weight",
-				"blind-defense", "metal-clinging");
+		        "good-luck", "weight",
+		        "blind-defense", "metal-clinging");
 		addRule("[brick-type]",
-				"flying");
+		        "flying");
 		addRule("[geode-type]",
-				"ioun");
+		        "ioun");
 	}
 
 	private void addRopeRules() {
 		addRule("[rope]",
-				"[rope-type] rope", "rope of [rope-type]",
-				"ball of [string-type] [string-kind]");
+		        "[rope-type] rope", "rope of [rope-type]",
+		        "ball of [string-type] [string-kind]");
 		addRule("[rope-type]",
-				"trick", "entangling", "climbing", "dancing",
-				"tripping", "snaring", "levitating", "self-entangling");
-		addRule("[string-type]", 
-				"endless");
+		        "trick", "entangling", "climbing", "dancing",
+		        "tripping", "snaring", "levitating", "self-entangling");
+		addRule("[string-type]",
+		        "endless");
 		addRule("[string-kind]",
-				"string", "yarn");
+		        "string", "yarn");
 	}
 
 	private void addRule(String rule, String... cases) {
@@ -189,31 +189,31 @@ public class ZadronsPouch {
 
 	private void addVialRules() {
 		addRule("[vial]",
-				"vial of [vial-type]", "[vial-type] vial",
-				"[bottle-type] bottle", "[flask-type] flask");
+		        "vial of [vial-type]", "[vial-type] vial",
+		        "[bottle-type] bottle", "[flask-type] flask");
 		addRule("[vial-type]",
-				"holding", "trapping",
-				"experience", "unnatural regeneration");
+		        "holding", "trapping",
+		        "experience", "unnatural regeneration");
 		addRule("[bottle-type]",
-				"ever-smoking", "wheezing",
-				"blank potion");
+		        "ever-smoking", "wheezing",
+		        "blank potion");
 		addRule("[flask-type]",
-				"iron");
+		        "iron");
 	}
 
 	private void addWandRules() {
 		addRule("[wand]",
-				"[wand-type] wand", "wand of [wand-type]",
-				"canceling [wand-type] wand");
+		        "[wand-type] wand", "wand of [wand-type]",
+		        "canceling [wand-type] wand");
 		addRule("[wand-type]",
-				"magic missile", "[spell-1]", "[spell-2]",
-				"gusting", "life-detecting", "zadron");
+		        "magic missile", "[spell-1]", "[spell-2]",
+		        "gusting", "life-detecting", "zadron");
 		addRule("[spell-1]",
-				"frost", "fire", "lightning", "fear",
-				"illumination", "polymorphing", "conjuration", "paralyzing");
+		        "frost", "fire", "lightning", "fear",
+		        "illumination", "polymorphing", "conjuration", "paralyzing");
 		addRule("[spell-2]",
-				"[spell2-type] detecting");
+		        "[spell2-type] detecting");
 		addRule("[spell2-type]",
-				"magic", "enemy", "secret door/trap");
+		        "magic", "enemy", "secret door/trap");
 	}
 }
diff --git a/RGens/src/main/java/bjc/rgens/newparser/CaseElement.java b/RGens/src/main/java/bjc/rgens/newparser/CaseElement.java
index 5f798aa..8a5454b 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/CaseElement.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/CaseElement.java
@@ -4,13 +4,13 @@ import static bjc.rgens.newparser.CaseElement.ElementType.*;
 
 /**
  * A element in a rule case.
- * 
+ *
  * @author EVE
  */
 public class CaseElement {
 	/**
 	 * The possible types of an element.
-	 * 
+	 *
 	 * @author EVE
 	 *
 	 */
@@ -38,9 +38,9 @@ public class CaseElement {
 		EXPVARDEF;
 	}
 
-	private static final String	SPECIAL_CASELEM	= "\\{[^}]+\\}";
-	private static final String	REFER_CASELEM	= "\\[[^\\]]+\\]";
-	private static final String	RANGE_CASELM	= "\\[\\d+\\.\\.\\d+\\]";
+	private static final String     SPECIAL_CASELEM = "\\{[^}]+\\}";
+	private static final String     REFER_CASELEM   = "\\[[^\\]]+\\]";
+	private static final String     RANGE_CASELM    = "\\[\\d+\\.\\.\\d+\\]";
 
 	/**
 	 * The type of this element.
@@ -49,10 +49,10 @@ public class CaseElement {
 
 	/**
 	 * The literal string value of this element.
-	 * 
+	 *
 	 * This means that it is a string whose value should always mean the
 	 * same thing.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>LITERAL</dt>
@@ -65,7 +65,7 @@ public class CaseElement {
 
 	/**
 	 * The starting integer value of this element.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>RANGE</dt>
@@ -76,7 +76,7 @@ public class CaseElement {
 
 	/**
 	 * The starting integer value of this element.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>RANGE</dt>
@@ -87,7 +87,7 @@ public class CaseElement {
 
 	/**
 	 * The name of the variable this element defines.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>VARDEF</dt>
@@ -100,7 +100,7 @@ public class CaseElement {
 
 	/**
 	 * The definition of the variable this element defines.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>VARDEF</dt>
@@ -113,23 +113,26 @@ public class CaseElement {
 
 	/**
 	 * Create a new case element.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of this element.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the specified type needs parameters.
 	 */
 	public CaseElement(ElementType typ) {
-		switch(typ) {
+		switch (typ) {
 		case LITERAL:
 		case RULEREF:
 			throw new IllegalArgumentException("This type requires a string parameter");
+
 		case RANGE:
 			throw new IllegalArgumentException("This type requires two integer parameters");
+
 		case VARDEF:
 		case EXPVARDEF:
 			throw new IllegalArgumentException("This type requires two string parameters");
+
 		default:
 			break;
 		}
@@ -139,27 +142,30 @@ public class CaseElement {
 
 	/**
 	 * Create a new case element that has a single string value.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of this element.
-	 * 
+	 *
 	 * @param val
 	 *                The string value of this element.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the specified type doesn't take a single string
 	 *                 parameter.
 	 */
 	public CaseElement(ElementType typ, String val) {
-		switch(typ) {
+		switch (typ) {
 		case LITERAL:
 		case RULEREF:
 			break;
+
 		case RANGE:
 			throw new IllegalArgumentException("This type requires two integer parameters");
+
 		case VARDEF:
 		case EXPVARDEF:
 			throw new IllegalArgumentException("This type requires two string parameters");
+
 		default:
 			throw new IllegalArgumentException("This type doesn't have a string parameter");
 		}
@@ -171,28 +177,31 @@ public class CaseElement {
 
 	/**
 	 * Create a new case element that has two integer values.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of this element.
 	 * @param first
 	 *                The first integer value for this element.
 	 * @param second
 	 *                The second integer value for this element.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the specified type doesn't take two integer
 	 *                 parameters.
 	 */
 	public CaseElement(ElementType typ, int first, int second) {
-		switch(typ) {
+		switch (typ) {
 		case LITERAL:
 		case RULEREF:
 			throw new IllegalArgumentException("This type requires a string parameter");
+
 		case RANGE:
 			break;
+
 		case VARDEF:
 		case EXPVARDEF:
 			throw new IllegalArgumentException("This type requires two string parameters");
+
 		default:
 			throw new IllegalArgumentException("This type doesn't have two integer parameters");
 		}
@@ -205,28 +214,31 @@ public class CaseElement {
 
 	/**
 	 * Create a new case element that has two string values.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of this element.
 	 * @param name
 	 *                The first string value for this element.
 	 * @param def
 	 *                The second string value for this element.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the specified type doesn't take two string
 	 *                 parameters.
 	 */
 	public CaseElement(ElementType typ, String name, String def) {
-		switch(typ) {
+		switch (typ) {
 		case LITERAL:
 		case RULEREF:
 			throw new IllegalArgumentException("This type requires a string parameter");
+
 		case RANGE:
 			throw new IllegalArgumentException("This type requires two integer parameters");
+
 		case VARDEF:
 		case EXPVARDEF:
 			break;
+
 		default:
 			throw new IllegalArgumentException("This type doesn't have two string parameters");
 		}
@@ -239,19 +251,21 @@ public class CaseElement {
 
 	/**
 	 * Get the literal string value for this element.
-	 * 
+	 *
 	 * @return The literal string value for this element.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 If this type doesn't have a literal string value.
 	 */
 	public String getLiteral() {
-		switch(type) {
+		switch (type) {
 		case LITERAL:
 		case RULEREF:
 			break;
+
 		default:
-			throw new IllegalStateException(String.format("Type '%s' doesn't have a literal string value"));
+			throw new IllegalStateException(
+			        String.format("Type '%s' doesn't have a literal string value"));
 		}
 
 		return literalVal;
@@ -259,39 +273,42 @@ public class CaseElement {
 
 	/**
 	 * Get the starting integer value for this element.
-	 * 
+	 *
 	 * @return The starting integer value for this element.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 If this type doesn't have a starting integer value.
 	 */
 	public int getStart() {
-		switch(type) {
+		switch (type) {
 		case RANGE:
 			break;
+
 		default:
 			throw new IllegalStateException(
-					String.format("Type '%s' doesn't have a starting integer value", type));
+			        String.format("Type '%s' doesn't have a starting integer value", type));
 
 		}
+
 		return start;
 	}
 
 	/**
 	 * Get the ending integer value for this element.
-	 * 
+	 *
 	 * @return The ending integer value for this element.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 If this type doesn't have a ending integer value.
 	 */
 	public int getEnd() {
-		switch(type) {
+		switch (type) {
 		case RANGE:
 			break;
+
 		default:
 			throw new IllegalStateException(
-					String.format("Type '%s' doesn't have a ending integer value", type));
+			        String.format("Type '%s' doesn't have a ending integer value", type));
 		}
 
 		return end;
@@ -299,17 +316,18 @@ public class CaseElement {
 
 	/**
 	 * Get the variable name for this element.
-	 * 
+	 *
 	 * @return The variable name of this element.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 If the type doesn't have a variable name.
 	 */
 	public String getName() {
-		switch(type) {
+		switch (type) {
 		case VARDEF:
 		case EXPVARDEF:
 			break;
+
 		default:
 			throw new IllegalStateException(String.format("Type '%s' doesn't have a name", type));
 		}
@@ -319,17 +337,18 @@ public class CaseElement {
 
 	/**
 	 * Get the variable definition for this element.
-	 * 
+	 *
 	 * @return The variable definition of this element.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 If the type doesn't have a variable definition.
 	 */
 	public String getDefn() {
-		switch(type) {
+		switch (type) {
 		case VARDEF:
 		case EXPVARDEF:
 			break;
+
 		default:
 			throw new IllegalStateException(String.format("Type '%s' doesn't have a name", type));
 		}
@@ -339,16 +358,20 @@ public class CaseElement {
 
 	@Override
 	public String toString() {
-		switch(type) {
+		switch (type) {
 		case LITERAL:
 		case RULEREF:
 			return literalVal;
+
 		case RANGE:
 			return String.format("[%d..%d]", start, end);
+
 		case VARDEF:
 			return String.format("{%s:=%s}", varName, varDef);
+
 		case EXPVARDEF:
 			return String.format("{%s=%s}", varName, varDef);
+
 		default:
 			return String.format("Unknown type '%s'", type);
 		}
@@ -356,36 +379,36 @@ public class CaseElement {
 
 	/**
 	 * Create a case element from a string.
-	 * 
+	 *
 	 * @param csepart
 	 *                The string to convert.
-	 * 
+	 *
 	 * @return A case element representing the string.
 	 */
 	public static CaseElement createElement(String csepart) {
-		if(csepart == null) {
+		if (csepart == null) {
 			throw new NullPointerException("Case part cannot be null");
 		}
 
-		if(csepart.matches(SPECIAL_CASELEM)) {
+		if (csepart.matches(SPECIAL_CASELEM)) {
 			/*
 			 * Handle special cases.
 			 */
 			String specialBody = csepart.substring(1, csepart.length() - 1);
 
-			if(specialBody.matches("\\S+:=\\S+")) {
+			if (specialBody.matches("\\S+:=\\S+")) {
 				/*
 				 * Handle expanding variable definitions.
 				 */
 				String[] parts = specialBody.split(":=");
 
-				if(parts.length != 2) {
+				if (parts.length != 2) {
 					throw new GrammarException("Expanded variables must be a name and a definition,"
-							+ " seperated by :=");
+					                           + " seperated by :=");
 				}
 
 				return new CaseElement(EXPVARDEF, parts[0], parts[1]);
-			} else if(specialBody.matches("\\S+=\\S+")) {
+			} else if (specialBody.matches("\\S+=\\S+")) {
 				/*
 				 * Handle regular variable definitions.
 				 */
@@ -394,23 +417,23 @@ public class CaseElement {
 				 */
 				String[] parts = specialBody.split("=");
 
-				if(parts.length != 2) {
+				if (parts.length != 2) {
 					throw new GrammarException("Variables must be a name and a definition,"
-							+ " seperated by =");
+					                           + " seperated by =");
 				}
 
 				return new CaseElement(VARDEF, parts[0], parts[1]);
-			} else if(specialBody.matches("{empty}")) {
+			} else if (specialBody.matches("{empty}")) {
 				/*
 				 * Literal blank, for empty cases.
 				 */
 				return new CaseElement(LITERAL, "");
 			} else {
 				throw new IllegalArgumentException(
-						String.format("Unknown special case part '%s'", specialBody));
+				        String.format("Unknown special case part '%s'", specialBody));
 			}
-		} else if(csepart.matches(REFER_CASELEM)) {
-			if(csepart.matches(RANGE_CASELM)) {
+		} else if (csepart.matches(REFER_CASELEM)) {
+			if (csepart.matches(RANGE_CASELM)) {
 				/*
 				 * Handle ranges
 				 */
@@ -421,7 +444,7 @@ public class CaseElement {
 
 				return new CaseElement(RANGE, firstNum, secondNum);
 			}
-			
+
 			return new CaseElement(RULEREF, csepart);
 		} else {
 			return new CaseElement(LITERAL, csepart);
diff --git a/RGens/src/main/java/bjc/rgens/newparser/GrammarException.java b/RGens/src/main/java/bjc/rgens/newparser/GrammarException.java
index c9f2723..ac37f7a 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/GrammarException.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/GrammarException.java
@@ -3,7 +3,7 @@ package bjc.rgens.newparser;
 /**
  * The exception thrown when something goes wrong while parsing a
  * grammar.
- * 
+ *
  * @author student
  *
  */
@@ -15,7 +15,7 @@ public class GrammarException extends RuntimeException {
 
 	/**
 	 * Create a new grammar exception with the specified message.
-	 * 
+	 *
 	 * @param msg
 	 *                The message for this exception.
 	 */
@@ -26,10 +26,10 @@ public class GrammarException extends RuntimeException {
 	/**
 	 * Create a new grammar exception with the specified message and
 	 * cause.
-	 * 
+	 *
 	 * @param msg
 	 *                The message for this exception.
-	 * 
+	 *
 	 * @param cause
 	 *                The cause of this exception.
 	 */
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
index 5f1c3aa..2c389a5 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammar.java
@@ -19,7 +19,7 @@ import edu.gatech.gtri.bktree.MutableBkTree;
 
 /**
  * Represents a randomized grammar.
- * 
+ *
  * @author EVE
  *
  */
@@ -43,8 +43,8 @@ public class RGrammar {
 	}
 
 	private static class GenerationState {
-		public StringBuilder	contents;
-		public Random		rnd;
+		public StringBuilder    contents;
+		public Random           rnd;
 
 		public Map<String, String> vars;
 
@@ -57,16 +57,16 @@ public class RGrammar {
 
 	private static Pattern NAMEVAR_PATTERN = Pattern.compile("\\$(\\w+)");
 
-	private Map<String, Rule>	rules;
-	private Map<String, RGrammar>	importRules;
-	private Set<String>		exportRules;
-	private String			initialRule;
+	private Map<String, Rule>       rules;
+	private Map<String, RGrammar>   importRules;
+	private Set<String>             exportRules;
+	private String                  initialRule;
 
 	private BkTreeSearcher<String> ruleSearcher;
 
 	/**
 	 * Create a new randomized grammar using the specified set of rules.
-	 * 
+	 *
 	 * @param ruls
 	 *                The rules to use.
 	 */
@@ -76,10 +76,10 @@ public class RGrammar {
 
 	/**
 	 * Sets the imported rules to use.
-	 * 
+	 *
 	 * Imported rules are checked for rule definitions after local
 	 * definitions are checked.
-	 * 
+	 *
 	 * @param exportedRules
 	 *                The set of imported rules to use.
 	 */
@@ -104,11 +104,11 @@ public class RGrammar {
 	/**
 	 * Generate a string from this grammar, starting from the specified
 	 * rule.
-	 * 
+	 *
 	 * @param startRule
 	 *                The rule to start generating at, or null to use the
 	 *                initial rule for this grammar.
-	 * 
+	 *
 	 * @return A possible string from the grammar.
 	 */
 	public String generate(String startRule) {
@@ -118,17 +118,17 @@ public class RGrammar {
 	/**
 	 * Generate a string from this grammar, starting from the specified
 	 * rule.
-	 * 
+	 *
 	 * @param startRule
 	 *                The rule to start generating at, or null to use the
 	 *                initial rule for this grammar.
-	 * 
+	 *
 	 * @param rnd
 	 *                The random number generator to use.
-	 * 
+	 *
 	 * @param vars
 	 *                The set of variables to use.
-	 * 
+	 *
 	 * @return A possible string from the grammar.
 	 */
 	public String generate(String startRule, Random rnd, Map<String, String> vars) {
@@ -137,7 +137,7 @@ public class RGrammar {
 		if (startRule == null) {
 			if (initialRule == null) {
 				throw new GrammarException(
-						"Must specify a start rule for grammars with no initial rule");
+				        "Must specify a start rule for grammars with no initial rule");
 			}
 
 			fromRule = initialRule;
@@ -166,7 +166,9 @@ public class RGrammar {
 				for (CaseElement elm : start.getElements()) {
 					generateElement(elm, state);
 				}
+
 				break;
+
 			default:
 				throw new GrammarException(String.format("Unknown case type '%s'", start.type));
 			}
@@ -185,9 +187,11 @@ public class RGrammar {
 				state.contents.append(elm.getLiteral());
 				state.contents.append(" ");
 				break;
+
 			case RULEREF:
 				generateRuleReference(elm, state);
 				break;
+
 			case RANGE:
 				int start = elm.getStart();
 				int end = elm.getEnd();
@@ -198,17 +202,21 @@ public class RGrammar {
 				state.contents.append(val);
 				state.contents.append(" ");
 				break;
+
 			case VARDEF:
 				generateVarDef(elm.getName(), elm.getDefn(), state);
 				break;
+
 			case EXPVARDEF:
 				generateExpVarDef(elm.getName(), elm.getDefn(), state);
 				break;
+
 			default:
 				throw new GrammarException(String.format("Unknown element type '%s'", elm.type));
 			}
 		} catch (GrammarException gex) {
-			throw new GrammarException(String.format("Error in generating case element (%s)", elm), gex);
+			throw new GrammarException(String.format("Error in generating case element (%s)", elm),
+			                           gex);
 		}
 	}
 
@@ -216,7 +224,8 @@ public class RGrammar {
 	 * Generate a expanding variable definition.
 	 */
 	private void generateExpVarDef(String name, String defn, GenerationState state) {
-		GenerationState newState = new GenerationState(new StringBuilder(), state.rnd, state.vars);
+		GenerationState newState = new GenerationState(new StringBuilder(), state.rnd,
+		                state.vars);
 
 		if (rules.containsKey(defn)) {
 			RuleCase destCase = rules.get(defn).getCase();
@@ -247,7 +256,8 @@ public class RGrammar {
 	private void generateRuleReference(CaseElement elm, GenerationState state) {
 		String refersTo = elm.getLiteral();
 
-		GenerationState newState = new GenerationState(new StringBuilder(), state.rnd, state.vars);
+		GenerationState newState = new GenerationState(new StringBuilder(), state.rnd,
+		                state.vars);
 
 		if (refersTo.contains("$")) {
 			/*
@@ -268,17 +278,17 @@ public class RGrammar {
 
 					if (!state.vars.containsKey(var)) {
 						throw new GrammarException(
-								String.format("No variable '%s' defined", var));
+						        String.format("No variable '%s' defined", var));
 					}
 
 					String name = state.vars.get(var);
 
 					if (name.contains(" ")) {
 						throw new GrammarException(
-								"Variables substituted into names cannot contain spaces");
+						        "Variables substituted into names cannot contain spaces");
 					} else if (name.equals("")) {
 						throw new GrammarException(
-								"Variables substituted into names cannot be empty");
+						        "Variables substituted into names cannot be empty");
 					}
 
 					nameMatcher.appendReplacement(nameBuffer, name);
@@ -320,10 +330,10 @@ public class RGrammar {
 				Set<Match<? extends String>> results = ruleSearcher.search(refersTo, MAX_DISTANCE);
 
 				String[] resArray = results.stream().map((mat) -> mat.getMatch())
-						.toArray((i) -> new String[i]);
+				                    .toArray((i) -> new String[i]);
 
 				throw new GrammarException(String.format("No rule '%s' defined (perhaps you meant %s?)",
-						refersTo, StringUtils.toEnglishList(resArray, false)));
+				                           refersTo, StringUtils.toEnglishList(resArray, false)));
 			}
 
 			throw new GrammarException(String.format("No rule '%s' defined", refersTo));
@@ -341,7 +351,7 @@ public class RGrammar {
 
 	/**
 	 * Get the initial rule of this grammar.
-	 * 
+	 *
 	 * @return The initial rule of this grammar.
 	 */
 	public String getInitialRule() {
@@ -350,7 +360,7 @@ public class RGrammar {
 
 	/**
 	 * Set the initial rule of this grammar.
-	 * 
+	 *
 	 * @param initRule
 	 *                The initial rule of this grammar, or null to say there
 	 *                is no initial rule.
@@ -368,7 +378,7 @@ public class RGrammar {
 			throw new GrammarException("The empty string is not a valid rule name");
 		} else if (!rules.containsKey(initRule)) {
 			throw new GrammarException(
-					String.format("No rule '%s' local to this grammar defined.", initRule));
+			        String.format("No rule '%s' local to this grammar defined.", initRule));
 		}
 
 		initialRule = initRule;
@@ -376,9 +386,9 @@ public class RGrammar {
 
 	/**
 	 * Gets the rules exported by this grammar.
-	 * 
+	 *
 	 * The initial rule is exported by default if specified.
-	 * 
+	 *
 	 * @return The rules exported by this grammar.
 	 */
 	public Set<Rule> getExportedRules() {
@@ -387,7 +397,7 @@ public class RGrammar {
 		for (String rname : exportRules) {
 			if (!rules.containsKey(rname)) {
 				throw new GrammarException(String.format("No rule '%s' local to this grammar defined",
-						initialRule));
+				                           initialRule));
 			}
 
 			res.add(rules.get(rname));
@@ -402,7 +412,7 @@ public class RGrammar {
 
 	/**
 	 * Set the rules exported by this grammar.
-	 * 
+	 *
 	 * @param exportedRules
 	 *                The rules exported by this grammar.
 	 */
@@ -412,7 +422,7 @@ public class RGrammar {
 
 	/**
 	 * Get all the rules in this grammar.
-	 * 
+	 *
 	 * @return All the rules in this grammar.
 	 */
 	public Map<String, Rule> getRules() {
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
index d71578b..b4f9f45 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarBuilder.java
@@ -12,7 +12,7 @@ import static bjc.rgens.newparser.RuleCase.CaseType.*;
 
 /**
  * Construct randomized grammars piece by piece.
- * 
+ *
  * @author EVE
  *
  */
@@ -40,20 +40,20 @@ public class RGrammarBuilder {
 
 	/**
 	 * Starts a rule with the provided name.
-	 * 
+	 *
 	 * If the rule already exists, it will be opened for adding additional
 	 * cases instead.
-	 * 
+	 *
 	 * @param rName
 	 *                The name of the rule currently being built.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule name is the empty string.
 	 */
 	public void startRule(String rName) {
-		if(rName == null) {
+		if (rName == null) {
 			throw new NullPointerException("Rule name must not be null");
-		} else if(rName.equals("")) {
+		} else if (rName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
 		}
 
@@ -62,7 +62,7 @@ public class RGrammarBuilder {
 
 	/**
 	 * Convert this builder into a grammar.
-	 * 
+	 *
 	 * @return The grammar built by this builder
 	 */
 	public RGrammar toRGrammar() {
@@ -77,7 +77,7 @@ public class RGrammarBuilder {
 
 	/**
 	 * Adds a case part to this rule.
-	 * 
+	 *
 	 * <h2>Case part formatting</h2>
 	 * <dl>
 	 * <dt>Rule Reference</dt>
@@ -86,7 +86,7 @@ public class RGrammarBuilder {
 	 * <dt>Literal Strings</dt>
 	 * <dd>Literal strings are the default case part type.</dd>
 	 * </dl>
-	 * 
+	 *
 	 * @param csepart
 	 */
 	public void addCasePart(String csepart) {
@@ -97,14 +97,14 @@ public class RGrammarBuilder {
 
 	/**
 	 * Finalizes editing a rule.
-	 * 
+	 *
 	 * Saves the rule to the rule map.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 Must be invoked while a rule is being edited.
 	 */
 	public void finishRule() {
-		if(currRule == null) {
+		if (currRule == null) {
 			throw new IllegalStateException("Must start a rule before finishing one");
 		}
 
@@ -113,12 +113,12 @@ public class RGrammarBuilder {
 
 	/**
 	 * Finishes the current case being edited.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 Must be invoked while a rule is being edited.
 	 */
 	public void finishCase() {
-		if(currRule == null) {
+		if (currRule == null) {
 			throw new IllegalStateException("Must start a rule before finishing a case");
 		}
 
@@ -129,30 +129,30 @@ public class RGrammarBuilder {
 
 	/**
 	 * Begins a case for the current rule.
-	 * 
+	 *
 	 * @throws IllegalStateException
 	 *                 Must be invoked while a rule is being edited.
 	 */
 	public void beginCase() {
-		if(currRule == null) {
+		if (currRule == null) {
 			throw new IllegalStateException("Must start a rule before adding cases");
 		}
 	}
 
 	/**
 	 * Set the initial rule of the grammar.
-	 * 
+	 *
 	 * @param init
 	 *                The initial rule of the grammar.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule is either not valid or not defined in the
 	 *                 grammar.
 	 */
 	public void setInitialRule(String init) {
-		if(init == null) {
+		if (init == null) {
 			throw new NullPointerException("init must not be null");
-		} else if(init.equals("")) {
+		} else if (init.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
 		}
 
@@ -161,18 +161,18 @@ public class RGrammarBuilder {
 
 	/**
 	 * Add an exported rule to this grammar.
-	 * 
+	 *
 	 * @param export
 	 *                The name of the rule to export.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule is either not valid or not defined in the
 	 *                 grammar.
 	 */
 	public void addExport(String export) {
-		if(export == null) {
+		if (export == null) {
 			throw new NullPointerException("Export name must not be null");
-		} else if(export.equals("")) {
+		} else if (export.equals("")) {
 			throw new NullPointerException("The empty string is not a valid rule name");
 		}
 
@@ -181,54 +181,54 @@ public class RGrammarBuilder {
 
 	/**
 	 * Suffix a given case element to every case of a specific rule.
-	 * 
+	 *
 	 * @param ruleName
 	 *                The rule to suffix.
-	 * 
+	 *
 	 * @param suffix
 	 *                The suffix to add.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule name is either invalid or not defined by
 	 *                 this grammar, or if the suffix is invalid.
 	 */
 	public void suffixWith(String ruleName, String suffix) {
-		if(ruleName == null) {
+		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
-		} else if(ruleName.equals("")) {
+		} else if (ruleName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
 		}
 
 		CaseElement element = CaseElement.createElement(suffix);
 
-		for(RuleCase ruleCase : rules.get(ruleName).getCases()) {
+		for (RuleCase ruleCase : rules.get(ruleName).getCases()) {
 			ruleCase.getElements().add(element);
 		}
 	}
 
 	/**
 	 * Prefix a given case element to every case of a specific rule.
-	 * 
+	 *
 	 * @param ruleName
 	 *                The rule to prefix.
-	 * 
+	 *
 	 * @param prefix
 	 *                The prefix to add.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule name is either invalid or not defined by
 	 *                 this grammar, or if the prefix is invalid.
 	 */
 	public void prefixWith(String ruleName, String prefix) {
-		if(ruleName == null) {
+		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
-		} else if(ruleName.equals("")) {
+		} else if (ruleName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
 		}
 
 		CaseElement element = CaseElement.createElement(prefix);
 
-		for(RuleCase ruleCase : rules.get(ruleName).getCases()) {
+		for (RuleCase ruleCase : rules.get(ruleName).getCases()) {
 			ruleCase.getElements().add(element);
 		}
 	}
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarFormatter.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarFormatter.java
index 202d9ef..168fb7b 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarFormatter.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarFormatter.java
@@ -8,17 +8,17 @@ import java.util.Set;
 
 /**
  * Format randomized grammars to strings properly.
- * 
+ *
  * @author EVE
  *
  */
 public class RGrammarFormatter {
 	/**
 	 * Format a grammar into a file that represents that grammar.
-	 * 
+	 *
 	 * @param gram
 	 *                The grammar to format.
-	 * 
+	 *
 	 * @return The formatted grammar.
 	 */
 	public static String formatGrammar(RGrammar gram) {
@@ -30,16 +30,16 @@ public class RGrammarFormatter {
 
 		Set<String> processedRules = new HashSet<>();
 
-		if(initRuleName != null) {
+		if (initRuleName != null) {
 			processRule(rules.get(initRuleName), sb);
 
 			processedRules.add(initRuleName);
 		}
 
-		for(Rule rule : rules.values()) {
-			if(!processedRules.contains(rule.name)) {
+		for (Rule rule : rules.values()) {
+			if (!processedRules.contains(rule.name)) {
 				sb.append("\n\n");
-				
+
 				processRule(rule, sb);
 			}
 
@@ -65,10 +65,10 @@ public class RGrammarFormatter {
 
 		ruleBuilder = new StringBuilder();
 
-		for(RuleCase cse : cases.tail()) {
+		for (RuleCase cse : cases.tail()) {
 			sb.append("\n\t");
 
-			for(int i = 8; i < markerPos; i++) {
+			for (int i = 8; i < markerPos; i++) {
 				ruleBuilder.append(" ");
 			}
 
@@ -85,7 +85,7 @@ public class RGrammarFormatter {
 		/*
 		 * Process each element, adding a space.
 		 */
-		for(CaseElement element : cse.getElements()) {
+		for (CaseElement element : cse.getElements()) {
 			sb.append(element.toString());
 			sb.append(" ");
 		}
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
index 51aeb78..9717eee 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarParser.java
@@ -12,7 +12,7 @@ import java.util.Map;
 
 /**
  * Reads {@link RGrammar} from a input stream.
- * 
+ *
  * @author student
  *
  */
@@ -59,7 +59,7 @@ public class RGrammarParser {
 
 			if (parts.length != 2) {
 				throw new GrammarException("Suffix-with pragma takes two arguments,"
-						+ " the name of the rule to suffix, then what to suffix it with");
+				+ " the name of the rule to suffix, then what to suffix it with");
 			}
 
 			String name = parts[0];
@@ -77,7 +77,7 @@ public class RGrammarParser {
 
 			if (parts.length != 2) {
 				throw new GrammarException("Prefix-with pragma takes two arguments,"
-						+ " the name of the rule to prefix, then what to prefix it with");
+				+ " the name of the rule to prefix, then what to prefix it with");
 			}
 
 			String name = parts[0];
@@ -93,17 +93,18 @@ public class RGrammarParser {
 
 	/**
 	 * Read a {@link RGrammar} from an input stream.
-	 * 
+	 *
 	 * @param is
 	 *            The input stream to read from.
-	 * 
+	 *
 	 * @return The grammar represented by the stream.
-	 * 
+	 *
 	 * @throws GrammarException
 	 *             Thrown if the grammar has a syntax error.
 	 */
 	public static RGrammar readGrammar(Reader is) throws GrammarException {
-		try (BlockReader reader = new SimpleBlockReader(String.format(TMPL_TOPLEVEL_BLOCK_DELIM, 0), is)) {
+		try (BlockReader reader = new SimpleBlockReader(String.format(TMPL_TOPLEVEL_BLOCK_DELIM,
+			                0), is)) {
 			if (!reader.hasNextBlock()) {
 				throw new GrammarException("At least one top-level block must be present");
 			}
@@ -131,14 +132,17 @@ public class RGrammarParser {
 	/*
 	 * Handles an arbitrary block.
 	 */
-	private static void handleBlock(RGrammarBuilder build, String block, int level) throws GrammarException {
+	private static void handleBlock(RGrammarBuilder build, String block,
+	                                int level) throws GrammarException {
 		/*
 		 * Discard empty blocks
 		 */
 		if (block.equals(""))
 			return;
+
 		if (block.equals("\n"))
 			return;
+
 		if (block.equals("\r\n"))
 			return;
 
@@ -146,7 +150,7 @@ public class RGrammarParser {
 
 		if (typeSep == -1) {
 			throw new GrammarException(
-					"A block must start with a type, followed by a space, then the rest of the block");
+			        "A block must start with a type, followed by a space, then the rest of the block");
 		}
 
 		String blockType = block.substring(0, typeSep);
@@ -170,9 +174,11 @@ public class RGrammarParser {
 	/*
 	 * Handle reading a block of pragmas.
 	 */
-	private static void handlePragmaBlock(String block, RGrammarBuilder build, int level) throws GrammarException {
-		try (BlockReader pragmaReader = new SimpleBlockReader(String.format(TMPL_PRAGMA_BLOCK_DELIM, level),
-				new StringReader(block))) {
+	private static void handlePragmaBlock(String block, RGrammarBuilder build,
+	                                      int level) throws GrammarException {
+		try (BlockReader pragmaReader = new SimpleBlockReader(String.format(
+			                        TMPL_PRAGMA_BLOCK_DELIM, level),
+			                new StringReader(block))) {
 			try {
 				pragmaReader.forEachBlock((pragma) -> {
 					String pragmaContents = pragma.contents;
@@ -181,7 +187,7 @@ public class RGrammarParser {
 
 					if (pragmaSep == -1) {
 						throw new GrammarException("A pragma invocation must consist of the word pragma,"
-								+ " followed by a space, then the body of the pragma");
+						+ " followed by a space, then the body of the pragma");
 					}
 
 					String pragmaLeader = pragmaContents.substring(0, pragmaSep);
@@ -189,7 +195,7 @@ public class RGrammarParser {
 
 					if (!pragmaLeader.equalsIgnoreCase("pragma")) {
 						throw new GrammarException(
-								String.format("Illegal line leader in pragma block: '%s'", pragmaLeader));
+						        String.format("Illegal line leader in pragma block: '%s'", pragmaLeader));
 					}
 
 					handlePragma(pragmaBody, build, level);
@@ -207,7 +213,8 @@ public class RGrammarParser {
 	/*msg
 	 * Handle an individual pragma in a block.
 	 */
-	private static void handlePragma(String pragma, RGrammarBuilder build, int level) throws GrammarException {
+	private static void handlePragma(String pragma, RGrammarBuilder build,
+	                                 int level) throws GrammarException {
 		int bodySep = pragma.indexOf(' ');
 
 		if (bodySep == -1)
@@ -230,9 +237,11 @@ public class RGrammarParser {
 	/*
 	 * Handle a block of a rule declaration and one or more cases.
 	 */
-	private static void handleRuleBlock(String ruleBlock, RGrammarBuilder build, int level) throws GrammarException {
-		try (BlockReader ruleReader = new SimpleBlockReader(String.format(TMPL_RULEDECL_BLOCK_DELIM, level),
-				new StringReader(ruleBlock))) {
+	private static void handleRuleBlock(String ruleBlock, RGrammarBuilder build,
+	                                    int level) throws GrammarException {
+		try (BlockReader ruleReader = new SimpleBlockReader(String.format(
+			                        TMPL_RULEDECL_BLOCK_DELIM, level),
+			                new StringReader(ruleBlock))) {
 			try {
 				if (ruleReader.hasNextBlock()) {
 					/*
@@ -258,7 +267,8 @@ public class RGrammarParser {
 					build.finishRule();
 				}
 			} catch (GrammarException gex) {
-				throw new GrammarException(String.format("Error in rule case (%s)", ruleReader.getBlock()), gex);
+				throw new GrammarException(String.format("Error in rule case (%s)",
+				                           ruleReader.getBlock()), gex);
 			}
 		} catch (Exception ex) {
 			throw new GrammarException("Unknown error handling rule block", ex);
@@ -280,11 +290,11 @@ public class RGrammarParser {
 
 			if (declSep == -1) {
 				throw new GrammarException("A rule must be given at least one case in its declaration, and"
-						+ "seperated from that case by \u2192");
+				                           + "seperated from that case by \u2192");
 			}
 
 			System.out.println(
-					"WARNING: Empty space separating a declaration and its case is deprecated. Use \u2192 instead");
+			        "WARNING: Empty space separating a declaration and its case is deprecated. Use \u2192 instead");
 		}
 
 		String ruleName = declContents.substring(0, declSep).trim();
@@ -323,21 +333,26 @@ public class RGrammarParser {
 	/*
 	 * Handle a where block (a block with local rules).
 	 */
-	private static void handleWhereBlock(String block, RGrammarBuilder build, int level) throws GrammarException {
+	private static void handleWhereBlock(String block, RGrammarBuilder build,
+	                                     int level) throws GrammarException {
 		int nlIndex = block.indexOf("\\n");
-		if(nlIndex == -1) {
+
+		if (nlIndex == -1) {
 			throw new GrammarException("Where block must be a context followed by a body");
 		}
-		
+
 		String trimBlock = block.substring(nlIndex).trim();
-		
+
 		String whereDelim = String.format(TMPL_WHERE_BLOCK_DELIM, level);
-		try (BlockReader whereReader = new SimpleBlockReader(whereDelim, new StringReader(trimBlock))) {
+
+		try (BlockReader whereReader = new SimpleBlockReader(whereDelim,
+			                new StringReader(trimBlock))) {
 			try {
 				Block whereCtx = whereReader.next();
 
 				StringReader ctxReader = new StringReader(whereCtx.contents.trim());
 				String ctxDelim = String.format(TMPL_TOPLEVEL_BLOCK_DELIM, level + 1);
+
 				try (BlockReader bodyReader = new SimpleBlockReader(ctxDelim, ctxReader)) {
 
 				}
@@ -346,12 +361,13 @@ public class RGrammarParser {
 
 				/**
 				 * TODO implement where blocks.
-				 * 
+				 *
 				 * A where block has the context evaluated in a new context, and
 				 * the body executed in that context.
 				 */
 			} catch (GrammarException gex) {
-				throw new GrammarException(String.format("Error in where block (%s)", whereReader.getBlock()), gex);
+				throw new GrammarException(String.format("Error in where block (%s)",
+				                           whereReader.getBlock()), gex);
 			}
 		} catch (Exception ex) {
 			throw new GrammarException("Unknown error in where block", ex);
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java
index 452c5f5..e1b9823 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarSet.java
@@ -12,7 +12,7 @@ import java.util.Set;
 
 /**
  * Represents a set of grammars that can share rules via exports.
- * 
+ *
  * @author EVE
  *
  */
@@ -51,28 +51,28 @@ public class RGrammarSet {
 
 	/**
 	 * Add a grammar to this grammar set.
-	 * 
+	 *
 	 * @param grammarName
 	 *                The name of the grammar to add.
-	 * 
+	 *
 	 * @param gram
 	 *                The grammar to add.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the grammar name is invalid.
 	 */
 	public void addGrammar(String grammarName, RGrammar gram) {
-		if(grammarName == null) {
+		if (grammarName == null) {
 			throw new NullPointerException("Grammar name must not be null");
-		} else if(gram == null) {
+		} else if (gram == null) {
 			throw new NullPointerException("Grammar must not be null");
-		} else if(grammarName.equals("")) {
+		} else if (grammarName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid grammar name");
 		}
 
 		grammars.put(grammarName, gram);
 
-		for(Rule export : gram.getExportedRules()) {
+		for (Rule export : gram.getExportedRules()) {
 			exportedRules.put(export.name, gram);
 			exportFrom.put(export.name, grammarName);
 		}
@@ -82,24 +82,24 @@ public class RGrammarSet {
 
 	/**
 	 * Get a grammar from this grammar set.
-	 * 
+	 *
 	 * @param grammarName
 	 *                The name of the grammar to get.
-	 * 
+	 *
 	 * @return The grammar with that name.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the grammar name is invalid or not present in this
 	 *                 set.
 	 */
 	public RGrammar getGrammar(String grammarName) {
-		if(grammarName == null) {
+		if (grammarName == null) {
 			throw new NullPointerException("Grammar name must not be null");
-		} else if(grammarName.equals("")) {
+		} else if (grammarName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid grammar name");
-		} else if(!grammars.containsKey(grammarName)) {
+		} else if (!grammars.containsKey(grammarName)) {
 			throw new IllegalArgumentException(
-					String.format("No grammar with name '%s' found", grammarName));
+			        String.format("No grammar with name '%s' found", grammarName));
 		}
 
 		return grammars.get(grammarName);
@@ -107,24 +107,24 @@ public class RGrammarSet {
 
 	/**
 	 * Get the grammar a rule was exported from.
-	 * 
+	 *
 	 * @param exportName
 	 *                The name of the exported rule.
-	 * 
+	 *
 	 * @return The grammar the exported rule came from.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the export name is invalid or not present in this
 	 *                 set.
 	 */
 	public RGrammar getExportSource(String exportName) {
-		if(exportName == null) {
+		if (exportName == null) {
 			throw new NullPointerException("Export name must not be null");
-		} else if(exportName.equals("")) {
+		} else if (exportName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
-		} else if(!exportedRules.containsKey(exportName)) {
+		} else if (!exportedRules.containsKey(exportName)) {
 			throw new IllegalArgumentException(
-					String.format("No export with name '%s' defined", exportName));
+			        String.format("No export with name '%s' defined", exportName));
 		}
 
 		return exportedRules.get(exportName);
@@ -132,26 +132,26 @@ public class RGrammarSet {
 
 	/**
 	 * Get the source of an exported rule.
-	 * 
+	 *
 	 * This will often be a grammar name, but is not required to be one.
-	 * 
+	 *
 	 * @param exportName
 	 *                The name of the exported rule.
-	 * 
+	 *
 	 * @return The source of an exported rule.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the exported rule is invalid or not present in
 	 *                 this set.
 	 */
 	public String exportedFrom(String exportName) {
-		if(exportName == null) {
+		if (exportName == null) {
 			throw new NullPointerException("Export name must not be null");
-		} else if(exportName.equals("")) {
+		} else if (exportName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
-		} else if(!exportedRules.containsKey(exportName)) {
+		} else if (!exportedRules.containsKey(exportName)) {
 			throw new IllegalArgumentException(
-					String.format("No export with name '%s' defined", exportName));
+			        String.format("No export with name '%s' defined", exportName));
 		}
 
 		return exportFrom.getOrDefault(exportName, "unknown");
@@ -159,29 +159,29 @@ public class RGrammarSet {
 
 	/**
 	 * Get the source of an grammar
-	 * 
+	 *
 	 * This will often be a file name, but is not required to be one.
-	 * 
+	 *
 	 * @param grammarName
 	 *                The name of the exported grammar.
-	 * 
+	 *
 	 * @return The source of an exported grammar.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the exported grammar is invalid or not present in
 	 *                 this set.
 	 */
 	public String loadedFrom(String grammarName) {
-		if(grammarName == null) {
+		if (grammarName == null) {
 			throw new NullPointerException("Grammar name must not be null");
-		} else if(grammarName.equals("")) {
+		} else if (grammarName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid grammar name");
-		} else if(grammarName.equals("unknown")) {
+		} else if (grammarName.equals("unknown")) {
 			return grammarName;
-		} else if(!grammars.containsKey(grammarName)) {
+		} else if (!grammars.containsKey(grammarName)) {
 
 			throw new IllegalArgumentException(
-					String.format("No grammar with name '%s' defined", grammarName));
+			        String.format("No grammar with name '%s' defined", grammarName));
 		}
 
 		return loadedFrom.getOrDefault(grammarName, "unknown");
@@ -189,7 +189,7 @@ public class RGrammarSet {
 
 	/**
 	 * Get the names of all the grammars in this set.
-	 * 
+	 *
 	 * @return The names of all the grammars in this set.
 	 */
 	public Set<String> getGrammars() {
@@ -198,7 +198,7 @@ public class RGrammarSet {
 
 	/**
 	 * Get the names of all the exported rules in this set.
-	 * 
+	 *
 	 * @return The names of all the exported rules in this set.
 	 */
 	public Set<String> getExportedRules() {
@@ -207,12 +207,12 @@ public class RGrammarSet {
 
 	/**
 	 * Load a grammar set from a configuration file.
-	 * 
+	 *
 	 * @param cfgFile
 	 *                The configuration file to load from.
-	 * 
+	 *
 	 * @return The grammar set created by the configuration file.
-	 * 
+	 *
 	 * @throws IOException
 	 *                 If something goes wrong during configuration loading.
 	 */
@@ -225,14 +225,15 @@ public class RGrammarSet {
 			/*
 			 * Execute lines from the configuration file.
 			 */
-			while(scn.hasNextLine()) {
+			while (scn.hasNextLine()) {
 				String ln = scn.nextLine().trim();
 
 				/*
 				 * Ignore blank/comment lines.
 				 */
-				if(ln.equals("")) continue;
-				if(ln.startsWith("#")) continue;
+				if (ln.equals("")) continue;
+
+				if (ln.startsWith("#")) continue;
 
 				/*
 				 * Handle mixed whitespace
@@ -241,7 +242,7 @@ public class RGrammarSet {
 
 				int nameIdx = ln.indexOf(" ");
 
-				if(nameIdx == -1) {
+				if (nameIdx == -1) {
 					throw new GrammarException("Must specify a name for a loaded grammar");
 				}
 
@@ -258,12 +259,12 @@ public class RGrammarSet {
 
 				File fle = convPath.toFile();
 
-				if(fle.isDirectory()) {
+				if (fle.isDirectory()) {
 					/*
 					 * TODO implement subset grammars
 					 */
 					throw new GrammarException("Sub-grammar sets aren't implemented yet");
-				} else if(fle.getName().endsWith(".gram")) {
+				} else if (fle.getName().endsWith(".gram")) {
 					/*
 					 * Load grammar files.
 					 */
@@ -271,13 +272,13 @@ public class RGrammarSet {
 						FileReader fis = new FileReader(fle);
 						RGrammar gram = RGrammarParser.readGrammar(fis);
 						fis.close();
-						
+
 						set.addGrammar(name, gram);
 
 						set.loadedFrom.put(name, path.toString());
-					} catch(GrammarException gex) {
+					} catch (GrammarException gex) {
 						throw new GrammarException(
-								String.format("Error loading file '%s'", path), gex);
+						        String.format("Error loading file '%s'", path), gex);
 					}
 				} else {
 					throw new GrammarException(String.format("Unrecognized file '%s'"));
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java b/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
index 7d8ed9c..7bfd762 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RGrammarTest.java
@@ -7,14 +7,14 @@ import java.nio.file.Paths;
 
 /**
  * Test for new grammar syntax.
- * 
+ *
  * @author EVE
  *
  */
 public class RGrammarTest {
 	/**
 	 * Main method.
-	 * 
+	 *
 	 * @param args
 	 *                Unused CLI args.
 	 */
@@ -24,20 +24,20 @@ public class RGrammarTest {
 		try {
 			RGrammarSet gramSet = RGrammarSet.fromConfigFile(Paths.get(rsc.toURI()));
 
-			for(String gramName : gramSet.getGrammars()) {
+			for (String gramName : gramSet.getGrammars()) {
 				gramSet.getGrammar(gramName).generateSuggestions();
 			}
 
-			for(String exportName : gramSet.getExportedRules()) {
+			for (String exportName : gramSet.getExportedRules()) {
 				RGrammar grammar = gramSet.getExportSource(exportName);
 
-				for(int i = 0; i < 10; i++) {
+				for (int i = 0; i < 10; i++) {
 					try {
 						grammar.generate(exportName);
-					} catch(GrammarException gex) {
+					} catch (GrammarException gex) {
 						System.out.println("Error in exported rule " + exportName
-								+ " (loaded from "
-								+ gramSet.loadedFrom(gramSet.exportedFrom(exportName)));
+						                   + " (loaded from "
+						                   + gramSet.loadedFrom(gramSet.exportedFrom(exportName)));
 
 						System.out.println();
 
@@ -48,9 +48,9 @@ public class RGrammarTest {
 					}
 				}
 			}
-		} catch(IOException ioex) {
+		} catch (IOException ioex) {
 			ioex.printStackTrace();
-		} catch(URISyntaxException urisex) {
+		} catch (URISyntaxException urisex) {
 			urisex.printStackTrace();
 		}
 	}
diff --git a/RGens/src/main/java/bjc/rgens/newparser/Rule.java b/RGens/src/main/java/bjc/rgens/newparser/Rule.java
index 0197860..aee1a89 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/Rule.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/Rule.java
@@ -7,7 +7,7 @@ import java.util.Random;
 
 /**
  * A rule in a randomized grammar.
- * 
+ *
  * @author EVE
  *
  */
@@ -21,17 +21,17 @@ public class Rule {
 
 	/**
 	 * Create a new grammar rule.
-	 * 
+	 *
 	 * @param ruleName
 	 *                The name of the grammar rule.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the rule name is invalid.
 	 */
 	public Rule(String ruleName) {
-		if(ruleName == null) {
+		if (ruleName == null) {
 			throw new NullPointerException("Rule name must not be null");
-		} else if(ruleName.equals("")) {
+		} else if (ruleName.equals("")) {
 			throw new IllegalArgumentException("The empty string is not a valid rule name");
 		}
 
@@ -42,12 +42,12 @@ public class Rule {
 
 	/**
 	 * Adds a case to the rule.
-	 * 
+	 *
 	 * @param cse
 	 *                The case to add.
 	 */
 	public void addCase(RuleCase cse) {
-		if(cse == null) {
+		if (cse == null) {
 			throw new NullPointerException("Case must not be null");
 		}
 
@@ -56,7 +56,7 @@ public class Rule {
 
 	/**
 	 * Get a random case from this rule.
-	 * 
+	 *
 	 * @return A random case from this rule.
 	 */
 	public RuleCase getCase() {
@@ -65,10 +65,10 @@ public class Rule {
 
 	/**
 	 * Get a random case from this rule.
-	 * 
+	 *
 	 * @param rnd
 	 *                The random number generator to use.
-	 * 
+	 *
 	 * @return A random case from this rule.
 	 */
 	public RuleCase getCase(Random rnd) {
@@ -77,7 +77,7 @@ public class Rule {
 
 	/**
 	 * Get all the cases of this rule.
-	 * 
+	 *
 	 * @return All the cases in this rule.
 	 */
 	public IList<RuleCase> getCases() {
@@ -97,19 +97,21 @@ public class Rule {
 
 	@Override
 	public boolean equals(Object obj) {
-		if(this == obj) return true;
-		if(obj == null) return false;
-		if(!(obj instanceof Rule)) return false;
+		if (this == obj) return true;
+
+		if (obj == null) return false;
+
+		if (!(obj instanceof Rule)) return false;
 
 		Rule other = (Rule) obj;
 
-		if(cases == null) {
-			if(other.cases != null) return false;
-		} else if(!cases.equals(other.cases)) return false;
+		if (cases == null) {
+			if (other.cases != null) return false;
+		} else if (!cases.equals(other.cases)) return false;
 
-		if(name == null) {
-			if(other.name != null) return false;
-		} else if(!name.equals(other.name)) return false;
+		if (name == null) {
+			if (other.name != null) return false;
+		} else if (!name.equals(other.name)) return false;
 
 		return true;
 	}
diff --git a/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java b/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
index 9652273..3f971c3 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
+++ b/RGens/src/main/java/bjc/rgens/newparser/RuleCase.java
@@ -4,13 +4,13 @@ import bjc.utils.funcdata.IList;
 
 /**
  * A case in a rule in a randomized grammar.
- * 
+ *
  * @author EVE
  */
 public class RuleCase {
 	/**
 	 * The possible types of a case.
-	 * 
+	 *
 	 * @author EVE
 	 *
 	 */
@@ -28,7 +28,7 @@ public class RuleCase {
 
 	/**
 	 * The list of element values for this case.
-	 * 
+	 *
 	 * <h2>Used For</h2>
 	 * <dl>
 	 * <dt>NORMAL</dt>
@@ -39,17 +39,18 @@ public class RuleCase {
 
 	/**
 	 * Create a new case of the specified type.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of case to create.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If the type requires parameters.
 	 */
 	public RuleCase(CaseType typ) {
-		switch(typ) {
+		switch (typ) {
 		case NORMAL:
 			throw new IllegalArgumentException("This type requires an element list parameter");
+
 		default:
 			break;
 		}
@@ -60,20 +61,21 @@ public class RuleCase {
 	/**
 	 * Create a new case of the specified type that takes a element list
 	 * parameter.
-	 * 
+	 *
 	 * @param typ
 	 *                The type of case to create.
-	 * 
+	 *
 	 * @param elements
 	 *                The element list parameter of the case.
-	 * 
+	 *
 	 * @throws IllegalArgumentException
 	 *                 If this type doesn't take a element list parameter.
 	 */
 	public RuleCase(CaseType typ, IList<CaseElement> elements) {
-		switch(typ) {
+		switch (typ) {
 		case NORMAL:
 			break;
+
 		default:
 			throw new IllegalArgumentException("This type doesn't have a element list parameter");
 		}
@@ -85,7 +87,7 @@ public class RuleCase {
 
 	/**
 	 * Get the element list value of this type.
-	 * 
+	 *
 	 * @return The element list value of this case, or null if this type
 	 *         doesn't have one.
 	 */
diff --git a/RGens/src/main/java/bjc/rgens/newparser/new-syntax.txt b/RGens/src/main/java/bjc/rgens/newparser/new-syntax.txt
index 3e5738c..f6578b4 100644
--- a/RGens/src/main/java/bjc/rgens/newparser/new-syntax.txt
+++ b/RGens/src/main/java/bjc/rgens/newparser/new-syntax.txt
@@ -1,13 +1,13 @@
-[grammar] → ([block] (/\n\.\n?/ [block])*)?
+[grammar] → ([block] ( / \n\.\n ? / [block])*) ?
 
-[block] → [pragma-block]
-	→ [rule-block]
-	→ [where-block]
+[block] → [pragma - block]
+→ [rule - block]
+→ [where - block]
 
-[pragma-block] → [pragma] (/\n(?!\t)/ [pragma])*
+[pragma - block] → [pragma] ( / \n( ? !\t) / [pragma])*
 
-[rule-block] → [rule-decl] [rule-case] (/\n\t/ [rule-case])*
+[rule - block] → [rule - decl] [rule - case] ( / \n\t / [rule - case])*
 
-[where-block] -> where /\n\t/ ([rule-block] /\n\t/)+ in /\n\t/ [rule-block]
+[where - block] → where / \n\t / ([rule - block] / \n\t / ) + in / \n\t / [rule - block]
 
-[pragma] → pragma [pragma-name] [pragma-body]
+[pragma] → pragma [pragma - name] [pragma - body]
diff --git a/RGens/src/main/java/bjc/rgens/text/markov/Markov.java b/RGens/src/main/java/bjc/rgens/text/markov/Markov.java
index 9eb4134..df8b06c 100755..100644
--- a/RGens/src/main/java/bjc/rgens/text/markov/Markov.java
+++ b/RGens/src/main/java/bjc/rgens/text/markov/Markov.java
@@ -6,19 +6,19 @@ import java.util.*;
 /**
  * Represents a k-character substring. Can give a pseudo-random suffix character
  * based on probability.
- * 
+ *
  * @author Daniel Friedman (Fall 2011)
  *
  */
 public class Markov {
-	String	substring;
-	int	count	= 0;
+	String  substring;
+	int     count   = 0;
 
 	TreeMap<Character, Integer> map;
 
 	/**
 	 * Constructs a Markov object from a given substring.
-	 * 
+	 *
 	 * @param substr
 	 *                the given substring.
 	 */
@@ -33,7 +33,7 @@ public class Markov {
 	/**
 	 * Constructs a Markov object from a given substring and suffix
 	 * character. Suffix characters are stored in a TreeMap.
-	 * 
+	 *
 	 * @param substr
 	 *                the specified substring.
 	 * @param suffix
@@ -57,7 +57,7 @@ public class Markov {
 
 	/**
 	 * Adds a suffix character to the TreeMap.
-	 * 
+	 *
 	 * @param c
 	 *                the suffix character to be added.
 	 */
@@ -73,7 +73,7 @@ public class Markov {
 	/**
 	 * Gives the frequency count of a suffix character; that is, the number
 	 * of times the specified suffix follows the substring in a text.
-	 * 
+	 *
 	 * @param c
 	 *                the specified suffix.
 	 * @return the frequency count.
@@ -88,7 +88,7 @@ public class Markov {
 
 	/**
 	 * Gives a percentage of frequency count / number of total suffixes.
-	 * 
+	 *
 	 * @param c
 	 * @return the ratio of frequency count of a single character to the
 	 *         total number of suffixes
@@ -103,7 +103,7 @@ public class Markov {
 
 	/**
 	 * Finds whether or not the given suffix is in the TreeMap.
-	 * 
+	 *
 	 * @param c
 	 *                the given suffix.
 	 * @return True if the suffix exists in the TreeMap, false otherwise.
@@ -118,7 +118,7 @@ public class Markov {
 
 	/**
 	 * Gives the number of times this substring occurs in a text.
-	 * 
+	 *
 	 * @return said number of times.
 	 */
 	public int count() {
@@ -127,7 +127,7 @@ public class Markov {
 
 	/**
 	 * Gives the TreeMap.
-	 * 
+	 *
 	 * @return the TreeMap.
 	 */
 	public TreeMap<Character, Integer> getMap() {
@@ -142,7 +142,7 @@ public class Markov {
 	 * indices in the ArrayList, the probability of getting a more common
 	 * suffix is greater than the probability of getting a less common
 	 * suffix.
-	 * 
+	 *
 	 * @return the pseudo-random suffix.
 	 */
 	public char random() {
@@ -170,7 +170,7 @@ public class Markov {
 
 	/**
 	 * Gives a String representation of the Markov object.
-	 * 
+	 *
 	 * @return said String representation.
 	 */
 	@Override
@@ -183,6 +183,7 @@ public class Markov {
 			int value = entry.getValue();
 			ret += "\n" + "Suffix: " + key + ", frequency count: " + value;
 		}
+
 		return ret;
 	}
 }
diff --git a/RGens/src/main/java/bjc/rgens/text/markov/StandaloneMarkov.java b/RGens/src/main/java/bjc/rgens/text/markov/StandaloneMarkov.java
index 8934daa..29f8446 100644
--- a/RGens/src/main/java/bjc/rgens/text/markov/StandaloneMarkov.java
+++ b/RGens/src/main/java/bjc/rgens/text/markov/StandaloneMarkov.java
@@ -4,25 +4,25 @@ import java.util.Map;
 
 /**
  * A standalone Markov generator.
- * 
+ *
  * @author bjculkin
  *
  */
 public class StandaloneMarkov {
 	private int ord;
 
-	private Map<String, Markov>	hash;
-	private String			first;
+	private Map<String, Markov>     hash;
+	private String                  first;
 
 	/**
 	 * Create a new standalone Markov generator.
-	 * 
+	 *
 	 * @param order
 	 *                The order of this generator.
-	 * 
+	 *
 	 * @param markovHash
 	 *                The generators to use.
-	 * 
+	 *
 	 * @param firstSub
 	 *                The string to start out with.
 	 */
@@ -34,10 +34,10 @@ public class StandaloneMarkov {
 
 	/**
 	 * Generate random text from the markov generator.
-	 * 
+	 *
 	 * @param charsToGenerate
 	 *                The number of characters of text to generate.
-	 * 
+	 *
 	 * @return The randomly generate text.
 	 */
 	public String generateTextFromMarkov(int charsToGenerate) {
diff --git a/RGens/src/main/java/bjc/rgens/text/markov/StandaloneTextGenerator.java b/RGens/src/main/java/bjc/rgens/text/markov/StandaloneTextGenerator.java
index 17cd670..c6eea0d 100644
--- a/RGens/src/main/java/bjc/rgens/text/markov/StandaloneTextGenerator.java
+++ b/RGens/src/main/java/bjc/rgens/text/markov/StandaloneTextGenerator.java
@@ -7,20 +7,20 @@ import java.util.Map;
 
 /**
  * Create a Markov generate from a provided source.
- * 
+ *
  * @author bjculkin
  *
  */
 public class StandaloneTextGenerator {
 	/**
 	 * Build a markov generator from a provided source.
-	 * 
+	 *
 	 * @param order
 	 *                The markov order to use.
-	 * 
+	 *
 	 * @param reader
 	 *                The source to seed the generator from.
-	 * 
+	 *
 	 * @return The markov generator for the provided text.
 	 */
 	public static StandaloneMarkov generateMarkovMap(int order, Reader reader) {
diff --git a/RGens/src/main/java/bjc/rgens/text/markov/TextGenerator.java b/RGens/src/main/java/bjc/rgens/text/markov/TextGenerator.java
index 7d20d79..0ec40df 100755..100644
--- a/RGens/src/main/java/bjc/rgens/text/markov/TextGenerator.java
+++ b/RGens/src/main/java/bjc/rgens/text/markov/TextGenerator.java
@@ -4,20 +4,20 @@ import java.io.*;
 
 /**
  * Generate text from a markov model of an input text
- * 
+ *
  * @author ben
  *
  */
 public class TextGenerator {
 	/**
 	 * Main method.
-	 * 
+	 *
 	 * @param args
 	 *                when used with three arguments, the first represents
 	 *                the k-order of the Markov objects. The second
 	 *                represents the number of characters to print out. The
 	 *                third represents the file to be read.
-	 * 
+	 *
 	 *                When used with two arguments, the first represents the
 	 *                k-order of the Markov objects, and the second
 	 *                represents the file to be read. The generated text
diff --git a/RGens/src/main/sql/db_schema.sql b/RGens/src/main/sql/db_schema.sql
index 10df3f0..553c7a8 100644
--- a/RGens/src/main/sql/db_schema.sql
+++ b/RGens/src/main/sql/db_schema.sql
@@ -1,15 +1,15 @@
 create table Rules (
-	ruleid serial,
-	name varchar(255) not null,
-	casecount int,
-	primary key(id)
+        ruleid serial,
+        name varchar(255) not null,
+        casecount int,
+        primary key(id)
 );
 
 create index Rules_name on Rules(name);
 
 create table RuleCases (
-	ruleid serial,
-	cse varchar(255) array
+        ruleid serial,
+        cse varchar(255) array
 );
 
 create index RuleCase_id on RuleCases(ruleid);