Large update

A large update, this contains much debugging of the CL FORMAT routines,
as well as a few other minor changes.

13 files changed, 522 insertions, 186 deletions

diff --git a/base/src/main/java/bjc/utils/ioutils/format/CLFormatter.java b/base/src/main/java/bjc/utils/ioutils/format/CLFormatter.java
index 1605a75..9e01ca6 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/CLFormatter.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/CLFormatter.java
@@ -24,33 +24,33 @@ import static bjc.utils.misc.PropertyDB.getRegex;
  *
  */
 public class CLFormatter {
-	private static final String prefixParam = getRegex("clFormatPrefix");
-
-	private static final String formatMod = getRegex("clFormatModifier");
-
-	private static final String prefixList = applyFormat("delimSeparatedList", prefixParam, ",");
-
+	private static final String prefixParam   = getRegex("clFormatPrefix");
+	private static final String formatMod     = getRegex("clFormatModifier");
 	private static final String directiveName = getRegex("clFormatName");
 
-	private static final String formatDirective = applyFormat("clFormatDirective", prefixList, formatMod,
-			directiveName);
+	private static final String prefixList      = applyFormat("delimSeparatedList", prefixParam, ",");
+	private static final String formatDirective = applyFormat("clFormatDirective", prefixList, formatMod, directiveName);
+
 	private static final Pattern pFormatDirective = Pattern.compile(formatDirective);
 
 	private static Map<String, Directive> builtinDirectives;
-
-	private Map<String, Directive> extraDirectives;
+	private        Map<String, Directive> extraDirectives;
 
 	static {
 		builtinDirectives = new HashMap<>();
 
 		builtinDirectives.put("A", new AestheticDirective());
+		// @NOTE 9/6/18
+		//
+		// This is just an alias, not the actual S directive
+		builtinDirectives.put("S", new AestheticDirective());
 
 		builtinDirectives.put("C", new CharacterDirective());
 
-		builtinDirectives.put("B", new NumberDirective(-1, 2));
-		builtinDirectives.put("O", new NumberDirective(-1, 8));
-		builtinDirectives.put("D", new NumberDirective(-1, 10));
-		builtinDirectives.put("X", new NumberDirective(-1, 16));
+		builtinDirectives.put("B", new NumberDirective(-1, 2,  'B'));
+		builtinDirectives.put("O", new NumberDirective(-1, 8,  'O'));
+		builtinDirectives.put("D", new NumberDirective(-1, 10, 'D'));
+		builtinDirectives.put("X", new NumberDirective(-1, 16, 'X'));
 
 		builtinDirectives.put("R", new RadixDirective());
 
@@ -58,13 +58,15 @@ public class CLFormatter {
 
 		builtinDirectives.put("%", new LiteralDirective("\n", '%'));
 		builtinDirectives.put("|", new LiteralDirective("\f", '|'));
-		builtinDirectives.put("~", new LiteralDirective("~", '~'));
+		builtinDirectives.put("~", new LiteralDirective("~",  '~'));
+		builtinDirectives.put("?", new RecursiveDirective());
 
 		builtinDirectives.put("*", new GotoDirective());
 
 		builtinDirectives.put("^", new EscapeDirective());
 		builtinDirectives.put("[", new ConditionalDirective());
 		builtinDirectives.put("{", new IterationDirective());
+		builtinDirectives.put("(", new CaseDirective());
 
 		builtinDirectives.put("T", new TabulateDirective());
 	}
@@ -103,7 +105,7 @@ public class CLFormatter {
 		/* Put the parameters where we can easily handle them. */
 		Tape<Object> tParams = new SingleTape<>(params);
 
-		doFormatString(format, rw, tParams);
+		doFormatString(format, rw, tParams, true);
 
 		return rw.toString();
 	}
@@ -123,7 +125,7 @@ public class CLFormatter {
 		/* Put the parameters where we can easily handle them. */
 		Tape<Object> tParams = new SingleTape<>(params);
 
-		doFormatString(format, rw, tParams);
+		doFormatString(format, rw, tParams, true);
 
 		return rw.toString();
 	}
@@ -141,7 +143,7 @@ public class CLFormatter {
 		/* Put the parameters where we can easily handle them. */
 		Tape<Object> tParams = new SingleTape<>(params);
 
-		doFormatString(format, rw, tParams);
+		doFormatString(format, rw, tParams, true);
 	}
 	
 	/**
@@ -159,7 +161,7 @@ public class CLFormatter {
 		/* Put the parameters where we can easily handle them. */
 		Tape<Object> tParams = new SingleTape<>(params);
 
-		doFormatString(format, rw, tParams);
+		doFormatString(format, rw, tParams, true);
 	}
 
 	/**
@@ -175,7 +177,7 @@ public class CLFormatter {
 	 * @param tParams
 	 *        The parameters to use.
 	 */
-	public void doFormatString(String format, ReportWriter rw, Tape<Object> tParams) throws IOException {
+	public void doFormatString(String format, ReportWriter rw, Tape<Object> tParams, boolean isToplevel) throws IOException {
 		Matcher dirMatcher = pFormatDirective.matcher(format);
 
 		// We need this StringBuffer to use appendReplacement and stuff
@@ -185,90 +187,96 @@ public class CLFormatter {
 		// ourselves.
 		StringBuffer sb = new StringBuffer();
 
-		while(dirMatcher.find()) {
-			dirMatcher.appendReplacement(sb, "");
-			rw.writeBuffer(sb);
-
-			String dirName = dirMatcher.group("name");
-			String dirFunc = dirMatcher.group("funcname");
-			String dirMods = dirMatcher.group("modifiers");
-			String dirParams = dirMatcher.group("params");
-
-			if(dirMods == null) dirMods = "";
-			if(dirParams == null) dirParams = "";
-
-			String[] splitPars = dirParams.split("(?<!'),");
-			CLParameters arrParams = CLParameters.fromDirective(splitPars, tParams);
-
-			CLModifiers mods = CLModifiers.fromString(dirMods);
-
-			Object item = tParams.item();
-			if(dirName == null && dirFunc != null) {
-				/*
-				 * @TODO implement user-called functions.
-				 */
-				continue;
-			}
-
-			if(extraDirectives.containsKey(dirName)) {
-				extraDirectives.get(dirName).format(rw, item, mods, arrParams, tParams, dirMatcher,
-						this);
-
-				continue;
+		boolean doTail = true;
+		try {
+			while(dirMatcher.find()) {
+				dirMatcher.appendReplacement(sb, "");
+				rw.writeBuffer(sb);
+
+				String dirName   = dirMatcher.group("name");
+				String dirFunc   = dirMatcher.group("funcname");
+				String dirMods   = dirMatcher.group("modifiers");
+				String dirParams = dirMatcher.group("params");
+
+				if(dirMods   == null) dirMods = "";
+				if(dirParams == null) dirParams = "";
+
+				CLParameters arrParams = CLParameters.fromDirective(dirParams, tParams);
+
+				CLModifiers mods = CLModifiers.fromString(dirMods);
+
+				Object item = tParams.item();
+
+				if(dirName == null && dirFunc != null) {
+					/*
+					 * @TODO implement user-called functions.
+					 */
+					continue;
+				}
+
+				if(extraDirectives.containsKey(dirName)) {
+					extraDirectives.get(dirName).format(rw, item, mods, arrParams, tParams, dirMatcher,
+							this);
+
+					continue;
+				}
+
+				if(builtinDirectives.containsKey(dirName)) {
+					// System.err.printf("Executing directive %s (%s) (%d to %d) from string %s\n", dirName, dirMatcher.group(), dirMatcher.start(), dirMatcher.end(), format);
+
+					builtinDirectives.get(dirName).format(rw,
+							item, mods, arrParams, tParams, dirMatcher, this);
+
+					continue;
+				}
+
+				if(dirName == null) dirName = "<null>";
+
+				switch(dirName) {
+					case "]":
+						throw new IllegalArgumentException("Found conditional-end outside of conditional.");
+					case ";":
+						throw new IllegalArgumentException(
+								"Found seperator outside of block.");
+					case "}":
+						throw new IllegalArgumentException("Found iteration-end outside of iteration");
+					case "<":
+					case ">":
+						throw new IllegalArgumentException("Layout-control directives aren't implemented yet.");
+					case "F":
+					case "E":
+					case "G":
+					case "$":
+						/* @TODO implement floating point directives. */
+						throw new IllegalArgumentException("Floating-point directives aren't implemented yet.");
+					case "W":
+						/*
+						 * @TODO figure out if we want to implement
+						 * someting for these directives instead of
+						 * punting.
+						 */
+						throw new IllegalArgumentException("S and W aren't implemented. Use A instead");
+					case "P":
+						throw new IllegalArgumentException("These directives aren't implemented yet");
+					case ")":
+						throw new IllegalArgumentException("Case-conversion end outside of case conversion");
+					case "\n":
+						/*
+						 * Ignored newline.
+						 */
+						break;
+					default:
+						String msg = String.format("Unknown format directive '%s'", dirName);
+						throw new IllegalArgumentException(msg);
+				}
 			}
+		} catch (EscapeException eex) {
+			if (!isToplevel) throw eex;
 
-			if(builtinDirectives.containsKey(dirName)) {
-				builtinDirectives.get(dirName).format(rw, item, mods, arrParams, tParams, dirMatcher,
-						this);
-
-				continue;
-			}
-
-			if(dirName == null) dirName = "<null>";
-
-			switch(dirName) {
-			case "]":
-				throw new IllegalArgumentException("Found conditional-end outside of conditional.");
-			case ";":
-				throw new IllegalArgumentException(
-						"Found seperator outside of block.");
-			case "}":
-				throw new IllegalArgumentException("Found iteration-end outside of iteration");
-			case "<":
-			case ">":
-				throw new IllegalArgumentException("Layout-control directives aren't implemented yet.");
-			case "F":
-			case "E":
-			case "G":
-			case "$":
-				/* @TODO implement floating point directives. */
-				throw new IllegalArgumentException("Floating-point directives aren't implemented yet.");
-			case "S":
-			case "W":
-				/*
-				 * @TODO figure out if we want to implement
-				 * someting for these directives instead of
-				 * punting.
-				 */
-				throw new IllegalArgumentException("S and W aren't implemented. Use A instead");
-			case "?":
-			case "(":
-			case "P":
-				throw new IllegalArgumentException("These directives aren't implemented yet");
-			case ")":
-				throw new IllegalArgumentException("Case-conversion end outside of case conversion");
-			case "\n":
-				/*
-				 * Ignored newline.
-				 */
-				break;
-			default:
-				String msg = String.format("Unknown format directive '%s'", dirName);
-				throw new UnknownFormatConversionException(msg);
-			}
+			doTail = false;
 		}
 
-		dirMatcher.appendTail(sb);
+		if (doTail) dirMatcher.appendTail(sb);
 		rw.writeBuffer(sb);
 	}
 }
diff --git a/base/src/main/java/bjc/utils/ioutils/format/CLModifiers.java b/base/src/main/java/bjc/utils/ioutils/format/CLModifiers.java
index 0625ff8..68127b6 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/CLModifiers.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/CLModifiers.java
@@ -15,6 +15,14 @@ public class CLModifiers {
 	 * Whether the colon mod is on.
 	 */
 	public final boolean colonMod;
+	/**
+	 * Whether the dollar mod is on.
+	 */
+	public final boolean dollarMod;
+	/**
+	 * Whether the star mod is on.
+	 */
+	public final boolean starMod;
 
 	/**
 	 * Create a new set of CL modifiers.
@@ -23,10 +31,14 @@ public class CLModifiers {
 	 *        The state of the at mod.
 	 * @param colon
 	 *        The state of the colon mod.
+	 * @param dollar
+	 *        The state of the dollar mod.
 	 */
-	public CLModifiers(boolean at, boolean colon) {
-		atMod = at;
-		colonMod = colon;
+	public CLModifiers(boolean at, boolean colon, boolean dollar, boolean star) {
+		atMod     = at;
+		colonMod  = colon;
+		dollarMod = dollar;
+		starMod   = star;
 	}
 
 	/**
@@ -37,13 +49,18 @@ public class CLModifiers {
 	 * @return A set of modifiers matching the string.
 	 */
 	public static CLModifiers fromString(String modString) {
-		boolean atMod = false;
-		boolean colonMod = false;
+		boolean atMod     = false;
+		boolean colonMod  = false;
+		boolean dollarMod = false;
+		boolean starMod   = false;
+
 		if(modString != null) {
-			atMod = modString.contains("@");
-			colonMod = modString.contains(":");
+			atMod     = modString.contains("@");
+			colonMod  = modString.contains(":");
+			dollarMod = modString.contains("$");
+			starMod   = modString.contains("*");
 		}
 
-		return new CLModifiers(atMod, colonMod);
+		return new CLModifiers(atMod, colonMod, dollarMod, starMod);
 	}
-}
\ No newline at end of file
+}
diff --git a/base/src/main/java/bjc/utils/ioutils/format/CLParameters.java b/base/src/main/java/bjc/utils/ioutils/format/CLParameters.java
index 2588446..bde7a7d 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/CLParameters.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/CLParameters.java
@@ -44,10 +44,33 @@ public class CLParameters {
 	 *
 	 * @return A set of CL parameters.
 	 */
-	public static CLParameters fromDirective(String[] params, Tape<Object> dirParams) {
+	public static CLParameters fromDirective(String unsplit, Tape<Object> dirParams) {
+		List<String>  lParams   = new ArrayList<>();
+		StringBuilder currParm = new StringBuilder();
+
+		char prevChar = ' ';
+
+		for (int i = 0; i < unsplit.length(); i++) {
+			char c = unsplit.charAt(i);
+
+			if (c == ',' && prevChar != '\'') {
+				lParams.add(currParm.toString());
+				
+				currParm = new StringBuilder();
+			} else {
+				currParm.append(c);
+			}
+
+			prevChar = c;
+		}
+		lParams.add(currParm.toString());
+
 		List<String> parameters = new ArrayList<>();
 
-		for(String param : params) {
+		if (lParams.size() == 1 && lParams.get(0).equals(""))
+			return new CLParameters(parameters.toArray(new String[0]));
+
+		for(String param : lParams) {
 			if(param.equalsIgnoreCase("V")) {
 				Object par = dirParams.item();
 				boolean succ = dirParams.right();
@@ -73,7 +96,9 @@ public class CLParameters {
 					throw new IllegalArgumentException(
 							"Incorrect type of parameter for V inline parameter");
 				}
-			} else if(param.equals("#")) {
+			} else if (param.equals("#")) {
+				parameters.add(Integer.toString(dirParams.size() - dirParams.position()));
+			} else if (param.equals("%")) {
 				parameters.add(Integer.toString(dirParams.position()));
 			} else {
 				parameters.add(param);
@@ -119,9 +144,14 @@ public class CLParameters {
 	public char getChar(int idx, String paramName, char directive) {
 		String param = params[idx];
 
+		if (param.length() == 1) {
+			// Punt in the case we have a slightly malformed issue
+			return param.charAt(0);
+		}
+
 		if(!param.startsWith("'")) {
 			throw new IllegalArgumentException(
-					String.format("Invalid %s %s to %c directive", paramName, param, directive));
+					String.format("Invalid %s \"%s\" to %c directive", paramName, param, directive));
 		}
 
 		return param.charAt(1);
@@ -166,7 +196,7 @@ public class CLParameters {
 		try {
 			return Integer.parseInt(param);
 		} catch(NumberFormatException nfex) {
-			String msg = String.format("Invalid %s %s to %c directive", paramName, param, directive);
+			String msg = String.format("Invalid %s \"%s\" to %c directive", paramName, param, directive);
 
 			IllegalArgumentException iaex = new IllegalArgumentException(msg);
 			iaex.initCause(nfex);
@@ -174,4 +204,21 @@ public class CLParameters {
 			throw iaex;
 		}
 	}
+	
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder("[");
+
+		for (int i = 0; i < params.length; i++) {
+			if (i != 0) sb.append(", ");
+
+			sb.append("\"");
+			sb.append(params[i]);
+			sb.append("\"");
+		}
+
+		sb.append("]");
+
+		return sb.toString();
+	}
 }
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
index 4276f40..9bad6d7 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java
@@ -21,6 +21,7 @@ public class AestheticDirective implements Directive {
 	@Override
 	public void format(ReportWriter rw, Object item, CLModifiers mods, CLParameters params, Tape<Object> tParams,
 			Matcher dirMatcher, CLFormatter fmt) throws IOException {
+		// System.err.printf("Aesthetic directive with item \"%s\" and params: %s\n", item, tParams);
 		CLFormatter.checkItem(item, 'A');
 
 		int mincol = 0, colinc = 1, minpad = 0;
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/CaseDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/CaseDirective.java
new file mode 100644
index 0000000..728bb43
--- /dev/null
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/CaseDirective.java
@@ -0,0 +1,117 @@
+
+package bjc.utils.ioutils.format.directives;
+
+import bjc.utils.esodata.Tape;
+import bjc.utils.ioutils.format.*;
+import bjc.utils.ioutils.ReportWriter;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.ArrayList;
+import java.util.IllegalFormatConversionException;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class CaseDirective implements Directive {
+	private static final Pattern wordPattern = Pattern.compile("(\\w+)(\\b*)");
+
+	@Override
+	public void format(ReportWriter rw, Object item, CLModifiers mods, CLParameters params, Tape<Object> tParams,
+			Matcher dirMatcher, CLFormatter fmt) throws IOException {
+		StringBuffer condBody = new StringBuffer();
+
+		int nestLevel = 1;
+
+		while (dirMatcher.find()) {
+			/* Process a list of clauses. */
+			String dirName = dirMatcher.group("name");
+
+			if (dirName != null) {
+				/* Append everything up to this directive. */
+				dirMatcher.appendReplacement(condBody, "");
+
+				if (dirName.equals("(")) {
+					if (nestLevel > 0) {
+						condBody.append(dirMatcher.group());
+					}
+
+					nestLevel += 1;
+				} else if (Directive.isOpening(dirName)) {
+					nestLevel += 1;
+
+					condBody.append(dirMatcher.group());
+				} else if (dirName.equals(")")) {
+					nestLevel = Math.max(0, nestLevel - 1);
+
+					/* End the iteration. */
+					if (nestLevel == 0) break;
+				} else if (Directive.isClosing(dirName)) {
+					nestLevel = Math.max(0, nestLevel - 1);
+				} else {
+					/* Not a special directive. */
+					condBody.append(dirMatcher.group());
+				}
+			}
+		}
+
+		String frmt = condBody.toString();
+
+		ReportWriter nrw = rw.duplicate(new StringWriter());
+
+		fmt.doFormatString(frmt, nrw, tParams, false);
+
+		String strang = nrw.toString();
+
+		if (mods.colonMod && mods.atMod) {
+			strang = strang.toUpperCase();
+		} else if (mods.colonMod) {
+			Matcher mat = wordPattern.matcher(strang);
+
+			StringBuffer sb = new StringBuffer();
+			while(!mat.find()) {
+				mat.appendReplacement(sb, "");
+
+				String word = mat.group(1);
+				
+				word = word.substring(0, 1).toUpperCase() + word.substring(1);
+
+				sb.append(word);
+				sb.append(mat.group(2));
+			}
+
+			mat.appendTail(sb);
+
+			strang = sb.toString();
+		} else if (mods.atMod) {
+			Matcher mat = wordPattern.matcher(strang);
+
+			StringBuffer sb = new StringBuffer();
+			boolean doCap = true;
+			while(!mat.find()) {
+				mat.appendReplacement(sb, "");
+
+				String word = mat.group(1);
+				
+				if (doCap) {
+					doCap = false;
+
+					word = word.substring(0, 1).toUpperCase() + word.substring(1);
+				}
+
+				sb.append(word);
+				sb.append(mat.group(2));
+			}
+
+			mat.appendTail(sb);
+
+			strang = sb.toString();
+
+		} else {
+			strang = strang.toLowerCase();
+		}
+
+		rw.write(strang);
+	}
+}
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java
index 71d9e7d..ed0b39b 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java
@@ -8,6 +8,7 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.IllegalFormatConversionException;
 import java.util.List;
+import java.util.logging.Logger;
 import java.util.regex.Matcher;
 
 /**
@@ -17,6 +18,7 @@ import java.util.regex.Matcher;
  *
  */
 public class ConditionalDirective implements Directive {
+	private static Logger LOG = Logger.getLogger(ConditionalDirective.class.getName());
 
 	@Override
 	public void format(ReportWriter rw, Object item, CLModifiers mods, CLParameters arrParams,
@@ -24,42 +26,75 @@ public class ConditionalDirective implements Directive {
 		StringBuffer condBody = new StringBuffer();
 
 		List<String> clauses = new ArrayList<>();
-		String defClause = null;
+
+		String defClause  = null;
 		boolean isDefault = false;
 
+		int nestLevel = 1;
+
 		while (dirMatcher.find()) {
 			/* Process a list of clauses. */
 			String dirName = dirMatcher.group("name");
 			String dirMods = dirMatcher.group("modifiers");
 
+			//System.err.printf("Found conditional directive %s with %s mods and level %d\n", dirName, dirMods, nestLevel);
 			if (dirName != null) {
 				/* Append everything up to this directive. */
 				dirMatcher.appendReplacement(condBody, "");
 
-				if (dirName.equals("]")) {
-					/* End the conditional. */
-					String clause = condBody.toString();
-					if (isDefault) {
-						defClause = clause;
-					} else {
+				if (dirName.equals("[")) {
+					if (nestLevel > 0) {
+						condBody.append(dirMatcher.group());
+					}
+					nestLevel += 1;
+				} else if (Directive.isOpening(dirName)) {
+					nestLevel += 1;
+
+					condBody.append(dirMatcher.group());
+				} else if (dirName.equals("]")) {
+					nestLevel = Math.max(0, nestLevel - 1);
+
+					if (nestLevel == 0) {
+						/* End the conditional. */
+						String clause = condBody.toString();
+						// System.err.printf("Found clause \"%s]\"\n", clause);
+						condBody      = new StringBuffer();
+
+						if (isDefault) {
+							defClause = clause;
+						}
 						clauses.add(clause);
+
+						break;
+					} else {
+						/* Not a special directive. */
+						condBody.append(dirMatcher.group());
 					}
+				} else if (Directive.isClosing(dirName)) {
+					nestLevel = Math.max(0, nestLevel - 1);
 
-					break;
+					condBody.append(dirMatcher.group());
 				} else if (dirName.equals(";")) {
-					/* End the clause. */
-					String clause = condBody.toString();
-					if (isDefault) {
-						defClause = clause;
-					} else {
+					if (nestLevel == 1) {
+						/* End the clause. */
+						String clause = condBody.toString();
+						// System.err.printf("Found clause \"%s;\"\n", clause);
+						condBody      = new StringBuffer();
+
+						if (isDefault) {
+							defClause = clause;
+						}
 						clauses.add(clause);
-					}
 
-					/*
-					 * Mark the next clause as the default.
-					 */
-					if (dirMods.contains(":")) {
-						isDefault = true;
+						/*
+						 * Mark the next clause as the default.
+						 */
+						if (dirMods.contains(":")) {
+							isDefault = true;
+						}
+					} else {
+						/* Not a special directive. */
+						condBody.append(dirMatcher.group());
 					}
 				} else {
 					/* Not a special directive. */
@@ -67,18 +102,21 @@ public class ConditionalDirective implements Directive {
 				}
 			}
 		}
+		
+		if (mods.starMod && clauses.size() > 0) defClause = clauses.get(0);
 
-		Object par = formatParams.item();
 		try {
 			if (mods.colonMod) {
 				formatParams.right();
 
-				if (par == null) {
-					throw new IllegalArgumentException("No parameter provided for [ directive.");
-				} else if (!(par instanceof Boolean)) {
-					throw new IllegalFormatConversionException('[', par.getClass());
+				boolean res = false;
+				if (item == null) {
+					//throw new IllegalArgumentException("No parameter provided for [ directive.");
+				} else if (!(item instanceof Boolean)) {
+					throw new IllegalFormatConversionException('[', item.getClass());
+				} else {
+					res = (Boolean) item;
 				}
-				boolean res = (Boolean) par;
 
 				String frmt;
 				if (res)
@@ -86,17 +124,21 @@ public class ConditionalDirective implements Directive {
 				else
 					frmt = clauses.get(0);
 
-				fmt.doFormatString(frmt, rw, formatParams);
+				fmt.doFormatString(frmt, rw, formatParams, false);
 			} else if (mods.atMod) {
-				if (par == null) {
-					throw new IllegalArgumentException("No parameter provided for [ directive.");
-				} else if (!(par instanceof Boolean)) {
-					throw new IllegalFormatConversionException('[', par.getClass());
+				boolean res = false;
+				if (item == null) {
+					// throw new IllegalArgumentException("No parameter provided for [ directive.");
+				} else if (item instanceof Integer) {
+					if ((Integer)item != 0) res = true;
+				} else if (item instanceof Boolean) {
+					res = (Boolean) item;
+				} else {
+					throw new IllegalFormatConversionException('[', item.getClass());
 				}
-				boolean res = (Boolean) par;
 
 				if (res) {
-					fmt.doFormatString(clauses.get(0), rw, formatParams);
+					fmt.doFormatString(clauses.get(0), rw, formatParams, false);
 				} else {
 					formatParams.right();
 				}
@@ -105,21 +147,33 @@ public class ConditionalDirective implements Directive {
 				if (arrParams.length() >= 1) {
 					res = arrParams.getInt(0, "conditional choice", '[');
 				} else {
-					if (par == null) {
+					if (item == null) {
 						throw new IllegalArgumentException("No parameter provided for [ directive.");
-					} else if (!(par instanceof Number)) {
-						throw new IllegalFormatConversionException('[', par.getClass());
+					} else if (!(item instanceof Number)) {
+						throw new IllegalFormatConversionException('[', item.getClass());
 					}
-					res = ((Number) par).intValue();
+					res = ((Number) item).intValue();
 
 					formatParams.right();
 				}
 
-				if (res < 0 || res > clauses.size()) {
-					if (defClause != null)
-						fmt.doFormatString(defClause, rw, formatParams);
+				if (mods.dollarMod) res -= 1;
+
+				// System.err.printf("Attempting selection of clause %d of %d (%s) (default %s)\n",
+				//		res, clauses.size(), clauses, defClause);
+				if (clauses.size() == 0 || res < 0 || res >= clauses.size()) {
+					// System.err.printf("Selecting default clause (res %d, max %d): %s\n", res, clauses.size(), defClause);
+					// int clauseNo = 0;
+					// for (String clause : clauses) {
+						// System.err.printf("... clause %d: %s\n", ++clauseNo, clause); 
+					// }
+
+					if (defClause != null) fmt.doFormatString(defClause, rw, formatParams, false);
 				} else {
-					fmt.doFormatString(clauses.get(res), rw, formatParams);
+					String frmt = clauses.get(res);
+
+					// System.out.printf("Selecting clause %d of %d (params %s): %s\n", res, clauses.size(), formatParams, frmt);
+					fmt.doFormatString(frmt, rw, formatParams, false);
 				}
 			}
 		} catch (EscapeException eex) {
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/Directive.java b/base/src/main/java/bjc/utils/ioutils/format/directives/Directive.java
index ad9c34c..61abfc1 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/Directive.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/Directive.java
@@ -37,4 +37,36 @@ public interface Directive {
 	 */
 	public void format(ReportWriter rw, Object item, CLModifiers mods, CLParameters arrParams, Tape<Object> tParams,
 			Matcher dirMatcher, CLFormatter fmt) throws IOException;
+
+	public static boolean isOpening(String str) {
+		return isOpening(str.charAt(0));
+	}
+
+	public static boolean isOpening(char dir) {
+		switch(dir) {
+		case '(':
+		case '<':
+		case '[':
+		case '{':
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	public static boolean isClosing(String str) {
+		return isClosing(str.charAt(0));
+	}
+
+	public static boolean isClosing(char dir) {
+		switch(dir) {
+		case ')':
+		case '>':
+		case ']':
+		case '}':
+			return true;
+		default:
+			return false;
+		}
+	}
 }
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java
index 5badff0..74488ed 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java
@@ -21,28 +21,35 @@ public class EscapeDirective implements Directive {
 			Tape<Object> formatParams, Matcher dirMatcher, CLFormatter fmt) {
 		boolean shouldExit;
 
+		if (mods.dollarMod) formatParams.right();
+
 		switch(params.length()) {
 		case 0:
-			shouldExit = formatParams.size() == 0;
+			shouldExit = formatParams.atEnd();
 			break;
 		case 1:
 			int num = params.getInt(0, "condition count", '^');
+
 			shouldExit = num == 0;
 			break;
 		case 2:
-			int left = params.getInt(0, "left-hand condition", '^');
+			int left  = params.getInt(0, "left-hand condition", '^');
 			int right = params.getInt(1, "right-hand condition", '^');
+
 			shouldExit = left == right;
 			break;
 		case 3:
 		default:
-			int low = params.getInt(0, "lower-bound condition", '^');
-			int mid = params.getInt(1, "interval condition", '^');
+			int low  = params.getInt(0, "lower-bound condition", '^');
+			int mid  = params.getInt(1, "interval condition", '^');
 			int high = params.getInt(2, "upper-bound condition", '^');
+
 			shouldExit = (low <= mid) && (mid <= high);
 			break;
 		}
 
+		if (mods.dollarMod) formatParams.left();
+
 		/* At negates it. */
 		if(mods.atMod) shouldExit = !shouldExit;
 
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java
index ccf01d8..3eb741e 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java
@@ -38,10 +38,10 @@ public abstract class GeneralNumberDirective implements Directive {
 			 */
 			int commaInterval = 0;
 			char commaChar = ',';
-			if (params.length() >= (argidx + 3)) {
-				commaChar = params.getCharDefault((argidx + 3), "comma character", 'R', ' ');
-			}
 			if (params.length() >= (argidx + 4)) {
+				commaChar = params.getCharDefault((argidx + 3), "comma character", 'R', ',');
+			}
+			if (params.length() >= (argidx + 5)) {
 				commaInterval = params.getIntDefault((argidx + 4), "comma interval", 'R', 0);
 			}
 
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java
index 97e392e..2ce6309 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java
@@ -36,18 +36,18 @@ public class IterationDirective implements Directive {
 				dirMatcher.appendReplacement(condBody, "");
 
 				if (dirName.equals("}")) {
-					/* End the iteration. */
 					break;
+				} else {
+					/* Not a special directive. */
+					condBody.append(dirMatcher.group());
 				}
-
-				/* Not a special directive. */
-				condBody.append(dirMatcher.group());
 			}
 		}
 
 		String frmt = condBody.toString();
 		Object iter = item;
 
+		// System.err.printf("Iteration format \"%s\" (iter %s)\n", frmt, item);
 		if (frmt.equals("")) {
 			/* Grab an argument. */
 			if (!(item instanceof String)) {
@@ -86,25 +86,29 @@ public class IterationDirective implements Directive {
 					Tape<Object> nParams = new SingleTape<>(nitr);
 
 					try {
-						fmt.doFormatString(frmt, rw, nParams);
+						fmt.doFormatString(frmt, rw, nParams, false);
 					} catch (EscapeException eex) {
 						if (eex.endIteration) {
-							if (tParams.atEnd()) throw eex;
+							if (tParams.atEnd()) {
+								throw eex;
+							}
 						}
 					}
 
-					iter = tParams.right();
+					tParams.right();
+					iter = tParams.item();
 				} while (tParams.position() < tParams.size());
 			} catch (EscapeException eex) {
 			}
 		} else if (mods.atMod) {
 			try {
-			while (tParams.position() < tParams.size()) {
-				if (numItr > maxItr) break;
-				numItr += 1;
+				while (!tParams.atEnd()) {
+					// System.err.printf("Iterating with format \"%s\"\n", frmt);
+					if (numItr > maxItr) break;
+					numItr += 1;
 
-				fmt.doFormatString(frmt, rw, tParams);
-			}
+					fmt.doFormatString(frmt, rw, tParams, false);
+				}
 			} catch (EscapeException eex) {
 				if (eex.endIteration)
 					throw new UnsupportedOperationException("Colon mod not allowed on escape marker without colon mod on iteration");
@@ -133,13 +137,12 @@ public class IterationDirective implements Directive {
 					Tape<Object> nParams = new SingleTape<>(nitr);
 
 					try {
-						fmt.doFormatString(frmt, rw, nParams);
+						fmt.doFormatString(frmt, rw, nParams, false);
 					} catch (EscapeException eex) {
 						if(eex.endIteration && !itr.hasNext()) throw eex;
 					}
 				}
-			}
-			catch (EscapeException eex) {
+			} catch (EscapeException eex) {
 			}
 		} else {
 			if (!(item instanceof Iterable<?>)) {
@@ -149,16 +152,13 @@ public class IterationDirective implements Directive {
 			try {
 				@SuppressWarnings("unchecked")
 				Iterable<Object> itr = (Iterable<Object>) item;
-
 				Tape<Object> nParams = new SingleTape<>(itr);
 
-				while (nParams.position() < nParams.size()) {
-					if (numItr > maxItr)
-						break;
+				while (!nParams.atEnd()) {
+					if (numItr > maxItr) break;
 					numItr += 1;
 
-					fmt.doFormatString(frmt, rw, nParams);
-
+					fmt.doFormatString(frmt, rw, nParams, false);
 				}
 			} catch (EscapeException eex) {
 				if (eex.endIteration)
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java
index 763665d..88b3e7e 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java
@@ -26,21 +26,25 @@ public class NumberDirective extends GeneralNumberDirective {
 	 * @param radix
 	 *            The radix of the number to use.
 	 */
-	public NumberDirective(int argidx, int radix) {
+	public NumberDirective(int argidx, int radix, char directive) {
 		this.argidx = argidx;
 		this.radix = radix;
+
+		this.directive = directive;
 	}
 
 	private int argidx;
 	private int radix;
 
+	private char directive;
+
 	@Override
 	public void format(ReportWriter rw, Object item, CLModifiers mods, CLParameters params, Tape<Object> tParams,
 			Matcher dirMatcher, CLFormatter fmt) throws IOException {
-		CLFormatter.checkItem(item, 'B');
+		CLFormatter.checkItem(item, directive);
 
 		if (!(item instanceof Number)) {
-			throw new IllegalFormatConversionException('B', item.getClass());
+			throw new IllegalFormatConversionException(directive, item.getClass());
 		}
 
 		long val = ((Number) item).longValue();
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/RecursiveDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/RecursiveDirective.java
new file mode 100644
index 0000000..44a25ad
--- /dev/null
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/RecursiveDirective.java
@@ -0,0 +1,49 @@
+package bjc.utils.ioutils.format.directives;
+
+import bjc.utils.esodata.SingleTape;
+import bjc.utils.esodata.Tape;
+import bjc.utils.ioutils.format.*;
+import bjc.utils.ioutils.ReportWriter;
+import java.util.IllegalFormatConversionException;
+
+import java.io.IOException;
+import java.util.regex.Matcher;
+
+public class RecursiveDirective implements Directive {
+	public void format(ReportWriter rw, Object arg, CLModifiers mods, CLParameters params, Tape<Object> tParams,
+			Matcher dirMatcher, CLFormatter fmt) throws IOException {
+		tParams.right();
+
+		CLFormatter.checkItem(arg, '?');
+
+		if (mods.atMod) {
+			if (!(arg instanceof String))
+				throw new IllegalFormatConversionException('?', arg.getClass());
+
+			try {
+				fmt.doFormatString((String)arg, rw, tParams, true);
+			} catch (EscapeException eex) {
+				if (eex.endIteration)
+					throw new UnsupportedOperationException("Colon mod not allowed on escape marker without colon mod on iteration");
+			}
+		} else {
+			if (tParams.atEnd())
+				throw new IllegalArgumentException("? directive requires two format parameters");
+
+			Object o = tParams.item();
+			tParams.right();
+
+			if (!(o instanceof Iterable))
+				throw new IllegalFormatConversionException('?', o.getClass());
+
+			Iterable<Object> itb = (Iterable<Object>)o;
+			Tape<Object> newParams = new SingleTape<>(itb);
+
+			try {
+				fmt.doFormatString((String)arg, rw, newParams, true);
+			} catch (EscapeException eex) {
+				throw new UnsupportedOperationException("Colon mod not allowed on escape marker without colon mod on iteration");
+			}
+		}
+	}
+}
diff --git a/base/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java b/base/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java
index 7775904..d9136f2 100644
--- a/base/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java
+++ b/base/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java
@@ -14,7 +14,7 @@ public class TabulateDirective implements Directive {
 		// Unsupported feature.
 		//
 		// I can't really make out what this is supposed to do from the
-		// documentation, but I suspect that it depends of font glyph
+		// documentation, but I suspect that it depends on font glyph
 		// size, not character positions
 		if (mods.colonMod) {
 			throw new UnsupportedOperationException("Colon mod is not supported for T directive");