diff options
Diffstat (limited to 'clformat/src/main/java/bjc')
16 files changed, 267 insertions, 115 deletions
diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/CLFormatter.java b/clformat/src/main/java/bjc/utils/ioutils/format/CLFormatter.java index ef04cf8..12802cf 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/CLFormatter.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/CLFormatter.java @@ -253,7 +253,7 @@ public class CLFormatter { if(dirMods == null) dirMods = ""; if(dirParams == null) dirParams = ""; - CLParameters arrParams = CLParameters.fromDirective(dirParams, tParams); + CLParameters arrParams = CLParameters.fromDirective(dirParams); CLModifiers mods = CLModifiers.fromString(dirMods); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/CLParameters.java b/clformat/src/main/java/bjc/utils/ioutils/format/CLParameters.java index 779ce9d..b89a706 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/CLParameters.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/CLParameters.java @@ -22,12 +22,12 @@ public class CLParameters { private static String RX_TRUE = "(?i)y(?:es)?|t(?:rue)?(?i)"; private static String RX_FALSE = "(?i)no?|f(?:alse)?(?i)"; - private String[] params; + private CLValue[] params; private Set<String> abbrevWords; private AbbrevMap nameAbbrevs; - private Map<String, String> namedParams; + private Map<String, CLValue> namedParams; private Map<String, Integer> nameIndices; /** @@ -36,15 +36,15 @@ public class CLParameters { * @param params * The CL format parameters to use. */ - public CLParameters(String[] params) { + public CLParameters(CLValue[] params) { this(params, new HashMap<>()); } - public CLParameters(Map<String, String> namedParams) { - this(new String[0], namedParams); + public CLParameters(Map<String, CLValue> namedParams) { + this(new CLValue[0], namedParams); } - public CLParameters(String[] params, Map<String, String> namedParams) { + public CLParameters(CLValue[] params, Map<String, CLValue> namedParams) { this.params = params; this.namedParams = namedParams; @@ -109,11 +109,12 @@ public class CLParameters { if (doRefresh) refreshAbbrevs(); } - public String getByIndex(int idx) { - if (idx < 0 || idx >= params.length) return "Out of Bounds"; + public CLValue getByIndex(int idx) { + if (idx < 0 || idx >= params.length) return null; return params[idx]; } + /** * Get the length of the parameter list. * @@ -136,8 +137,9 @@ public class CLParameters { * * @return A set of CL parameters. */ - public static CLParameters fromDirective(String unsplit, Tape<Object> dirParams) { - List<String> lParams = new ArrayList<>(); + public static CLParameters fromDirective(String unsplit) { + List<String> lParams = new ArrayList<>(); + StringBuilder currParm = new StringBuilder(); char prevChar = ' '; @@ -168,13 +170,13 @@ public class CLParameters { // Add last parameter lParams.add(currParm.toString()); - List<String> parameters = new ArrayList<>(); + List<CLValue> parameters = new ArrayList<>(); // Special case empty blocks, so that we don't confuse people if (lParams.size() == 1 && lParams.get(0).equals("")) - return new CLParameters(parameters.toArray(new String[0])); + return new CLParameters(parameters.toArray(new CLValue[0])); - Map<String, String> namedParams = new HashMap<>(); + Map<String, CLValue> namedParams = new HashMap<>(); for(String param : lParams) { if (param.startsWith("#") && !param.equals("#")) { @@ -198,62 +200,52 @@ public class CLParameters { String paramName = param.substring(0, nameIdx); String paramVal = param.substring(nameIdx + 1); - String actVal = parseParam(paramVal, dirParams); + CLValue actVal = parseParam(paramVal); namedParams.put(paramName.toUpperCase(), actVal); if (setIndex) parameters.add(actVal); } else { - parameters.add(parseParam(param, dirParams)); + parameters.add(parseParam(param)); } - - //currParamNo += 1; } - return new CLParameters(parameters.toArray(new String[0]), namedParams); + return new CLParameters(parameters.toArray(new CLValue[0]), namedParams); } - private static String parseParam(String param, Tape<Object> dirParams) { - if(param.equalsIgnoreCase("V")) { - // Read parameter from items - Object par = dirParams.item(); - boolean succ = dirParams.right(); - - if(!succ) { - throw new IllegalStateException("Couldn't advance tape for parameter"); - } else if(par == null) { - throw new IllegalArgumentException( - "Expected a format parameter for V inline parameter"); - } - - if(par instanceof Number) { - int val = ((Number) par).intValue(); - - return Integer.toString(val); - } else if(par instanceof Character) { - char ch = ((Character) par); + private static CLValue parseParam(String param) { + String val = param; - return Character.toString(ch); - } else if (par instanceof String) { - return (String)par; - } else { - throw new IllegalArgumentException( - "Incorrect type of parameter for V inline parameter"); - } - } else if (param.equals("#")) { - return (Integer.toString(dirParams.size() - dirParams.position())); - } else if (param.equals("%")) { - return Integer.toString(dirParams.position()); - } else if (param.startsWith("\"")) { + if (param.startsWith("\"")) { String dquote = param.substring(1, param.length() - 1); - return TokenUtils.descapeString(dquote); + val = TokenUtils.descapeString(dquote); } - return param; + return CLValue.parse(val); } - private String resolveKey(String key) { + /** + * Get the corresponding value for a key. + * + * @param key + * The name of the parameter to look up. + * + * @return The value for that key, or null if none exists. + */ + public CLValue resolveKey(int key) { + return resolveKey(Integer.toString(key)); + } + + /** + * Get the corresponding value for a key. + * + * @param key + * The name of the parameter to look up. + * + * @return The value for that key, or null if none exists. + */ + public CLValue resolveKey(String key) { String ucKey = key.toUpperCase(); if (!abbrevWords.contains(ucKey)) refreshAbbrev(ucKey); @@ -286,16 +278,16 @@ public class CLParameters { // @NOTE 9/22/18 // // Consider whether we should throw an exception here. - if (idx < 0 || idx >= params.length) return ""; + if (idx < 0 || idx >= params.length) return null; return params[idx]; } - return ""; + return null; } - public boolean getBoolean(String key, String paramName, String directive, boolean def) { - String bol = resolveKey(key); + public boolean getBoolean(Tape<Object> params, String key, String paramName, String directive, boolean def) { + String bol = resolveKey(key).getValue(params); if(!bol.equals("")) { if (bol.matches(RX_TRUE)) return true; @@ -309,8 +301,8 @@ public class CLParameters { return def; } - public String getString(String key, String paramName, String directive, String def) { - String vl = resolveKey(key); + public String getString(Tape<Object> params, String key, String paramName, String directive, String def) { + String vl = resolveKey(key).getValue(params); // @NOTE 9/19/17 // @@ -321,8 +313,8 @@ public class CLParameters { return def; } - public char getChar(String key, String paramName, String directive, char def) { - String param = resolveKey(key); + public char getChar(Tape<Object> params, String key, String paramName, String directive, char def) { + String param = resolveKey(key).getValue(params); if (!param.equals("")) { if (param.length() == 1) { @@ -342,8 +334,8 @@ public class CLParameters { return def; } - public int getInt(String key, String paramName, String directive, int def) { - String param = resolveKey(key); + public int getInt(Tape<Object> params, String key, String paramName, String directive, int def) { + String param = resolveKey(key).getValue(params); if (!param.equals("")) { try { diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/CLValue.java b/clformat/src/main/java/bjc/utils/ioutils/format/CLValue.java new file mode 100644 index 0000000..50aa681 --- /dev/null +++ b/clformat/src/main/java/bjc/utils/ioutils/format/CLValue.java @@ -0,0 +1,110 @@ +package bjc.utils.ioutils.format; + +import bjc.utils.esodata.*; + +/** + * Represents a parameter value to an edict that may have a dynamic value + * obtained from the format arguments. + * + * @author Ben Culkin + */ +public interface CLValue { + /** + * Create a CLValue from a string. + * + * @param val + * The string to create the value from. + */ + public static CLValue parse(String val) { + if (val.equalsIgnoreCase("V")) { + return new VValue(); + } + + switch (val) { + case "V": + case "v": + return new VValue(); + case "#": + return new HashValue(); + case "%": + return new PercValue(); + default: + return new LiteralValue(val); + } + } + + /** + * Get the value of the parameter. + * + * @param params + * The parameters passed to the directive. + */ + public String getValue(Tape<Object> params); +} + +class PercValue implements CLValue { + public String getValue(Tape<Object> params) { + return Integer.toString(params.position()); + } +} + +class HashValue implements CLValue { + public String getValue(Tape<Object> params) { + return (Integer.toString(params.size() - params.position())); + } +} + +class VValue implements CLValue { + public String getValue(Tape<Object> params) { + // Read parameter from items + Object par = params.item(); + boolean succ = params.right(); + + if(!succ) { + throw new IllegalStateException("Couldn't advance tape for parameter"); + } else if(par == null) { + throw new IllegalArgumentException( + "Expected a format parameter for V inline parameter"); + } + + if(par instanceof Number) { + int val = ((Number) par).intValue(); + + return Integer.toString(val); + } else if(par instanceof Character) { + char ch = ((Character) par); + + return Character.toString(ch); + } else if (par instanceof String) { + return (String) par; + } else { + String msg = "Incorrect type of parameter for V inline parameter"; + + throw new IllegalArgumentException(msg); + } + } +} + +class LiteralValue implements CLValue { + private String val; + + /** + * Create a new CLValue. + * + * @param vul + * The value of the parameter. + */ + public LiteralValue(String vul) { + val = vul; + } + + /** + * Get the value of the parameter. + * + * @param params + * The parameters passed to the directive. + */ + public String getValue(Tape<Object> params) { + return val; + } +} diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java index 513b7aa..d0a5d92 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/AestheticDirective.java @@ -1,9 +1,9 @@ package bjc.utils.ioutils.format.directives; -import java.io.IOException; +import java.io.*; -import bjc.utils.ioutils.format.CLFormatter; -import bjc.utils.ioutils.format.CLParameters; +import bjc.utils.esodata.*; +import bjc.utils.ioutils.format.*; /** * Implementation of the A directive. @@ -15,6 +15,8 @@ public class AestheticDirective implements Directive { @Override public void format(FormatParameters dirParams) throws IOException { + Tape<Object> itemTape = dirParams.tParams; + // Check that we have an item CLFormatter.checkItem(dirParams.item, 'A'); @@ -35,16 +37,16 @@ public class AestheticDirective implements Directive { case 1: params.mapIndices("mincol"); - mincol = params.getInt("mincol", "minimum column count", "A", 0); + mincol = params.getInt(itemTape, "mincol", "minimum column count", "A", 0); break; case 4: params.mapIndices("mincol", "colinc", "minpad", "padchar"); - mincol = params.getInt("mincol", "minimum column count", "A", 0); - colinc = params.getInt("colinc", "padding increment", "A", 1); - minpad = params.getInt("minpad", "minimum amount of padding", "A", 0); + mincol = params.getInt(itemTape, "mincol", "minimum column count", "A", 0); + colinc = params.getInt(itemTape, "colinc", "padding increment", "A", 1); + minpad = params.getInt(itemTape, "minpad", "minimum amount of padding", "A", 0); - padchar = params.getChar("padchar", "padding character", "A", ' '); + padchar = params.getChar(itemTape, "padchar", "padding character", "A", ' '); break; default: throw new IllegalArgumentException("Must provide either zero, one or four arguments to A directive"); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java index 55660ec..d4f9484 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/ConditionalDirective.java @@ -146,7 +146,8 @@ public class ConditionalDirective implements Directive { if (dirParams.arrParams.length() >= 1) { dirParams.arrParams.mapIndices("choice"); - res = dirParams.arrParams.getInt("choice", "conditional choice", "[", 0); + res = dirParams.arrParams.getInt(dirParams.tParams, + "choice", "conditional choice", "[", 0); } else { if (dirParams.item == null) { throw new IllegalArgumentException("No parameter provided for [ directive."); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/Directive.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/Directive.java index c9d0ca1..0813b23 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/Directive.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/Directive.java @@ -19,6 +19,18 @@ public interface Directive { public void format(FormatParameters dirParams) throws IOException; /** + * Compile this directive. + * + * @param compCTX + * The state necessary to compile this directive. + * + * @return A compiled form of this directive. + */ + public default Edict compile(CompileContext compCTX) { + throw new IllegalArgumentException("This directive does not support compilation yet"); + } + + /** * Check if a particular directive is an opening directive. * * @param str diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java index 233367f..0820c16 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/EscapeDirective.java @@ -1,7 +1,7 @@ package bjc.utils.ioutils.format.directives; -import bjc.utils.ioutils.format.CLParameters; -import bjc.utils.ioutils.format.EscapeException; +import bjc.utils.esodata.*; +import bjc.utils.ioutils.format.*; /** * Implementation for the ^ directive. @@ -12,6 +12,8 @@ public class EscapeDirective implements Directive { @Override public void format(FormatParameters dirParams) { + Tape<Object> itemTape = dirParams.tParams; + boolean shouldExit; if (dirParams.mods.dollarMod) dirParams.tParams.right(); @@ -23,15 +25,15 @@ public class EscapeDirective implements Directive { break; case 1: { params.mapIndices("count"); - int num = params.getInt("count", "condition count", "^", 0); + int num = params.getInt(itemTape, "count", "condition count", "^", 0); shouldExit = num == 0; break; } case 2: { params.mapIndices("lhand", "rhand"); - int left = params.getInt("lhand", "left-hand condition", "^", 0); - int right = params.getInt("rhand", "right-hand condition", "^", 0); + int left = params.getInt(itemTape, "lhand", "left-hand condition", "^", 0); + int right = params.getInt(itemTape, "rhand", "right-hand condition", "^", 0); shouldExit = left == right; break; @@ -40,9 +42,9 @@ public class EscapeDirective implements Directive { default: { params.mapIndices("lower", "ival", "upper"); - int low = params.getInt("lower", "lower-bound condition", "^", 0); - int mid = params.getInt("ival", "interval condition", "^", 0); - int high = params.getInt("upper", "upper-bound condition", "^", 0); + int low = params.getInt(itemTape, "lower", "lower-bound condition", "^", 0); + int mid = params.getInt(itemTape, "ival", "interval condition", "^", 0); + int high = params.getInt(itemTape, "upper", "upper-bound condition", "^", 0); shouldExit = (low <= mid) && (mid <= high); break; diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/FreshlineDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/FreshlineDirective.java index 710c3f5..3b54a92 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/FreshlineDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/FreshlineDirective.java @@ -1,6 +1,6 @@ package bjc.utils.ioutils.format.directives; -import java.io.IOException; +import java.io.*; /** * Implement the & directive. @@ -15,7 +15,8 @@ public class FreshlineDirective implements Directive { if(dirParams.arrParams.length() >= 1) { dirParams.arrParams.mapIndices("count"); - nTimes = dirParams.arrParams.getInt("count", "occurance count", "&", 1); + nTimes = dirParams.arrParams.getInt(dirParams.tParams, + "count", "occurance count", "&", 1); } if(dirParams.rw.isLastCharNL()) nTimes -= 1; diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java index 1d0ecdc..7f4cd02 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/GeneralNumberDirective.java @@ -1,11 +1,11 @@ package bjc.utils.ioutils.format.directives; -import java.io.IOException; +import java.io.*; -import bjc.utils.ioutils.ReportWriter; -import bjc.utils.ioutils.format.CLModifiers; -import bjc.utils.ioutils.format.CLParameters; -import bjc.utils.math.NumberUtils; +import bjc.utils.esodata.*; +import bjc.utils.ioutils.*; +import bjc.utils.ioutils.format.*; +import bjc.utils.math.*; /** * Implementation skeleton for number directives. @@ -14,7 +14,7 @@ import bjc.utils.math.NumberUtils; * */ public abstract class GeneralNumberDirective implements Directive { - protected static void handleNumberDirective(ReportWriter rw, CLModifiers mods, CLParameters params, int argidx, + protected static void handleNumberDirective(Tape<Object> itemTape, ReportWriter rw, CLModifiers mods, CLParameters params, int argidx, long val, int radix) throws IOException { /* @@ -25,12 +25,12 @@ public abstract class GeneralNumberDirective implements Directive { char padchar = ' '; if (params.length() >= (argidx + 2)) { params.mapIndex("mincol", argidx + 1); - mincol = params.getInt("mincol", "minimum column count", "R", 0); + mincol = params.getInt(itemTape, "mincol", "minimum column count", "R", 0); } if (params.length() >= (argidx + 3)) { params.mapIndex("padchar", argidx + 2); - padchar = params.getChar("padchar", "padding character", "R", ' '); + padchar = params.getChar(itemTape, "padchar", "padding character", "R", ' '); } String res; @@ -43,15 +43,13 @@ public abstract class GeneralNumberDirective implements Directive { int commaInterval = 0; char commaChar = ','; - // System.err.printf("Comma params (idx %d, len %d): char \"%s\", int \"%s\"\n", argidx, params.length(), params.getRaw(argidx + 3), params.getRaw(argidx + 4)); - if (params.length() >= (argidx + 4)) { params.mapIndex("cchar", argidx + 3); - commaChar = params.getChar("cchar", "comma character", "R", ','); + commaChar = params.getChar(itemTape, "cchar", "comma character", "R", ','); } if (params.length() >= (argidx + 5)) { params.mapIndex("cinterval", argidx + 4); - commaInterval = params.getInt("cinterval", "comma interval", "R", 0); + commaInterval = params.getInt(itemTape, "cinterval", "comma interval", "R", 0); } res = NumberUtils.toCommaString(val, mincol, padchar, commaInterval, commaChar, mods.atMod, radix); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/GotoDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/GotoDirective.java index 5c457b0..941b74d 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/GotoDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/GotoDirective.java @@ -1,6 +1,7 @@ package bjc.utils.ioutils.format.directives; -import bjc.utils.ioutils.format.CLParameters; +import bjc.utils.esodata.*; +import bjc.utils.ioutils.format.*; /** * Implement the * directive. @@ -12,13 +13,15 @@ public class GotoDirective implements Directive { @Override public void format(FormatParameters dirParams) { + Tape<Object> itemTape = dirParams.tParams; + CLParameters params = dirParams.arrParams; if (dirParams.mods.colonMod) { int num = 1; if (params.length() >= 1) { params.mapIndices("numargs"); - num = params.getInt("numargs", "number of arguments backward", "*", 1); + num = params.getInt(itemTape, "numargs", "number of arguments backward", "*", 1); } dirParams.tParams.left(num); @@ -27,7 +30,7 @@ public class GotoDirective implements Directive { if (params.length() >= 1) { params.mapIndices("argidx"); - num = params.getInt("argidx", "argument index", "*", 0); + num = params.getInt(itemTape, "argidx", "argument index", "*", 0); } dirParams.tParams.first(); @@ -37,7 +40,7 @@ public class GotoDirective implements Directive { if (params.length() >= 1) { params.mapIndices("numargs"); - num = params.getInt("numargs", "number of arguments forward", "*", 1); + num = params.getInt(itemTape, "numargs", "number of arguments forward", "*", 1); } dirParams.tParams.right(num); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/IndentDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/IndentDirective.java index 21e5535..a6354f8 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/IndentDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/IndentDirective.java @@ -1,6 +1,8 @@ package bjc.utils.ioutils.format.directives; -import java.io.IOException; +import java.io.*; + +import bjc.utils.esodata.*; /** * Implement the I directive. @@ -8,12 +10,12 @@ import java.io.IOException; * */ public class IndentDirective implements Directive { - @Override public void format(FormatParameters dirParams) throws IOException { + Tape<Object> itemTape = dirParams.tParams; + // Dollar mod is indent configuration if (dirParams.mods.dollarMod) { - return; } @@ -22,7 +24,7 @@ public class IndentDirective implements Directive { if(dirParams.arrParams.length() >= 1) { dirParams.arrParams.mapIndices("count"); - nIndents = dirParams.arrParams.getInt("count", "indent count", "I", 1); + nIndents = dirParams.arrParams.getInt(itemTape, "count", "indent count", "I", 1); } boolean dedent = false; diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java index b4d7c33..be5d48e 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/IterationDirective.java @@ -71,7 +71,8 @@ public class IterationDirective implements Directive { if (params.length() > 0) { params.mapIndices("maxitr"); - maxItr = params.getInt("maxitr", "maximum iterations", "{", Integer.MAX_VALUE); + maxItr = params.getInt(dirParams.tParams, "maxitr", + "maximum iterations", "{", Integer.MAX_VALUE); } int numItr = 0; diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/LiteralDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/LiteralDirective.java index 1e71777..e603305 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/LiteralDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/LiteralDirective.java @@ -9,7 +9,6 @@ import java.io.IOException; * */ public class LiteralDirective implements Directive { - private String directive; private String lit; @@ -33,7 +32,7 @@ public class LiteralDirective implements Directive { if (dirParams.arrParams.length() >= 1) { dirParams.arrParams.mapIndices("count"); - nTimes = dirParams.arrParams.getInt("count", "occurance count", directive, 1); + nTimes = dirParams.arrParams.getInt(dirParams.tParams, "count", "occurance count", directive, 1); } for (int i = 0; i < nTimes; i++) { @@ -42,4 +41,29 @@ public class LiteralDirective implements Directive { } + @Override + public Edict compile(CompileContext compCTX) { + int nTimes = 1; + + LiteralEdict edict = new LiteralEdict(lit, nTimes); + + return edict; + } +} + +/* + * Compiled version of the directive. + */ +class LiteralEdict implements Edict { + private String lit; + private int nTimes; + + public LiteralEdict(String lit, int nTimes) { + + } + + @Override + public void format(FormatContext formCTX) { + + } } diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java index 338cd61..68b5873 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/NumberDirective.java @@ -12,7 +12,6 @@ import bjc.utils.ioutils.format.CLFormatter; * */ public class NumberDirective extends GeneralNumberDirective { - /** * Create a new radix based number directive. * @@ -43,7 +42,8 @@ public class NumberDirective extends GeneralNumberDirective { long val = ((Number) dirParams.item).longValue(); - handleNumberDirective(dirParams.rw, dirParams.mods, dirParams.arrParams, argidx, val, radix); + handleNumberDirective(dirParams.tParams, dirParams.rw, + dirParams.mods, dirParams.arrParams, argidx, val, radix); dirParams.tParams.right(); } diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/RadixDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/RadixDirective.java index 4696c60..87fba8e 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/RadixDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/RadixDirective.java @@ -43,9 +43,10 @@ public class RadixDirective extends GeneralNumberDirective { params.mapIndex("radix", 0); - int radix = params.getInt("radix", "radix", "R", 10); + int radix = params.getInt(dirParams.tParams, "radix", "radix", "R", 10); - handleNumberDirective(dirParams.rw, dirParams.mods, params, 0, val, radix); + handleNumberDirective(dirParams.tParams, dirParams.rw, + dirParams.mods, params, 0, val, radix); } dirParams.tParams.right(); diff --git a/clformat/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java b/clformat/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java index d0bd55b..a06e585 100644 --- a/clformat/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java +++ b/clformat/src/main/java/bjc/utils/ioutils/format/directives/TabulateDirective.java @@ -1,11 +1,14 @@ package bjc.utils.ioutils.format.directives; -import java.io.IOException; +import java.io.*; -import bjc.utils.ioutils.format.CLParameters; +import bjc.utils.esodata.*; +import bjc.utils.ioutils.format.*; public class TabulateDirective implements Directive { public void format(FormatParameters dirParams) throws IOException { + Tape<Object> itemTape = dirParams.tParams; + // Support for a possible future feature char padchar = ' '; @@ -22,13 +25,13 @@ public class TabulateDirective implements Directive { if (params.length() > 2) { params.mapIndex("colinc", 1); - colinc = params.getInt("colinc", "column increment", "T", 1); + colinc = params.getInt(itemTape, "colinc", "column increment", "T", 1); } if (params.length() > 1) { params.mapIndices("colrel"); - colrel = params.getInt("colrel", "relative column number", "T", 1); + colrel = params.getInt(itemTape, "colrel", "relative column number", "T", 1); } for (int i = 0; i < colrel; i++) { @@ -48,13 +51,13 @@ public class TabulateDirective implements Directive { if (params.length() > 2) { params.mapIndex("colinc", 1); - colinc = params.getInt("colinc", "column increment", "T", 1); + colinc = params.getInt(itemTape, "colinc", "column increment", "T", 1); } if (params.length() > 1) { params.mapIndices("colnum"); - colnum = params.getInt("colnum", "column number", "T", 1); + colnum = params.getInt(itemTape, "colnum", "column number", "T", 1); } if (currCol < colnum) { |