Start splitting into maven modules

24 files changed, 0 insertions, 2837 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/DoubleMatcher.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/DoubleMatcher.java
deleted file mode 100644
index a885808..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/DoubleMatcher.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package bjc.utils.parserutils;
-
-import static bjc.utils.PropertyDB.applyFormat;
-import static bjc.utils.PropertyDB.getRegex;
-
-import java.util.regex.Pattern;
-
-/*
- * Checks if a string would pass Double.parseDouble.
- *
- * Uses a regex from the javadoc for Double.valueOf()
- */
-class DoubleMatcher {
-	/*
-	 * Unit pieces.
-	 */
-	private static final String	rDecDigits	= getRegex("fpDigits");
-	private static final String	rHexDigits	= getRegex("fpHexDigits");
-	private static final String	rExponent	= applyFormat("fpExponent", getRegex("fpExponent"), rDecDigits);
-
-	/*
-	 * Decimal floating point numbers.
-	 */
-	private static final String	rSimpleDec	= applyFormat("fpDecimalDecimal", rDecDigits, rExponent);
-	private static final String	rSimpleIntDec	= applyFormat("fpDecimalInteger", rDecDigits, rExponent);
-
-	/*
-	 * Hex floating point numbers.
-	 */
-	private static final String	rHexInt		= applyFormat("fpHexInteger", rHexDigits);
-	private static final String	rHexDec		= applyFormat("fpHexDecimal", rHexDigits);
-	private static final String	rHexLead	= applyFormat("fpHexLeader", rHexInt, rHexDec);
-	private static final String	rHexString	= applyFormat("fpHexString", rHexLead, rDecDigits);
-
-	/*
-	 * Floating point components.
-	 */
-	private static final String	rFPLeader	= getRegex("fpLeader");
-	private static final String	rFPNum		= applyFormat("fpNumber", rSimpleIntDec, rSimpleDec, rHexString);
-
-	/*
-	 * Full double.
-	 */
-	private static final String	rDouble		= applyFormat("fpDouble", rFPLeader, rFPNum);
-	public static final Pattern	doubleLiteral	= Pattern.compile("\\A" + rDouble + "\\Z");
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/IPrecedent.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/IPrecedent.java
deleted file mode 100644
index aa366cf..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/IPrecedent.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package bjc.utils.parserutils;
-
-/**
- * Represents something that has a set precedence
- *
- * @author ben
- *
- */
-@FunctionalInterface
-public interface IPrecedent {
-	/**
-	 * Create a new object with set precedence
-	 *
-	 * @param precedence
-	 *                The precedence of the object to handle
-	 * @return A new object with set precedence
-	 */
-	public static IPrecedent newSimplePrecedent(final int precedence) {
-		return () -> precedence;
-	}
-
-	/**
-	 * Get the precedence of the attached object
-	 *
-	 * @return The precedence of the attached object
-	 */
-	public int getPrecedence();
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ParserException.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ParserException.java
deleted file mode 100644
index ae33aba..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ParserException.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package bjc.utils.parserutils;
-
-/**
- * General superclass for exceptions thrown during parsing.
- *
- * @author EVE
- *
- */
-public class ParserException extends Exception {
-	/**
-	 *
-	 */
-	private static final long serialVersionUID = 631298568113373233L;
-
-	/**
-	 * Create a new exception with the provided message.
-	 *
-	 * @param msg
-	 *                The message for the exception.
-	 */
-	public ParserException(final String msg) {
-		super(msg);
-	}
-
-	/**
-	 * Create a new exception with the provided message and cause.
-	 *
-	 * @param msg
-	 *                The message for the exception.
-	 * @param cause
-	 *                The cause of the exception.
-	 */
-	public ParserException(final String msg, final Exception cause) {
-		super(msg, cause);
-	}
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
deleted file mode 100644
index a1b5feb..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java
+++ /dev/null
@@ -1,274 +0,0 @@
-package bjc.utils.parserutils;
-
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.function.Consumer;
-import java.util.function.Function;
-
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.FunctionalMap;
-import bjc.utils.funcdata.IList;
-import bjc.utils.funcdata.IMap;
-import bjc.utils.funcutils.StringUtils;
-
-/**
- * Utility to run the shunting yard algorithm on a bunch of tokens.
- *
- * @author ben
- *
- * @param <TokenType>
- *                The type of tokens being shunted.
- */
-public class ShuntingYard<TokenType> {
-	/**
-	 * A enum representing the fundamental operator types.
-	 *
-	 * @author ben
-	 *
-	 */
-	public static enum Operator implements IPrecedent {
-		/**
-		 * Represents addition.
-		 */
-		ADD(1),
-		/**
-		 * Represents subtraction.
-		 */
-		SUBTRACT(2),
-
-		/**
-		 * Represents multiplication.
-		 */
-		MULTIPLY(3),
-		/**
-		 * Represents division.
-		 */
-		DIVIDE(4);
-
-		private final int precedence;
-
-		private Operator(final int prec) {
-			precedence = prec;
-		}
-
-		@Override
-		public int getPrecedence() {
-			return precedence;
-		}
-	}
-
-	/*
-	 * Function that shunts tokens.
-	 */
-	private final class TokenShunter implements Consumer<String> {
-		private final IList<TokenType>			output;
-		private final Deque<String>			stack;
-		private final Function<String, TokenType>	transformer;
-
-		public TokenShunter(final IList<TokenType> outpt, final Deque<String> stack,
-				final Function<String, TokenType> transformer) {
-			this.output = outpt;
-			this.stack = stack;
-			this.transformer = transformer;
-		}
-
-		@Override
-		public void accept(final String token) {
-			/*
-			 * Handle operators
-			 */
-			if (operators.containsKey(token)) {
-				/* 
-				 * Pop operators while there isn't a higher precedence one
-				 */
-				while (!stack.isEmpty() && isHigherPrec(token, stack.peek())) {
-					output.add(transformer.apply(stack.pop()));
-				}
-
-				/*
-				 * Put this operator onto the stack
-				 */
-				stack.push(token);
-			} else if (StringUtils.containsOnly(token, "\\(")) {
-				/*
-				 * Handle groups of parenthesis for multiple nesting levels
-				 */
-				stack.push(token);
-			} else if (StringUtils.containsOnly(token, "\\)")) {
-				/*
-				 * Handle groups of parenthesis for multiple nesting levels
-				 */
-				final String swappedToken = token.replace(')', '(');
-
-				/*
-				 * Remove tokens up to a matching parenthesis
-				 */
-				while (!stack.peek().equals(swappedToken)) {
-					output.add(transformer.apply(stack.pop()));
-				}
-
-				/*
-				 * Remove the parenthesis
-				 */
-				stack.pop();
-			} else {
-				/*
-				 * Just add the transformed token
-				 */
-				output.add(transformer.apply(token));
-			}
-		}
-	}
-
-	/*
-	 * Holds all the shuntable operations.
-	 */
-	private IMap<String, IPrecedent> operators;
-
-	/**
-	 * Create a new shunting yard with a default set of operators.
-	 *
-	 * @param configureBasics
-	 *                Whether or not basic math operators should be
-	 *                provided.
-	 */
-	public ShuntingYard(final boolean configureBasics) {
-		operators = new FunctionalMap<>();
-
-		/*
-		 * Add basic operators if we're configured to do so
-		 */
-		if (configureBasics) {
-			operators.put("+", Operator.ADD);
-			operators.put("-", Operator.SUBTRACT);
-			operators.put("*", Operator.MULTIPLY);
-			operators.put("/", Operator.DIVIDE);
-		}
-	}
-
-	/**
-	 * Add an operator to the list of shuntable operators.
-	 *
-	 * @param operator
-	 *                The token representing the operator.
-	 *
-	 * @param precedence
-	 *                The precedence of the operator to add.
-	 */
-	public void addOp(final String operator, final int precedence) {
-		/*
-		 * Create the precedence marker
-		 */
-		final IPrecedent prec = IPrecedent.newSimplePrecedent(precedence);
-
-		this.addOp(operator, prec);
-	}
-
-	/**
-	 * Add an operator to the list of shuntable operators.
-	 *
-	 * @param operator
-	 *                The token representing the operator.
-	 *
-	 * @param precedence
-	 *                The precedence of the operator.
-	 */
-	public void addOp(final String operator, final IPrecedent precedence) {
-		/*
-		 * Complain about trying to add an incorrect operator
-		 */
-		if (operator == null)
-			throw new NullPointerException("Operator must not be null");
-		else if (precedence == null) throw new NullPointerException("Precedence must not be null");
-
-		/*
-		 * Add the operator to the ones we handle
-		 */
-		operators.put(operator, precedence);
-	}
-
-	private boolean isHigherPrec(final String left, final String right) {
-		/*
-		 * Check if the right operator exists
-		 */
-		final boolean exists = operators.containsKey(right);
-
-		/*
-		 * If it doesn't, the left is higher precedence.
-		 */
-		if (!exists) return false;
-
-		/*
-		 * Get the precedence of operators
-		 */
-		final int rightPrecedence = operators.get(right).getPrecedence();
-		final int leftPrecedence = operators.get(left).getPrecedence();
-
-		/*
-		 * Evaluate what we were asked
-		 */
-		return rightPrecedence >= leftPrecedence;
-	}
-
-	/**
-	 * Transform a string of tokens from infix notation to postfix.
-	 *
-	 * @param input
-	 *                The string to transform.
-	 *
-	 * @param transformer
-	 *                The function to use to transform strings to tokens.
-	 *
-	 * @return A list of tokens in postfix notation.
-	 */
-	public IList<TokenType> postfix(final IList<String> input, final Function<String, TokenType> transformer) {
-		/*
-		 * Check our input
-		 */
-		if (input == null)
-			throw new NullPointerException("Input must not be null");
-		else if (transformer == null) throw new NullPointerException("Transformer must not be null");
-
-		/*
-		 * Here's what we're handing back
-		 */
-		final IList<TokenType> output = new FunctionalList<>();
-
-		/*
-		 * The stack to put operators on
-		 */
-		final Deque<String> stack = new LinkedList<>();
-
-		/*
-		 * Shunt the tokens
-		 */
-		input.forEach(new TokenShunter(output, stack, transformer));
-
-		/*
-		 * Transform any resulting tokens
-		 */
-		stack.forEach(token -> {
-			output.add(transformer.apply(token));
-		});
-
-		return output;
-	}
-
-	/**
-	 * Remove an operator from the list of shuntable operators.
-	 *
-	 * @param operator
-	 *                The token representing the operator. If null, remove
-	 *                all operators.
-	 */
-	public void removeOp(final String operator) {
-		/*
-		 * Check if we want to remove all operators
-		 */
-		if (operator == null) {
-			operators = new FunctionalMap<>();
-		} else {
-			operators.remove(operator);
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/StringDescaper.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/StringDescaper.java
deleted file mode 100644
index 096656a..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/StringDescaper.java
+++ /dev/null
@@ -1,242 +0,0 @@
-package bjc.utils.parserutils;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.UnaryOperator;
-import java.util.logging.Logger;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.regex.PatternSyntaxException;
-
-import static java.util.Map.Entry;
-
-import static bjc.utils.PropertyDB.applyFormat;
-import static bjc.utils.PropertyDB.getCompiledRegex;
-import static bjc.utils.PropertyDB.getRegex;
-
-public class StringDescaper {
-	private Logger LOGGER = Logger.getLogger(StringDescaper.class.getName());
-
-	/*
-	 * Patterns and pattern parts.
-	 */
-	private static String  rPossibleEscapeString = getRegex("possibleStringEscape");
-	private static Pattern possibleEscapePatt    = Pattern.compile(rPossibleEscapeString);
-
-	private static String rShortEscape     = getRegex("shortFormStringEscape");
-	private static String rOctalEscape     = getRegex("octalStringEscape");
-	private static String rUnicodeEscape   = getRegex("unicodeStringEscape");
-
-	private String  rEscapeString;
-	private Pattern escapePatt;
-
-	private static String  rDoubleQuoteString = applyFormat("doubleQuotes", getRegex("nonStringEscape"), rPossibleEscapeString);
-	private static Pattern doubleQuotePatt    = Pattern.compile(rDoubleQuoteString);
-
-	private static Pattern quotePatt = getCompiledRegex("unescapedQuote");
-
-	private Map<String, String> literalEscapes;
-	private Map<Pattern, UnaryOperator<String>> specialEscapes;
-	
-	public StringDescaper() {
-		literalEscapes = new HashMap<>();
-		specialEscapes = new HashMap<>();
-
-		rEscapeString = String.format("\\\\(%1$s|%2$s|%3$s)");
-		escapePatt    = Pattern.compile(rEscapeString);
-	}
-
-	public void addLiteralEscape(String escape, String val) {
-		if(literalEscapes.containsKey(escape)) {
-			LOGGER.warning(String.format("Shadowing literal escape '%s'\n", escape));
-		}
-
-		literalEscapes.put(escape, val);
-	}
-
-	public void addSpecialEscape(String escape, UnaryOperator<String> val) {
-		if(specialEscapes.containsKey(escape)) {
-			LOGGER.warning(String.format("Shadowing special escape '%s'\n", escape));
-		}
-
-		/*
-		 * Make sure this special escape is a valid regex.
-		 */
-
-		Pattern patt = null;
-		try {
-			patt = Pattern.compile(escape);
-		} catch (PatternSyntaxException psex) {
-			String msg = String.format("Invalid special escape '%s'", escape);
-
-			IllegalArgumentException iaex = new IllegalArgumentException(msg);
-			iaex.initCause(psex);
-
-			throw psex;
-		}
-
-		specialEscapes.put(patt, val);
-	}
-
-	public void compileEscapes() {
-		StringBuilder work = new StringBuilder();
-
-		for(String litEscape : literalEscapes.keySet()) {
-			work.append("|(?:");
-			work.append(Pattern.quote(litEscape));
-			work.append(")");
-		}
-
-		for(Pattern specEscape : specialEscapes.keySet()) {
-			work.append("|(?:");
-			work.append(specEscape.toString());
-			work.append(")");
-		}
-
-		/*
-		 * Convert user-defined escapes to a regex for matching.
-		 * We don't need a bar before %4 because the string has it.
-		 */
-		rEscapeString = String.format("\\(%1$s|%2$s|%3$s%4$s)", rShortEscape, rOctalEscape, rUnicodeEscape, work.toString());
-		escapePatt    = Pattern.compile(rEscapeString);
-	}
-
-	/**
-	 * Replace escape characters with their actual equivalents.
-	 *
-	 * @param inp
-	 *                The string to replace escape sequences in.
-	 *
-	 * @return The string with escape sequences replaced by their equivalent
-	 *         characters.
-	 */
-	public String descapeString(final String inp) {
-		if (inp == null) {
-			throw new NullPointerException("Input to descapeString must not be null");
-		}
-
-		/*
-		 * Prepare the buffer and escape finder.
-		 */
-		final StringBuffer work = new StringBuffer();
-		final Matcher possibleEscapeFinder = possibleEscapePatt.matcher(inp);
-		final Matcher escapeFinder = escapePatt.matcher(inp);
-
-		while (possibleEscapeFinder.find()) {
-			if (!escapeFinder.find()) {
-				/*
-				 * Found a possible escape that isn't actually an
-				 * escape.
-				 */
-				final String msg = String.format("Illegal escape sequence '%s' at position %d of string '%s'",
-						possibleEscapeFinder.group(), possibleEscapeFinder.start(), inp);
-				throw new IllegalArgumentException(msg);
-			}
-
-			final String escapeSeq = escapeFinder.group();
-
-			/*
-			 * Convert the escape to a string.
-			 */
-			String escapeRep = "";
-			switch (escapeSeq) {
-			case "\\b":
-				escapeRep = "\b";
-				break;
-			case "\\t":
-				escapeRep = "\t";
-				break;
-			case "\\n":
-				escapeRep = "\n";
-				break;
-			case "\\f":
-				escapeRep = "\f";
-				break;
-			case "\\r":
-				escapeRep = "\r";
-				break;
-			case "\\\"":
-				escapeRep = "\"";
-				break;
-			case "\\'":
-				escapeRep = "'";
-				break;
-			case "\\\\":
-				/*
-				 * Skip past the second slash.
-				 */
-				possibleEscapeFinder.find();
-				escapeRep = "\\";
-				break;
-			default:
-				if (escapeSeq.startsWith("u")) {
-					escapeRep = handleUnicodeEscape(escapeSeq.substring(1));
-				} else if(escapeSeq.startsWith("O")) {
-					escapeRep = handleOctalEscape(escapeSeq.substring(1));
-				} else if(literalEscapes.containsKey(escapeSeq)) {
-					escapeRep = literalEscapes.get(escapeSeq);
-				} else {
-					for(Entry<Pattern, UnaryOperator<String>> ent : specialEscapes.entrySet()) {
-						Pattern pat = ent.getKey();
-
-						Matcher mat = pat.matcher(escapeSeq);
-						if(mat.matches()) {
-							escapeRep = ent.getValue().apply(escapeSeq);
-							break;
-						}
-					}
-				}
-			}
-
-			escapeFinder.appendReplacement(work, escapeRep);
-		}
-
-		escapeFinder.appendTail(work);
-
-		return work.toString();
-	}
-
-	/*
-	 * Handle a unicode codepoint.
-	 */
-	private static String handleUnicodeEscape(final String seq) {
-		try {
-			final int codepoint = Integer.parseInt(seq, 16);
-
-			return new String(Character.toChars(codepoint));
-		} catch (final IllegalArgumentException iaex) {
-			final String msg = String.format("'%s' is not a valid Unicode escape sequence'", seq);
-
-			final IllegalArgumentException reiaex = new IllegalArgumentException(msg);
-
-			reiaex.initCause(iaex);
-
-			throw reiaex;
-		}
-	}
-
-	/*
-	 * Handle a octal codepoint.
-	 */
-	private static String handleOctalEscape(final String seq) {
-		try {
-			final int codepoint = Integer.parseInt(seq, 8);
-
-			if (codepoint > 255) {
-				final String msg = String.format("'%d' is outside the range of octal escapes', codepoint");
-
-				throw new IllegalArgumentException(msg);
-			}
-
-			return new String(Character.toChars(codepoint));
-		} catch (final IllegalArgumentException iaex) {
-			final String msg = String.format("'%s' is not a valid octal escape sequence'", seq);
-
-			final IllegalArgumentException reiaex = new IllegalArgumentException(msg);
-
-			reiaex.initCause(iaex);
-
-			throw reiaex;
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
deleted file mode 100644
index 30ccc5a..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenTransformer.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package bjc.utils.parserutils;
-
-import java.util.Deque;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.function.UnaryOperator;
-
-import bjc.utils.data.IHolder;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Pair;
-import bjc.utils.data.Tree;
-import bjc.utils.parserutils.TreeConstructor.ConstructorState;
-import bjc.utils.parserutils.TreeConstructor.QueueFlattener;
-
-/*
- * Handle creating ASTs from tokens.
- */
-final class TokenTransformer<TokenType> implements Consumer<TokenType> {
-	/*
-	 * Handle operators
-	 */
-	private final class OperatorHandler implements UnaryOperator<ConstructorState<TokenType>> {
-		private final TokenType element;
-
-		public OperatorHandler(final TokenType element) {
-			this.element = element;
-		}
-
-		@Override
-		public ConstructorState<TokenType> apply(final ConstructorState<TokenType> pair) {
-			/*
-			 * Replace the current AST with the result of handling an operator
-			 */
-			return new ConstructorState<>(pair.bindLeft(queuedASTs -> {
-				return handleOperator(queuedASTs);
-			}));
-		}
-
-		private ConstructorState<TokenType> handleOperator(final Deque<ITree<TokenType>> queuedASTs) {
-			/*
-			 * The AST we're going to hand back
-			 */
-			ITree<TokenType> newAST;
-
-			/*
-			 * Handle special operators
-			 */
-			if (isSpecialOperator.test(element)) {
-				newAST = handleSpecialOperator.apply(element).apply(queuedASTs);
-			} else {
-				/*
-				 * Error if we don't have enough for a binary operator
-				 */
-				if (queuedASTs.size() < 2) {
-					final String msg = String.format(
-							"Attempted to parse binary operator without enough operands\n\tProblem operator is: %s\n\tPossible operand is: %s",
-							element.toString(), queuedASTs.peek().toString());
-
-					throw new IllegalStateException(msg);
-				}
-
-				/*
-				 * Grab the two operands
-				 */
-				final ITree<TokenType> right = queuedASTs.pop();
-				final ITree<TokenType> left = queuedASTs.pop();
-
-				/*
-				 * Create a new AST
-				 */
-				newAST = new Tree<>(element, left, right);
-			}
-
-			/*
-			 * Stick it onto the stack
-			 */
-			queuedASTs.push(newAST);
-
-			/*
-			 * Hand back the state
-			 */
-			return new ConstructorState<>(queuedASTs, newAST);
-		}
-	}
-
-	private final IHolder<ConstructorState<TokenType>> initialState;
-
-	private final Predicate<TokenType> operatorPredicate;
-
-	private final Predicate<TokenType>				isSpecialOperator;
-	private final Function<TokenType, QueueFlattener<TokenType>>	handleSpecialOperator;
-
-	/*
-	 * Create a new transformer
-	 */
-	public TokenTransformer(final IHolder<ConstructorState<TokenType>> initialState,
-			final Predicate<TokenType> operatorPredicate, final Predicate<TokenType> isSpecialOperator,
-			final Function<TokenType, QueueFlattener<TokenType>> handleSpecialOperator) {
-		this.initialState = initialState;
-		this.operatorPredicate = operatorPredicate;
-		this.isSpecialOperator = isSpecialOperator;
-		this.handleSpecialOperator = handleSpecialOperator;
-	}
-
-	@Override
-	public void accept(final TokenType element) {
-		/*
-		 * Handle operators
-		 */
-		if (operatorPredicate.test(element)) {
-			initialState.transform(new OperatorHandler(element));
-		} else {
-			final ITree<TokenType> newAST = new Tree<>(element);
-
-			/*
-			 * Insert the new tree into the AST
-			 */
-			initialState.transform(pair -> {
-				/*
-				 * Transform the pair, ignoring the current AST in favor of the one consisting of the current element
-				 */
-				return new ConstructorState<>(pair.bindLeft(queue -> {
-					queue.push(newAST);
-
-					return new Pair<>(queue, newAST);
-				}));
-			});
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java
deleted file mode 100644
index 67c1e5a..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TokenUtils.java
+++ /dev/null
@@ -1,303 +0,0 @@
-package bjc.utils.parserutils;
-
-import static bjc.utils.PropertyDB.applyFormat;
-import static bjc.utils.PropertyDB.getCompiledRegex;
-import static bjc.utils.PropertyDB.getRegex;
-
-import java.util.LinkedList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-import bjc.utils.parserutils.splitter.TokenSplitter;
-
-/**
- * Utilities useful for operating on PL tokens.
- *
- * @author EVE
- *
- */
-public class TokenUtils {
-	/**
-	 * Simple implementation of TokenSplitter for removing double-quoted
-	 * strings.
-	 * 
-	 * @author EVE
-	 *
-	 */
-	public static class StringTokenSplitter implements TokenSplitter {
-		@Override
-		public IList<String> split(final String input) {
-			return new FunctionalList<>(TokenUtils.removeDQuotedStrings(input));
-		}
-	}
-
-	/*
-	 * Patterns and pattern parts.
-	 */
-	private static String rPossibleEscapeString = getRegex("possibleStringEscape");
-
-	private static Pattern possibleEscapePatt = Pattern.compile(rPossibleEscapeString);
-
-	private static String	rShortEscape	= getRegex("shortFormStringEscape");
-	private static String	rOctalEscape	= getRegex("octalStringEscape");
-	private static String	rUnicodeEscape	= getRegex("unicodeStringEscape");
-
-	private static String rEscapeString = applyFormat("stringEscape", rShortEscape, rOctalEscape, rUnicodeEscape);
-
-	private static Pattern escapePatt = Pattern.compile(rEscapeString);
-
-	private static String rDoubleQuoteString = applyFormat("doubleQuotes", getRegex("nonStringEscape"),
-			rPossibleEscapeString);
-
-	private static Pattern doubleQuotePatt = Pattern.compile(rDoubleQuoteString);
-
-	private static Pattern quotePatt = getCompiledRegex("unescapedQuote");
-
-	private static Pattern intLitPattern = getCompiledRegex("intLiteral");
-
-	/**
-	 * Remove double quoted strings from a string.
-	 *
-	 * Splits a string around instances of java-style double-quoted strings.
-	 *
-	 * @param inp
-	 *                The string to split.
-	 *
-	 * @return An list containing alternating bits of the string and the
-	 *         embedded double-quoted strings that separated them.
-	 */
-	public static List<String> removeDQuotedStrings(final String inp) {
-		if (inp == null) throw new NullPointerException("inp must not be null");
-
-		/*
-		 * What we need for piece-by-piece string building
-		 */
-		StringBuffer work = new StringBuffer();
-		final List<String> res = new LinkedList<>();
-
-		/*
-		 * Matcher for proper strings and single quotes.
-		 */
-		final Matcher mt = doubleQuotePatt.matcher(inp);
-		final Matcher corr = quotePatt.matcher(inp);
-
-		if (corr.find() && !corr.find()) {
-			/*
-			 * There's a unmatched opening quote with no strings.
-			 */
-			final String msg = String.format(
-					"Unclosed string literal '%s'. Opening quote was at position %d", inp,
-					inp.indexOf("\""));
-
-			throw new IllegalArgumentException(msg);
-		}
-
-		while (mt.find()) {
-			/*
-			 * Remove the string until the quoted string.
-			 */
-			mt.appendReplacement(work, "");
-
-			/*
-			 * Add the string preceding the double-quoted string and
-			 * the double-quoted string to the list.
-			 */
-			res.add(work.toString());
-			res.add(mt.group(1));
-
-			/*
-			 * Renew the buffer.
-			 */
-			work = new StringBuffer();
-		}
-
-		/*
-		 * Grab the remainder of the string.
-		 */
-		mt.appendTail(work);
-		final String tail = work.toString();
-
-		if (tail.contains("\"")) {
-			/*
-			 * There's a unmatched opening quote with at least one
-			 * string.
-			 */
-			final String msg = String.format(
-					"Unclosed string literal '%s'. Opening quote was at position %d", inp,
-					inp.lastIndexOf("\""));
-
-			throw new IllegalArgumentException(msg);
-		}
-
-		/*
-		 * Only add an empty tail if the string was empty.
-		 */
-		if (!tail.equals("") || res.isEmpty()) {
-			res.add(tail);
-		}
-
-		return res;
-	}
-
-	/**
-	 * Replace escape characters with their actual equivalents.
-	 *
-	 * @param inp
-	 *                The string to replace escape sequences in.
-	 *
-	 * @return The string with escape sequences replaced by their equivalent
-	 *         characters.
-	 */
-	public static String descapeString(final String inp) {
-		if (inp == null) throw new NullPointerException("inp must not be null");
-
-		/*
-		 * Prepare the buffer and escape finder.
-		 */
-		final StringBuffer work = new StringBuffer();
-		final Matcher possibleEscapeFinder = possibleEscapePatt.matcher(inp);
-		final Matcher escapeFinder = escapePatt.matcher(inp);
-
-		while (possibleEscapeFinder.find()) {
-			if (!escapeFinder.find()) {
-				/*
-				 * Found a possible escape that isn't actually an
-				 * escape.
-				 */
-				final String msg = String.format("Illegal escape sequence '%s' at position %d",
-						possibleEscapeFinder.group(), possibleEscapeFinder.start());
-
-				throw new IllegalArgumentException(msg);
-			}
-
-			final String escapeSeq = escapeFinder.group();
-
-			/*
-			 * Convert the escape to a string.
-			 */
-			String escapeRep = "";
-			switch (escapeSeq) {
-			case "\\b":
-				escapeRep = "\b";
-				break;
-			case "\\t":
-				escapeRep = "\t";
-				break;
-			case "\\n":
-				escapeRep = "\n";
-				break;
-			case "\\f":
-				escapeRep = "\f";
-				break;
-			case "\\r":
-				escapeRep = "\r";
-				break;
-			case "\\\"":
-				escapeRep = "\"";
-				break;
-			case "\\'":
-				escapeRep = "'";
-				break;
-			case "\\\\":
-				/*
-				 * Skip past the second slash.
-				 */
-				possibleEscapeFinder.find();
-				escapeRep = "\\";
-				break;
-			default:
-				if (escapeSeq.startsWith("u")) {
-					escapeRep = handleUnicodeEscape(escapeSeq.substring(1));
-				} else {
-					escapeRep = handleOctalEscape(escapeSeq);
-				}
-			}
-
-			escapeFinder.appendReplacement(work, escapeRep);
-		}
-
-		escapeFinder.appendTail(work);
-
-		return work.toString();
-	}
-
-	/*
-	 * Handle a unicode codepoint.
-	 */
-	private static String handleUnicodeEscape(final String seq) {
-		try {
-			final int codepoint = Integer.parseInt(seq, 16);
-
-			return new String(Character.toChars(codepoint));
-		} catch (final IllegalArgumentException iaex) {
-			final String msg = String.format("'%s' is not a valid Unicode escape sequence'", seq);
-
-			final IllegalArgumentException reiaex = new IllegalArgumentException(msg);
-
-			reiaex.initCause(iaex);
-
-			throw reiaex;
-		}
-	}
-
-	/*
-	 * Handle a octal codepoint.
-	 */
-	private static String handleOctalEscape(final String seq) {
-		try {
-			final int codepoint = Integer.parseInt(seq, 8);
-
-			if (codepoint > 255) {
-				final String msg = String
-						.format("'%d' is outside the range of octal escapes', codepoint");
-
-				throw new IllegalArgumentException(msg);
-			}
-
-			return new String(Character.toChars(codepoint));
-		} catch (final IllegalArgumentException iaex) {
-			final String msg = String.format("'%s' is not a valid octal escape sequence'", seq);
-
-			final IllegalArgumentException reiaex = new IllegalArgumentException(msg);
-
-			reiaex.initCause(iaex);
-
-			throw reiaex;
-		}
-	}
-
-	/**
-	 * Check if a given string would be successfully converted to a double
-	 * by {@link Double#parseDouble(String)}.
-	 *
-	 * @param inp
-	 *                The string to check.
-	 * @return Whether the string is a valid double or not.
-	 */
-	public static boolean isDouble(final String inp) {
-		return DoubleMatcher.doubleLiteral.matcher(inp).matches();
-	}
-
-	/**
-	 * Check if a given string would be successfully converted to a integer
-	 * by {@link Integer#parseInt(String)}.
-	 *
-	 * NOTE: This only checks syntax. Using values out of the range of
-	 * integers will still cause errors.
-	 *
-	 * @param inp
-	 *                The input to check.
-	 * @return Whether the string is a valid integer or not.
-	 */
-	public static boolean isInt(final String inp) {
-		try {
-			Integer.parseInt(inp);
-			return true;
-		} catch (NumberFormatException nfex) {
-			return false;
-		}
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
deleted file mode 100644
index 90141ef..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package bjc.utils.parserutils;
-
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.function.Function;
-import java.util.function.Predicate;
-
-import bjc.utils.data.IHolder;
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Identity;
-import bjc.utils.data.Pair;
-import bjc.utils.funcdata.IList;
-
-/**
- * Creates a parse tree from a postfix expression
- *
- * @author ben
- *
- */
-public class TreeConstructor {
-	/**
-	 * Alias interface for special operator types.
-	 *
-	 * @param <TokenType>
-	 *                The token type of the tree.
-	 */
-	public interface QueueFlattener<TokenType> extends Function<Deque<ITree<TokenType>>, ITree<TokenType>> {
-
-	}
-
-	/*
-	 * Alias for constructor state.
-	 */
-	static final class ConstructorState<TokenType> extends Pair<Deque<ITree<TokenType>>, ITree<TokenType>> {
-		public ConstructorState(final Deque<ITree<TokenType>> left, final ITree<TokenType> right) {
-			super(left, right);
-		}
-
-		public ConstructorState(final IPair<Deque<ITree<TokenType>>, ITree<TokenType>> par) {
-			super(par.getLeft(), par.getRight());
-		}
-	}
-
-	/**
-	 * Construct a tree from a list of tokens in postfix notation
-	 *
-	 * Only binary operators are accepted.
-	 *
-	 * @param <TokenType>
-	 *                The elements of the parse tree
-	 * @param tokens
-	 *                The list of tokens to build a tree from
-	 * @param isOperator
-	 *                The predicate to use to determine if something is a
-	 *                operator
-	 * @return A AST from the expression
-	 */
-	public static <TokenType> ITree<TokenType> constructTree(final IList<TokenType> tokens,
-			final Predicate<TokenType> isOperator) {
-		/*
-		 * Construct a tree with no special operators
-		 */
-		return constructTree(tokens, isOperator, op -> false, null);
-	}
-
-	/**
-	 * Construct a tree from a list of tokens in postfix notation.
-	 *
-	 * Only binary operators are accepted by default. Use the last two
-	 * parameters to handle non-binary operators.
-	 *
-	 * @param <TokenType>
-	 *                The elements of the parse tree.
-	 *
-	 * @param tokens
-	 *                The list of tokens to build a tree from.
-	 *
-	 * @param isOperator
-	 *                The predicate to use to determine if something is a
-	 *                operator.
-	 *
-	 * @param isSpecialOperator
-	 *                The predicate to use to determine if an operator needs
-	 *                special handling.
-	 *
-	 * @param handleSpecialOperator
-	 *                The function to use to handle special case operators.
-	 *
-	 * @return A AST from the expression
-	 *
-	 */
-	public static <TokenType> ITree<TokenType> constructTree(final IList<TokenType> tokens,
-			final Predicate<TokenType> isOperator, final Predicate<TokenType> isSpecialOperator,
-			final Function<TokenType, QueueFlattener<TokenType>> handleSpecialOperator) {
-		/*
-		 * Make sure our parameters are valid
-		 */
-		if (tokens == null)
-			throw new NullPointerException("Tokens must not be null");
-		else if (isOperator == null)
-			throw new NullPointerException("Operator predicate must not be null");
-		else if (isSpecialOperator == null)
-			throw new NullPointerException("Special operator determiner must not be null");
-
-		/*
-		 * Here is the state for the tree construction
-		 */
-		final IHolder<ConstructorState<TokenType>> initialState = new Identity<>(
-				new ConstructorState<>(new LinkedList<>(), null));
-
-		/*
-		 * Transform each of the tokens
-		 */
-		tokens.forEach(new TokenTransformer<>(initialState, isOperator, isSpecialOperator,
-				handleSpecialOperator));
-
-		/*
-		 * Grab the tree from the state
-		 */
-		return initialState.unwrap(pair -> {
-			return pair.getRight();
-		});
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/IteratedDefine.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/IteratedDefine.java
deleted file mode 100644
index 552b471..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/IteratedDefine.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package bjc.utils.parserutils.defines;
-
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.function.UnaryOperator;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import bjc.utils.data.CircularIterator;
-
-public class IteratedDefine implements UnaryOperator<String> {
-	private Pattern patt;
-
-	private Iterator<String> repls;
-
-	/**
-	 * Create a new iterated define.
-	 *
-	 * @param pattern
-	 * 	The pattern to use for matching.
-	 * @param circular
-	 * 	Whether or not to loop through the list of replacers, or just
-	 * 	repeat the last one.
-	 * @param replacers
-	 * 	The set of replacers to use.
-	 */
-	public IteratedDefine(Pattern pattern, boolean circular, String... replacers) {
-		patt = pattern;
-
-		repls = new CircularIterator<>(Arrays.asList(replacers), circular);
-	}
-
-	@Override
-	public String apply(String ln) {
-		Matcher mat     = patt.matcher(ln);
-		StringBuffer sb = new StringBuffer();
-
-		while(mat.find()) {
-			String repl = repls.next();
-
-			mat.appendReplacement(sb, repl);
-		}
-
-		mat.appendTail(sb);
-
-		return sb.toString();
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/SimpleDefine.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/SimpleDefine.java
deleted file mode 100644
index 42866c2..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/defines/SimpleDefine.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package bjc.utils.parserutils.defines;
-
-import java.util.function.UnaryOperator;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class SimpleDefine implements UnaryOperator<String> {
-	private Pattern patt;
-	private String  repl;
-
-	public SimpleDefine(Pattern pattern, String replace) {
-		patt = pattern;
-
-		repl = replace;
-	}
-
-	@Override
-	public String apply(String line) {
-		Matcher mat = patt.matcher(line);
-
-		return mat.replaceAll(repl);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java
deleted file mode 100644
index 071afb4..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterException.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-/**
- * The superclass for exceptions thrown during sequence delimitation.
- */
-public class DelimiterException extends RuntimeException {
-	/**
-	 *
-	 */
-	private static final long serialVersionUID = 2079514406049040888L;
-
-	/**
-	 * Create a new generic delimiter exception.
-	 *
-	 * @param res
-	 *                The reason for this exception.
-	 */
-	public DelimiterException(final String res) {
-		super(res);
-	}
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java
deleted file mode 100644
index b1d8597..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/DelimiterGroup.java
+++ /dev/null
@@ -1,593 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-import java.util.Arrays;
-import java.util.Deque;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.BiPredicate;
-import java.util.function.Function;
-
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Pair;
-import bjc.utils.data.Tree;
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-
-/**
- * Represents a possible delimiter group to match.
- *
- * @author EVE
- *
- * @param <T>
- *                The type of items in the sequence.
- */
-public class DelimiterGroup<T> {
-	/**
-	 * Represents an instance of a delimiter group.
-	 *
-	 * @author EVE
-	 *
-	 */
-	public class OpenGroup {
-		/*
-		 * The contents of this group.
-		 */
-		private final Deque<ITree<T>> contents;
-
-		/*
-		 * The contents of the current subgroup.
-		 */
-		private IList<ITree<T>> currentGroup;
-
-		/*
-		 * The token that opened the group, and any opening parameters.
-		 */
-		private final T opener;
-		private final T[] params;
-
-		/**
-		 * Create a new instance of a delimiter group.
-		 *
-		 * @param open
-		 *                The item that opened this group.
-		 *
-		 * @param parms
-		 *                Any parameters from the opener.
-		 */
-		public OpenGroup(final T open, final T[] parms) {
-			opener = open;
-			params = parms;
-
-			contents = new LinkedList<>();
-
-			currentGroup = new FunctionalList<>();
-		}
-
-		/**
-		 * Add an item to this group instance.
-		 *
-		 * @param itm
-		 *                The item to add to this group instance.
-		 */
-		public void addItem(final ITree<T> itm) {
-			currentGroup.add(itm);
-		}
-
-		/**
-		 * Mark a subgroup.
-		 *
-		 * @param marker
-		 *                The item that indicated this subgroup.
-		 *
-		 * @param chars
-		 *                The characteristics for building the tree.
-		 */
-		public void markSubgroup(final T marker, final SequenceCharacteristics<T> chars) {
-			/*
-			 * Add all of the contents to the subgroup.
-			 */
-			final ITree<T> subgroupContents = new Tree<>(chars.contents);
-			for (final ITree<T> itm : currentGroup) {
-				subgroupContents.addChild(itm);
-			}
-
-			/*
-			 * Handle subordinate sub-groups.
-			 */
-			while (!contents.isEmpty()) {
-				final ITree<T> possibleSubordinate = contents.peek();
-
-				/*
-				 * Subordinate lower priority subgroups.
-				 */
-				if (possibleSubordinate.getHead().equals(chars.subgroup)) {
-					final T otherMarker = possibleSubordinate.getChild(1).getHead();
-
-					if (subgroups.get(marker) > subgroups.get(otherMarker)) {
-						subgroupContents.prependChild(contents.pop());
-					} else {
-						break;
-					}
-				} else {
-					subgroupContents.prependChild(contents.pop());
-				}
-			}
-
-			final Tree<T> subgroup = new Tree<>(chars.subgroup, subgroupContents, new Tree<>(marker));
-
-			contents.push(subgroup);
-
-			currentGroup = new FunctionalList<>();
-		}
-
-		/**
-		 * Convert this group into a tree.
-		 *
-		 * @param closer
-		 *                The item that closed this group.
-		 *
-		 * @param chars
-		 *                The characteristics for building the tree.
-		 *
-		 * @return This group as a tree.
-		 */
-		public ITree<T> toTree(final T closer, final SequenceCharacteristics<T> chars) {
-			/*
-			 * Mark any implied subgroups.
-			 */
-			if (impliedSubgroups.containsKey(closer)) {
-				markSubgroup(impliedSubgroups.get(closer), chars);
-			}
-
-			final ITree<T> res = new Tree<>(chars.contents);
-
-			/*
-			 * Add either the contents of the current group,
-			 * or subgroups if they're their.
-			 */
-			if (contents.isEmpty()) {
-				currentGroup.forEach(res::addChild);
-			} else {
-				while (!contents.isEmpty()) {
-					res.prependChild(contents.poll());
-				}
-
-				currentGroup.forEach(res::addChild);
-			}
-
-			return new Tree<>(groupName, new Tree<>(opener), res, new Tree<>(closer));
-		}
-
-		@Override
-		public String toString() {
-			final StringBuilder builder = new StringBuilder();
-
-			builder.append("OpenGroup [contents=");
-			builder.append(contents);
-			builder.append(", currentGroup=");
-			builder.append(currentGroup);
-			builder.append(", opener=");
-			builder.append(opener);
-			builder.append("]");
-
-			return builder.toString();
-		}
-
-		/**
-		 * Check if a group is excluded at the top level of this group.
-		 *
-		 * @param groupName
-		 *                The group to check.
-		 *
-		 * @return Whether or not the provided group is excluded.
-		 */
-		public boolean excludes(final T groupName) {
-			return topLevelExclusions.contains(groupName);
-		}
-
-		/**
-		 * Check if the provided delimiter would close this group.
-		 *
-		 * @param del
-		 *                The string to check as a closing delimiter.
-		 *
-		 * @return Whether or not the provided delimiter closes this
-		 *         group.
-		 */
-		public boolean isClosing(final T del) {
-			if (closingDelimiters.contains(del)) return true;
-
-			for (final BiPredicate<T, T[]> pred : predClosers) {
-				if (pred.test(del, params)) return true;
-			}
-
-			return closingDelimiters.contains(del);
-		}
-
-		/**
-		 * Get the name of the group this is an instance of.
-		 *
-		 * @return The name of the group this is an instance of.
-		 */
-		public T getName() {
-			return groupName;
-		}
-
-		/**
-		 * Get the groups that aren't allowed at all in this group.
-		 *
-		 * @return The groups that aren't allowed at all in this group.
-		 */
-		public Set<T> getNestingExclusions() {
-			return groupExclusions;
-		}
-
-		/**
-		 * Get the groups that are allowed to open anywhere inside this
-		 * group.
-		 *
-		 * @return The groups allowed to open anywhere inside this
-		 *         group.
-		 */
-		public Map<T, T> getNestingOpeners() {
-			return nestedOpenDelimiters;
-		}
-
-		/**
-		 * Checks if a given token marks a subgroup.
-		 *
-		 * @param tok
-		 *                The token to check.
-		 *
-		 * @return Whether or not the token marks a subgroup.
-		 */
-		public boolean marksSubgroup(final T tok) {
-			return subgroups.containsKey(tok);
-		}
-
-		/**
-		 * Checks if a given token opens a group.
-		 *
-		 * @param marker
-		 *                The token to check.
-		 *
-		 * @return The name of the group T opens, or null if it doesn't
-		 *         open one.
-		 */
-		public IPair<T, T[]> doesOpen(final T marker) {
-			if (openDelimiters.containsKey(marker)) return new Pair<>(openDelimiters.get(marker), null);
-
-			for (final Function<T, IPair<T, T[]>> pred : predOpeners) {
-				final IPair<T, T[]> par = pred.apply(marker);
-
-				if (par.getLeft() != null) return par;
-			}
-
-			return new Pair<>(null, null);
-		}
-
-		/**
-		 * Check if this group starts a new nesting scope.
-		 *
-		 * @return Whether this group starts a new nesting scope.
-		 */
-		public boolean isForgetful() {
-			return forgetful;
-		}
-	}
-
-	/**
-	 * The name of this delimiter group.
-	 */
-	public final T groupName;
-
-	/*
-	 * The delimiters that open groups at the top level of this group.
-	 */
-	private final Map<T, T> openDelimiters;
-
-	/*
-	 * The delimiters that open groups inside of this group.
-	 */
-	private final Map<T, T> nestedOpenDelimiters;
-
-	/*
-	 * The delimiters that close this group.
-	 */
-	private final Set<T> closingDelimiters;
-
-	/*
-	 * The groups that can't occur in the top level of this group.
-	 */
-	private final Set<T> topLevelExclusions;
-
-	/*
-	 * The groups that can't occur anywhere inside this group.
-	 */
-	private final Set<T> groupExclusions;
-
-	/*
-	 * Mapping from sub-group delimiters, to any sub-groups enclosed in
-	 * them.
-	 */
-	private final Map<T, Integer> subgroups;
-
-	/*
-	 * Subgroups implied by a particular closing delimiter
-	 */
-	private final Map<T, T> impliedSubgroups;
-
-	/*
-	 * Allows more complex openings
-	 */
-	private final List<Function<T, IPair<T, T[]>>> predOpeners;
-
-	/*
-	 * Allow more complex closings
-	 */
-	private final List<BiPredicate<T, T[]>> predClosers;
-
-	/*
-	 * Whether or not this group starts a new nesting set.
-	 */
-	private boolean forgetful;
-
-	/**
-	 * Create a new empty delimiter group.
-	 *
-	 * @param name
-	 *                The name of the delimiter group
-	 */
-	public DelimiterGroup(final T name) {
-		if (name == null) throw new NullPointerException("Group name must not be null");
-
-		groupName = name;
-
-		openDelimiters = new HashMap<>();
-		nestedOpenDelimiters = new HashMap<>();
-
-		closingDelimiters = new HashSet<>();
-
-		topLevelExclusions = new HashSet<>();
-		groupExclusions = new HashSet<>();
-
-		subgroups = new HashMap<>();
-		impliedSubgroups = new HashMap<>();
-
-		predOpeners = new LinkedList<>();
-		predClosers = new LinkedList<>();
-	}
-
-	/**
-	 * Adds one or more delimiters that close this group.
-	 *
-	 * @param closers
-	 *                Delimiters that close this group.
-	 */
-	@SafeVarargs
-	public final void addClosing(final T... closers) {
-		final List<T> closerList = Arrays.asList(closers);
-
-		for (final T closer : closerList) {
-			if (closer == null)
-				throw new NullPointerException("Closing delimiter must not be null");
-			else if (closer.equals(""))
-				/*
-				 * We can do this because equals works on
-				 * arbitrary objects, not just those of the same
-				 * type.
-				 */
-				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			else {
-				closingDelimiters.add(closer);
-			}
-		}
-	}
-
-	/**
-	 * Adds one or more groups that cannot occur in the top level of this
-	 * group.
-	 *
-	 * @param exclusions
-	 *                The groups forbidden in the top level of this group.
-	 */
-	@SafeVarargs
-	public final void addTopLevelForbid(final T... exclusions) {
-		for (final T exclusion : exclusions) {
-			if (exclusion == null)
-				throw new NullPointerException("Exclusion must not be null");
-			else if (exclusion.equals(""))
-				/*
-				 * We can do this because equals works on
-				 * arbitrary objects, not just those of the same
-				 * type.
-				 */
-				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			else {
-				topLevelExclusions.add(exclusion);
-			}
-		}
-	}
-
-	/**
-	 * Adds one or more groups that cannot occur at all in this group.
-	 *
-	 * @param exclusions
-	 *                The groups forbidden inside this group.
-	 */
-	@SafeVarargs
-	public final void addGroupForbid(final T... exclusions) {
-		for (final T exclusion : exclusions) {
-			if (exclusion == null)
-				throw new NullPointerException("Exclusion must not be null");
-			else if (exclusion.equals(""))
-				/*
-				 * We can do this because equals works on
-				 * arbitrary objects, not just those of the same
-				 * type.
-				 */
-				throw new IllegalArgumentException("Empty string is not a valid exclusion");
-			else {
-				groupExclusions.add(exclusion);
-			}
-		}
-	}
-
-	/**
-	 * Adds sub-group markers to this group.
-	 *
-	 * @param subgroup
-	 *                The token to mark a sub-group.
-	 *
-	 * @param priority
-	 *                The priority of this sub-group.
-	 */
-	public void addSubgroup(final T subgroup, final int priority) {
-		if (subgroup == null) throw new NullPointerException("Subgroup marker must not be null");
-
-		subgroups.put(subgroup, priority);
-	}
-
-	/**
-	 * Adds a marker that opens a group at the top level of this group.
-	 *
-	 * @param opener
-	 *                The marker that opens the group.
-	 *
-	 * @param group
-	 *                The group opened by the marker.
-	 */
-	public void addOpener(final T opener, final T group) {
-		if (opener == null)     throw new NullPointerException("Opener must not be null");
-		else if (group == null) throw new NullPointerException("Group to open must not be null");
-
-		openDelimiters.put(opener, group);
-	}
-
-	/**
-	 * Adds a marker that opens a group inside of this group.
-	 *
-	 * @param opener
-	 *                The marker that opens the group.
-	 *
-	 * @param group
-	 *                The group opened by the marker.
-	 */
-	public void addNestedOpener(final T opener, final T group) {
-		if (opener == null)     throw new NullPointerException("Opener must not be null");
-		else if (group == null) throw new NullPointerException("Group to open must not be null");
-
-		nestedOpenDelimiters.put(opener, group);
-	}
-
-	/**
-	 * Mark a closing delimiter as implying a subgroup.
-	 *
-	 * @param closer
-	 *                The closing delimiter.
-	 *
-	 * @param subgroup
-	 *                The subgroup to imply.
-	 */
-	public void implySubgroup(final T closer, final T subgroup) {
-		if      (closer == null)                      throw new NullPointerException("Closer must not be null");
-		else if (subgroup == null)                    throw new NullPointerException("Subgroup must not be null");
-		else if (!closingDelimiters.contains(closer)) throw new IllegalArgumentException(String.format("No closing delimiter '%s' defined", closer));
-		else if (!subgroups.containsKey(subgroup))    throw new IllegalArgumentException(String.format("No subgroup '%s' defined", subgroup));
-
-		impliedSubgroups.put(closer, subgroup);
-	}
-
-	@Override
-	public String toString() {
-		final StringBuilder builder = new StringBuilder();
-
-		builder.append("(");
-
-		builder.append("groupName=[");
-		builder.append(groupName);
-		builder.append("], ");
-
-		builder.append("closingDelimiters=[");
-		for (final T closer : closingDelimiters) {
-			builder.append(closer + ",");
-		}
-		builder.deleteCharAt(builder.length() - 1);
-		builder.append("]");
-
-		if (topLevelExclusions != null && !topLevelExclusions.isEmpty()) {
-			builder.append(", ");
-			builder.append("topLevelExclusions=[");
-			for (final T exclusion : topLevelExclusions) {
-				builder.append(exclusion + ",");
-			}
-			builder.deleteCharAt(builder.length() - 1);
-			builder.append("]");
-		}
-
-		if (groupExclusions != null && !groupExclusions.isEmpty()) {
-			builder.append(", ");
-			builder.append("groupExclusions=[");
-			for (final T exclusion : groupExclusions) {
-				builder.append(exclusion + ",");
-			}
-			builder.deleteCharAt(builder.length() - 1);
-			builder.append("]");
-		}
-
-		builder.append(" )");
-
-		return builder.toString();
-	}
-
-	/**
-	 * Open an instance of this group.
-	 *
-	 * @param opener
-	 *                The item that opened this group.
-	 *
-	 * @param parms
-	 *                The parameters that opened this group
-	 *
-	 * @return An opened instance of this group.
-	 */
-	public OpenGroup open(final T opener, final T[] parms) {
-		return new OpenGroup(opener, parms);
-	}
-
-	/**
-	 * Adds a predicated opener to the top level of this group.
-	 *
-	 * @param pred
-	 *                The predicate that defines the opener and its
-	 *                parameters.
-	 */
-	public void addPredOpener(final Function<T, IPair<T, T[]>> pred) {
-		predOpeners.add(pred);
-	}
-
-	/**
-	 * Adds a predicated closer to the top level of this group.
-	 *
-	 * @param pred
-	 *                The predicate that defines the closer.
-	 */
-	public void addPredCloser(final BiPredicate<T, T[]> pred) {
-		predClosers.add(pred);
-	}
-
-	/**
-	 * Set whether or not this group starts a new nesting set.
-	 *
-	 * @param forgetful
-	 *                Whether this group starts a new nesting set.
-	 */
-	public void setForgetful(final boolean forgetful) {
-		this.forgetful = forgetful;
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java
deleted file mode 100644
index 4b29949..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexCloser.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-import java.util.function.BiPredicate;
-
-/**
- * A predicated closer for use with {@link RegexOpener}.
- *
- * @author bjculkin
- *
- */
-public class RegexCloser implements BiPredicate<String, String[]> {
-	private final String rep;
-
-	/**
-	 * Create a new regex closer.
-	 *
-	 * @param closer
-	 *                The format string to use for closing.
-	 */
-	public RegexCloser(final String closer) {
-		rep = closer;
-	}
-
-	@Override
-	public boolean test(final String closer, final String[] params) {
-		/*
-		 * Confirm passing an array instead of a single var-arg.
-		 */
-		final String work = String.format(rep, (Object[]) params);
-
-		return work.equals(closer);
-	}
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java
deleted file mode 100644
index ee93b73..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/RegexOpener.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-import java.util.function.Function;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import bjc.utils.data.IPair;
-import bjc.utils.data.Pair;
-
-/**
- * A predicated opener for use with {@link RegexCloser}
- *
- * @author bjculkin
- *
- */
-public class RegexOpener implements Function<String, IPair<String, String[]>> {
-	private final String name;
-
-	private final Pattern patt;
-
-	/**
-	 * Create a new regex opener.
-	 *
-	 * @param groupName
-	 *                The name of the opened group.
-	 *
-	 * @param groupRegex
-	 *                The regex that matches the opener.
-	 */
-	public RegexOpener(final String groupName, final String groupRegex) {
-		name = groupName;
-
-		patt = Pattern.compile(groupRegex);
-	}
-
-	@Override
-	public IPair<String, String[]> apply(final String str) {
-		final Matcher m = patt.matcher(str);
-
-		if (m.matches()) {
-			final int numGroups = m.groupCount();
-
-			final String[] parms = new String[numGroups + 1];
-
-			for (int i = 0; i <= numGroups; i++) {
-				parms[i] = m.group(i);
-			}
-
-			return new Pair<>(name, parms);
-		}
-
-		return new Pair<>(null, null);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java
deleted file mode 100644
index 882b4c5..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceCharacteristics.java
+++ /dev/null
@@ -1,93 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-/**
- * Marks the parameters for building a sequence tree.
- *
- * @author EVE
- *
- * @param <T>
- *                The type of item in the tree.
- */
-public class SequenceCharacteristics<T> {
-	/**
-	 * The item to mark the root of the tree.
-	 */
-	public final T root;
-
-	/**
-	 * The item to mark the contents of a group/subgroup.
-	 */
-
-	public final T contents;
-
-	/**
-	 * The item to mark a subgroup.
-	 */
-	public final T subgroup;
-
-	/**
-	 * Create a new set of parameters for building a tree.
-	 *
-	 * @param root
-	 *                The root marker.
-	 * @param contents
-	 *                The group/subgroup contents marker.
-	 * @param subgroup
-	 *                The subgroup marker.
-	 */
-	public SequenceCharacteristics(final T root, final T contents, final T subgroup) {
-		this.root = root;
-		this.contents = contents;
-		this.subgroup = subgroup;
-	}
-
-	@Override
-	public int hashCode() {
-		final int prime = 31;
-		int result = 1;
-
-		result = prime * result + (contents == null ? 0 : contents.hashCode());
-		result = prime * result + (root == null ? 0 : root.hashCode());
-		result = prime * result + (subgroup == null ? 0 : subgroup.hashCode());
-
-		return result;
-	}
-
-	@Override
-	public boolean equals(final Object obj) {
-		if (this == obj) return true;
-		if (obj == null) return false;
-		if (!(obj instanceof SequenceCharacteristics)) return false;
-
-		final SequenceCharacteristics<?> other = (SequenceCharacteristics<?>) obj;
-
-		if (contents == null) {
-			if (other.contents != null) return false;
-		} else if (!contents.equals(other.contents)) return false;
-
-		if (root == null) {
-			if (other.root != null) return false;
-		} else if (!root.equals(other.root)) return false;
-
-		if (subgroup == null) {
-			if (other.subgroup != null) return false;
-		} else if (!subgroup.equals(other.subgroup)) return false;
-
-		return true;
-	}
-
-	@Override
-	public String toString() {
-		final StringBuilder builder = new StringBuilder();
-
-		builder.append("SequenceCharacteristics [root=");
-		builder.append(root == null ? "(null)" : root);
-		builder.append(", contents=");
-		builder.append(contents == null ? "(null)" : contents);
-		builder.append(", subgroup=");
-		builder.append(subgroup == null ? "(null)" : subgroup);
-		builder.append("]");
-
-		return builder.toString();
-	}
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java
deleted file mode 100644
index ccfaffb..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/SequenceDelimiter.java
+++ /dev/null
@@ -1,371 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.HashMultiset;
-import com.google.common.collect.Multimap;
-import com.google.common.collect.Multiset;
-
-import bjc.utils.data.IPair;
-import bjc.utils.data.ITree;
-import bjc.utils.data.Tree;
-import bjc.utils.esodata.PushdownMap;
-import bjc.utils.esodata.SimpleStack;
-import bjc.utils.esodata.Stack;
-import bjc.utils.funcdata.IMap;
-import bjc.utils.funcutils.StringUtils;
-
-/**
- * Convert linear sequences into trees that represent group structure.
- *
- * @author EVE
- *
- * @param <T>
- *                The type of items in the sequence.
- */
-public class SequenceDelimiter<T> {
-	/*
-	 * Mapping from group names to actual groups.
-	 */
-	private final Map<T, DelimiterGroup<T>> groups;
-
-	/*
-	 * The initial group to start with.
-	 */
-	private DelimiterGroup<T> initialGroup;
-
-	/**
-	 * Create a new sequence delimiter.
-	 */
-	public SequenceDelimiter() {
-		groups = new HashMap<>();
-	}
-
-	/**
-	 * Convert a linear sequence into a tree that matches the delimiter
-	 * structure.
-	 *
-	 * Essentially, creates a parse tree of the expression against the
-	 * following grammar while obeying the defined grouping rules.
-	 *
-	 * <pre>
-	 *         <tree>     → (<data> | <subgroup> | <group>)*
-	 *         <subgroup> → <tree> <marker>
-	 *         <group>    → <open> <tree> <close>
-	 *
-	 *         <data>     → STRING
-	 *         <open>     → STRING
-	 *         <close>    → STRING
-	 *         <marker>   → STRING
-	 * </pre>
-	 *
-	 * @param chars
-	 *                The parameters on how to mark certain portions of the
-	 *                tree.
-	 * @param seq
-	 *                The sequence to delimit.
-	 *
-	 * @return The sequence as a tree that matches its group structure. Each
-	 *         node in the tree is either a data node, a subgroup node, or a
-	 *         group node.
-	 *
-	 *         A data node is a leaf node whose data is the string it
-	 *         represents.
-	 *
-	 *         A subgroup node is a node with two children, and the name of
-	 *         the sub-group as its label. The first child is the contents
-	 *         of the sub-group, and the second is the marker that started
-	 *         the subgroup. The marker is a leaf node labeled with its
-	 *         contents, and the contents contains a recursive tree.
-	 *
-	 *         A group node is a node with three children, and the name of
-	 *         the group as its label. The first child is the opening
-	 *         delimiter, the second is the group contents, and the third is
-	 *         the closing delimiter. The delimiters are leaf nodes labeled
-	 *         with their contents, while the group node contains a
-	 *         recursive tree.
-	 *
-	 * @throws DelimiterException
-	 *                 Thrown if something went wrong during sequence
-	 *                 delimitation.
-	 *
-	 */
-	public ITree<T> delimitSequence(final SequenceCharacteristics<T> chars,
-			@SuppressWarnings("unchecked") final T... seq) throws DelimiterException {
-		if (initialGroup == null) throw new NullPointerException("Initial group must be specified.");
-		else if (chars == null)   throw new NullPointerException("Sequence characteristics must not be null");
-
-		/*
-		 * The stack of opened and not yet closed groups.
-		 */
-		final Stack<DelimiterGroup<T>.OpenGroup> groupStack = new SimpleStack<>();
-
-		/*
-		 * Open initial group.
-		 */
-		groupStack.push(initialGroup.open(chars.root, null));
-
-		/*
-		 * Groups that aren't allowed to be opened at the moment.
-		 */
-		final Stack<Multiset<T>> forbiddenDelimiters = new SimpleStack<>();
-		forbiddenDelimiters.push(HashMultiset.create());
-
-		/*
-		 * Groups that are allowed to be opened at the moment.
-		 */
-		final Stack<Multimap<T, T>> allowedDelimiters = new SimpleStack<>();
-		allowedDelimiters.push(HashMultimap.create());
-
-		/*
-		 * Map of who forbid what for debugging purposes.
-		 */
-		final IMap<T, T> whoForbid = new PushdownMap<>();
-
-		/*
-		 * Process each member of the sequence.
-		 */
-		for (int i = 0; i < seq.length; i++) {
-			final T tok = seq[i];
-
-			/*
-			 * Check if this token could open a group.
-			 */
-			final IPair<T, T[]> possibleOpenPar = groupStack.top().doesOpen(tok);
-			T possibleOpen = possibleOpenPar.getLeft();
-
-			if (possibleOpen == null) {
-				/*
-				 * Handle nested openers.
-				 *
-				 * Local openers take priority over nested ones
-				 * if they overlap.
-				 */
-				if (allowedDelimiters.top().containsKey(tok)) {
-					possibleOpen = allowedDelimiters.top().get(tok).iterator().next();
-				}
-			}
-
-			/*
-			 * If we have an opening delimiter, handle it.
-			 */
-			if (possibleOpen != null) {
-				final DelimiterGroup<T> group = groups.get(possibleOpen);
-
-				/*
-				 * Error on groups that can't open in this
-				 * context.
-				 *
-				 * This means groups that can't occur at the
-				 * top-level of this group, as well as nested
-				 * exclusions from all enclosing groups.
-				 */
-				if (isForbidden(groupStack, forbiddenDelimiters, possibleOpen)) {
-					T forbiddenBy;
-
-					if (whoForbid.containsKey(tok)) {
-						forbiddenBy = whoForbid.get(tok);
-					} else {
-						forbiddenBy = groupStack.top().getName();
-					}
-
-					final String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
-
-					final String fmt = "Group '%s' can't be opened in this context. (forbidden by '%s')\nContext Stack: %s";
-
-					throw new DelimiterException(String.format(fmt, group, forbiddenBy, ctxList));
-				}
-
-				/*
-				 * Add an open group.
-				 */
-				final DelimiterGroup<T>.OpenGroup open = group.open(tok, possibleOpenPar.getRight());
-				groupStack.push(open);
-
-				/*
-				 * Handle 'forgetful' groups that reset nesting
-				 */
-				if (open.isForgetful()) {
-					allowedDelimiters.push(HashMultimap.create());
-					forbiddenDelimiters.push(HashMultiset.create());
-				}
-
-				/*
-				 * Add the nested opens from this group.
-				 */
-				final Multimap<T, T> currentAllowed = allowedDelimiters.top();
-				for (final Entry<T, T> opener : open.getNestingOpeners().entrySet()) {
-					currentAllowed.put(opener.getKey(), opener.getValue());
-				}
-
-				/*
-				 * Add the nested exclusions from this group
-				 */
-				final Multiset<T> currentForbidden = forbiddenDelimiters.top();
-				for (final T exclusion : open.getNestingExclusions()) {
-					currentForbidden.add(exclusion);
-
-					whoForbid.put(exclusion, possibleOpen);
-				}
-			} else if (!groupStack.empty() && groupStack.top().isClosing(tok)) {
-				/*
-				 * Close the group.
-				 */
-				final DelimiterGroup<T>.OpenGroup closed = groupStack.pop();
-
-				groupStack.top().addItem(closed.toTree(tok, chars));
-
-				/*
-				 * Remove nested exclusions from this group.
-				 */
-				final Multiset<T> currentForbidden = forbiddenDelimiters.top();
-				for (final T excludedGroup : closed.getNestingExclusions()) {
-					currentForbidden.remove(excludedGroup);
-
-					whoForbid.remove(excludedGroup);
-				}
-
-				/*
-				 * Remove the nested opens from this group.
-				 */
-				final Multimap<T, T> currentAllowed = allowedDelimiters.top();
-				for (final Entry<T, T> closer : closed.getNestingOpeners().entrySet()) {
-					currentAllowed.remove(closer.getKey(), closer.getValue());
-				}
-
-				/*
-				 * Handle 'forgetful' groups that reset nesting.
-				 */
-				if (closed.isForgetful()) {
-					allowedDelimiters.drop();
-					forbiddenDelimiters.drop();
-				}
-			} else if (!groupStack.empty() && groupStack.top().marksSubgroup(tok)) {
-				/*
-				 * Mark a subgroup.
-				 */
-				groupStack.top().markSubgroup(tok, chars);
-			} else {
-				/*
-				 * Add an item to the group.
-				 */
-				groupStack.top().addItem(new Tree<>(tok));
-			}
-		}
-
-		/*
-		 * Error if not all groups were closed.
-		 */
-		if (groupStack.size() > 1) {
-			final DelimiterGroup<T>.OpenGroup group = groupStack.top();
-
-			final StringBuilder msgBuilder = new StringBuilder();
-
-			final String closingDelims = StringUtils.toEnglishList(group.getNestingExclusions().toArray(),
-					false);
-
-			final String ctxList = StringUtils.toEnglishList(groupStack.toArray(), "then");
-
-			msgBuilder.append("Unclosed group '");
-			msgBuilder.append(group.getName());
-			msgBuilder.append("'. Expected one of ");
-			msgBuilder.append(closingDelims);
-			msgBuilder.append(" to close it\nOpen groups: ");
-			msgBuilder.append(ctxList);
-
-			final String fmt = "Unclosed group '%s'. Expected one of %s to close it.\nOpen groups: %n";
-
-			throw new DelimiterException(String.format(fmt, group.getName(), closingDelims, ctxList));
-		}
-
-		return groupStack.pop().toTree(chars.root, chars);
-	}
-
-	/*
-	 * Check if a group is forbidden to open in a context.
-	 */
-	private boolean isForbidden(final Stack<DelimiterGroup<T>.OpenGroup> groupStack,
-			final Stack<Multiset<T>> forbiddenDelimiters, final T groupName) {
-		boolean localForbid;
-
-		/*
-		 * Check if a delimiter is locally forbidden.
-		 */
-		if (groupStack.empty()) {
-			localForbid = false;
-		} else {
-			localForbid = groupStack.top().excludes(groupName);
-		}
-
-		return localForbid || forbiddenDelimiters.top().contains(groupName);
-	}
-
-	/**
-	 * Add a delimiter group.
-	 *
-	 * @param group
-	 *                The delimiter group.
-	 */
-	public void addGroup(final DelimiterGroup<T> group) {
-		if (group == null) throw new NullPointerException("Group must not be null");
-
-		groups.put(group.groupName, group);
-	}
-
-	/**
-	 * Creates and adds a delimiter group using the provided settings.
-	 *
-	 * @param openers
-	 *                The tokens that open this group
-	 * @param groupName
-	 *                The name of the group
-	 * @param closers
-	 *                The tokens that close this group
-	 */
-	public void addGroup(final T[] openers, final T groupName, @SuppressWarnings("unchecked") final T... closers) {
-		final DelimiterGroup<T> group = new DelimiterGroup<>(groupName);
-
-		group.addClosing(closers);
-
-		addGroup(group);
-
-		for (final T open : openers) {
-			group.addOpener(open, groupName);
-		}
-	}
-
-	@Override
-	public String toString() {
-		final StringBuilder builder = new StringBuilder();
-
-		builder.append("SequenceDelimiter [");
-
-		if (groups != null) {
-			builder.append("groups=");
-			builder.append(groups);
-			builder.append(",");
-		}
-
-		if (initialGroup != null) {
-			builder.append("initialGroup=");
-			builder.append(initialGroup);
-		}
-
-		builder.append("]");
-
-		return builder.toString();
-	}
-
-	/**
-	 * Set the initial group of this delimiter.
-	 *
-	 * @param initialGroup
-	 *                The initial group of this delimiter.
-	 */
-	public void setInitialGroup(final DelimiterGroup<T> initialGroup) {
-		this.initialGroup = initialGroup;
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java
deleted file mode 100644
index e3eeea5..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/delims/StringDelimiter.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package bjc.utils.parserutils.delims;
-
-import bjc.utils.data.ITree;
-
-/**
- * A sequence delimiter specialized for strings.
- *
- * @author EVE
- *
- */
-public class StringDelimiter extends SequenceDelimiter<String> {
-
-	/**
-	 * Override of
-	 * {@link SequenceDelimiter#delimitSequence(SequenceCharacteristics, Object...)}
-	 * for ease of use for strings.
-	 *
-	 * @param seq
-	 *                The sequence to delimit.
-	 *
-	 * @return The sequence as a tree.
-	 *
-	 * @throws DelimiterException
-	 *                 if something went wrong with delimiting the sequence.
-	 *
-	 * @see SequenceDelimiter
-	 */
-	public ITree<String> delimitSequence(final String... seq) throws DelimiterException {
-		return super.delimitSequence(new SequenceCharacteristics<>("root", "contents", "subgroup"), seq);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ChainTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ChainTokenSplitter.java
deleted file mode 100644
index 4736310..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ChainTokenSplitter.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-
-/**
- * A token splitter that chains several other splitters together.
- *
- * @author EVE
- *
- */
-public class ChainTokenSplitter implements TokenSplitter {
-	private final IList<TokenSplitter> spliters;
-
-	/**
-	 * Create a new chain token splitter.
-	 */
-	public ChainTokenSplitter() {
-		spliters = new FunctionalList<>();
-	}
-
-	/**
-	 * Append a series of splitters to the chain.
-	 *
-	 * @param splitters
-	 *                The splitters to append to the chain.
-	 */
-	public void appendSplitters(final TokenSplitter... splitters) {
-		spliters.addAll(splitters);
-	}
-
-	/**
-	 * Prepend a series of splitters to the chain.
-	 *
-	 * @param splitters
-	 *                The splitters to append to the chain.
-	 */
-	public void prependSplitters(final TokenSplitter... splitters) {
-		spliters.prependAll(splitters);
-	}
-
-	@Override
-	public IList<String> split(final String input) {
-		final IList<String> initList = new FunctionalList<>(input);
-
-		return spliters.reduceAux(initList, (splitter, strangs) -> {
-			return strangs.flatMap(splitter::split);
-		});
-	}
-}
\ No newline at end of file
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ConfigurableTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ConfigurableTokenSplitter.java
deleted file mode 100644
index 48ddcb4..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ConfigurableTokenSplitter.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import static bjc.utils.PropertyDB.applyFormat;
-
-import java.util.LinkedHashSet;
-import java.util.Set;
-import java.util.regex.Pattern;
-
-import bjc.utils.funcdata.IList;
-
-/**
- * Split a string into pieces around a regular expression, and offer an easy way
- * to configure the regular expression.
- *
- * @author EVE
- *
- */
-public class ConfigurableTokenSplitter extends SimpleTokenSplitter {
-	private final Set<String>	simpleDelimiters;
-	private final Set<String>	multipleDelimiters;
-	private final Set<String>	rRawDelimiters;
-
-	/**
-	 * Create a new token splitter with blank configuration.
-	 *
-	 * @param keepDelims
-	 *                Whether or not to keep delimiters.
-	 */
-	public ConfigurableTokenSplitter(final boolean keepDelims) {
-		super(null, keepDelims);
-
-		/*
-		 * Use linked hash-sets to keep items in insertion order.
-		 */
-		simpleDelimiters = new LinkedHashSet<>();
-		multipleDelimiters = new LinkedHashSet<>();
-		rRawDelimiters = new LinkedHashSet<>();
-	}
-
-	/**
-	 * Add a set of simple delimiters to this splitter.
-	 *
-	 * Simple delimiters match one occurrence of themselves as literals.
-	 *
-	 * @param simpleDelims
-	 *                The simple delimiters to add.
-	 */
-	public void addSimpleDelimiters(final String... simpleDelims) {
-		for (final String simpleDelim : simpleDelims) {
-			simpleDelimiters.add(simpleDelim);
-		}
-	}
-
-	/**
-	 * Add a set of multiple delimiters to this splitter.
-	 *
-	 * Multiple delimiters match one or more occurrences of themselves as
-	 * literals.
-	 *
-	 * @param multiDelims
-	 *                The multiple delimiters to add.
-	 */
-	public void addMultiDelimiters(final String... multiDelims) {
-		for (final String multiDelim : multiDelims) {
-			multipleDelimiters.add(multiDelim);
-		}
-	}
-
-	/**
-	 * Add a set of raw delimiters to this splitter.
-	 *
-	 * Raw delimiters match one occurrence of themselves as regular
-	 * expressions.
-	 *
-	 * @param rRawDelims
-	 *                The raw delimiters to add.
-	 */
-	public void addRawDelimiters(final String... rRawDelims) {
-		for (final String rRawDelim : rRawDelims) {
-			rRawDelimiters.add(rRawDelim);
-		}
-	}
-
-	/**
-	 * Take the configuration and compile it into a regular expression to
-	 * use when splitting.
-	 */
-	public void compile() {
-		final StringBuilder rPattern = new StringBuilder();
-
-		for (final String rRawDelimiter : rRawDelimiters) {
-			rPattern.append(applyFormat("rawDelim", rRawDelimiter));
-		}
-
-		for (final String multipleDelimiter : multipleDelimiters) {
-			rPattern.append(applyFormat("multipleDelim", multipleDelimiter));
-		}
-
-		for (final String simpleDelimiter : simpleDelimiters) {
-			rPattern.append(applyFormat("simpleDelim", simpleDelimiter));
-		}
-
-		rPattern.deleteCharAt(rPattern.length() - 1);
-
-		spliter = Pattern.compile(rPattern.toString());
-	}
-
-	@Override
-	public IList<String> split(final String input) {
-		if (spliter == null) throw new IllegalStateException("Must compile splitter before use");
-
-		return super.split(input);
-	}
-
-	@Override
-	public String toString() {
-		final String fmt = "ConfigurableTokenSplitter [simpleDelimiters=%s, multipleDelimiters=%s,"
-				+ " rRawDelimiters=%s, spliter=%s]";
-
-		return String.format(fmt, simpleDelimiters, multipleDelimiters, rRawDelimiters, spliter);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ExcludingTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ExcludingTokenSplitter.java
deleted file mode 100644
index 369e7ae..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/ExcludingTokenSplitter.java
+++ /dev/null
@@ -1,71 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.function.Predicate;
-
-import bjc.utils.funcdata.FunctionalList;
-import bjc.utils.funcdata.IList;
-
-/**
- * A token splitter that will not split certain tokens.
- *
- * @author EVE
- *
- */
-public class ExcludingTokenSplitter implements TokenSplitter {
-	private final Set<String> literalExclusions;
-
-	private final IList<Predicate<String>> predExclusions;
-
-	private final TokenSplitter spliter;
-
-	/**
-	 * Create a new excluding token splitter.
-	 *
-	 * @param splitter
-	 *                The splitter to apply to non-excluded strings.
-	 */
-	public ExcludingTokenSplitter(final TokenSplitter splitter) {
-		spliter = splitter;
-
-		literalExclusions = new HashSet<>();
-
-		predExclusions = new FunctionalList<>();
-	}
-
-	/**
-	 * Exclude literal strings from splitting.
-	 *
-	 * @param exclusions
-	 *                The strings to exclude from splitting.
-	 */
-	public final void addLiteralExclusions(final String... exclusions) {
-		for (final String exclusion : exclusions) {
-			literalExclusions.add(exclusion);
-		}
-	}
-
-	/**
-	 * Exclude all of the strings matching any of the predicates from
-	 * splitting.
-	 *
-	 * @param exclusions
-	 *                The predicates to use for exclusions.
-	 */
-	@SafeVarargs
-	public final void addPredicateExclusion(final Predicate<String>... exclusions) {
-		for (final Predicate<String> exclusion : exclusions) {
-			predExclusions.add(exclusion);
-		}
-	}
-
-	@Override
-	public IList<String> split(final String input) {
-		if (literalExclusions.contains(input))
-			return new FunctionalList<>(input);
-		else if (predExclusions.anyMatch(pred -> pred.test(input)))
-			return new FunctionalList<>(input);
-		else return spliter.split(input);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/FilteredTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/FilteredTokenSplitter.java
deleted file mode 100644
index 5d954e0..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/FilteredTokenSplitter.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import java.util.function.Predicate;
-
-import bjc.utils.funcdata.IList;
-
-/**
- * A token splitter that removes tokens that match a predicate from the stream
- * of tokens.
- * 
- * @author bjculkin
- *
- */
-public class FilteredTokenSplitter implements TokenSplitter {
-	private TokenSplitter source;
-
-	private Predicate<String> filter;
-
-	/**
-	 * Create a new filtered token splitter.
-	 * 
-	 * @param source
-	 *                The splitter to get tokens from.
-	 * 
-	 * @param filter
-	 *                The filter to pass tokens through.
-	 */
-	public FilteredTokenSplitter(TokenSplitter source, Predicate<String> filter) {
-		this.source = source;
-		this.filter = filter;
-	}
-
-	@Override
-	public IList<String> split(String input) {
-		return source.split(input).getMatching(filter);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java
deleted file mode 100644
index c357886..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/SimpleTokenSplitter.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import java.util.regex.Pattern;
-
-import bjc.utils.funcdata.IList;
-import bjc.utils.functypes.ID;
-import bjc.utils.ioutils.RegexStringEditor;
-
-/**
- * Splits a string into pieces around a regular expression.
- *
- * @author EVE
- *
- */
-public class SimpleTokenSplitter implements TokenSplitter {
-	protected Pattern spliter;
-
-	private final boolean keepDelim;
-
-	/**
-	 * Create a new simple token splitter.
-	 *
-	 * @param splitter
-	 *                The pattern to split around.
-	 *
-	 * @param keepDelims
-	 *                Whether or not delimiters should be kept.
-	 */
-	public SimpleTokenSplitter(final Pattern splitter, final boolean keepDelims) {
-		spliter = splitter;
-
-		keepDelim = keepDelims;
-	}
-
-	@Override
-	public IList<String> split(final String input) {
-		if (keepDelim)
-			return RegexStringEditor.mapOccurances(input, spliter, ID.id(), ID.id());
-		else return RegexStringEditor.mapOccurances(input, spliter, ID.id(), strang -> "");
-	}
-
-	@Override
-	public String toString() {
-		return String.format("SimpleTokenSplitter [spliter=%s, keepDelim=%s]", spliter, keepDelim);
-	}
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java
deleted file mode 100644
index ddb28a7..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TokenSplitter.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import bjc.utils.funcdata.IList;
-
-/**
- * Split a string into a list of pieces.
- *
- * @author EVE
- *
- */
-public interface TokenSplitter {
-	/**
-	 * Split a string into a list of pieces.
-	 *
-	 * @param input
-	 *                The string to split.
-	 *
-	 * @return The pieces of the string.
-	 */
-	public IList<String> split(String input);
-}
diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TransformTokenSplitter.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TransformTokenSplitter.java
deleted file mode 100644
index 80490f5..0000000
--- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/splitter/TransformTokenSplitter.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package bjc.utils.parserutils.splitter;
-
-import java.util.function.UnaryOperator;
-
-import bjc.utils.funcdata.IList;
-
-/**
- * A token splitter that performs a transform on the tokens from another
- * splitter.
- * 
- * @author bjculkin
- *
- */
-public class TransformTokenSplitter implements TokenSplitter {
-	private TokenSplitter source;
-
-	private UnaryOperator<String> transform;
-
-	/**
-	 * Create a new transforming splitter.
-	 * 
-	 * @param source
-	 *                The splitter to use as a source.
-	 * 
-	 * @param transform
-	 *                The transform to apply to tokens.
-	 */
-	public TransformTokenSplitter(TokenSplitter source, UnaryOperator<String> transform) {
-		this.source = source;
-		this.transform = transform;
-	}
-
-	@Override
-	public IList<String> split(String input) {
-		return source.split(input).map(transform);
-	}
-
-}