X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fbin%2Fargparser%2FArgParser.java;h=f08e678112d83ba1221b6f05f293ad1f1397c5ff;hb=bda60947eaabb464920b733509ace12e745f3910;hp=7132e89e20d281598d7377a68d12f2469cc21b75;hpb=42611e30f90d424925aec52da4d82256690dfdbe;p=jalview.git diff --git a/src/jalview/bin/argparser/ArgParser.java b/src/jalview/bin/argparser/ArgParser.java index 7132e89..f08e678 100644 --- a/src/jalview/bin/argparser/ArgParser.java +++ b/src/jalview/bin/argparser/ArgParser.java @@ -38,11 +38,14 @@ import jalview.bin.Cache; import jalview.bin.Console; import jalview.bin.Jalview; import jalview.bin.argparser.Arg.Opt; +import jalview.bin.argparser.Arg.Type; import jalview.util.FileUtils; import jalview.util.HttpUtils; public class ArgParser { + protected static final String SINGLEDASH = "-"; + protected static final String DOUBLEDASH = "--"; protected static final char EQUALS = '='; @@ -81,6 +84,11 @@ public class ArgParser // the linked id substitution string used to use the idCounter private static final String LINKEDIDAUTOCOUNTER = "{n}"; + // the linked id substitution string used to use the filename extension of + // --append + // or --open + private static final String LINKEDIDEXTENSION = "{extension}"; + // the linked id substitution string used to use the base filename of --append // or --open private static final String LINKEDIDBASENAME = "{basename}"; @@ -100,10 +108,6 @@ public class ArgParser // --argfile name private static final String ARGFILEDIRNAME = "{argfiledirname}"; - // an output file wildcard to signify --output=*.ext is really --all --output - // {basename}.ext - private static final String OUTPUTWILDCARD = "*."; - // flag to say whether {n} subtitutions in output filenames should be made. // Turn on and off with --substitutions and --nosubstitutions // Start with it on @@ -117,6 +121,10 @@ public class ArgParser // or OPENED linkedIds private boolean openedLinkedIds = false; + // flag to say whether the structure arguments should be applied to all + // structures with this linked id + private boolean allStructures = false; + protected static final Map argMap; protected Map linkedArgs = new HashMap<>(); @@ -143,8 +151,7 @@ public class ArgParser if (argMap.containsKey(argName)) { Console.warn("Trying to add argument name multiple times: '" - + argName + "'"); // RESTORE THIS WHEN - // MERGED + + argName + "'"); if (argMap.get(argName) != a) { Console.error( @@ -241,13 +248,17 @@ public class ArgParser openEachInitialFilenames = false; } - String argName = null; - String val = null; - List globVals = null; // for Opt.GLOB only - SubVals globSubVals = null; // also for use by Opt.GLOB only - String linkedId = null; + // look for double-dash, e.g. --arg if (arg.startsWith(DOUBLEDASH)) { + String argName = null; + String val = null; + List globVals = null; // for Opt.GLOB only + SubVals globSubVals = null; // also for use by Opt.GLOB only + String linkedId = null; + Type type = null; + + // look for equals e.g. --arg=value int equalPos = arg.indexOf(EQUALS); if (equalPos > -1) { @@ -258,17 +269,38 @@ public class ArgParser { argName = arg.substring(DOUBLEDASH.length()); } + + // look for linked ID e.g. --arg[linkedID] int idOpen = argName.indexOf('['); int idClose = argName.indexOf(']'); - if (idOpen > -1 && idClose == argName.length() - 1) { linkedId = argName.substring(idOpen + 1, idClose); argName = argName.substring(0, idOpen); } + // look for type modification e.g. --help-opening + int dashPos = argName.indexOf(SINGLEDASH); + if (dashPos > -1) + { + String potentialArgName = argName.substring(0, dashPos); + Arg potentialArg = argMap.get(potentialArgName); + if (potentialArg != null && potentialArg.hasOption(Opt.HASTYPE)) + { + String typeName = argName.substring(dashPos + 1); + try + { + type = Type.valueOf(typeName); + } catch (IllegalArgumentException e) + { + type = Type.INVALID; + } + argName = argName.substring(0, dashPos); + } + } + Arg a = argMap.get(argName); - // check for boolean prepended by "no" + // check for boolean prepended by "no" e.g. --nowrap boolean negated = false; if (a == null && argName.startsWith(NEGATESTRING) && argMap .containsKey(argName.substring(NEGATESTRING.length()))) @@ -396,6 +428,10 @@ public class ArgParser openedLinkedIds = !negated; allLinkedIds = false; } + else if (a == Arg.ALLSTRUCTURES) + { + allStructures = !negated; + } if (a.hasOption(Opt.STORED)) { @@ -411,14 +447,13 @@ public class ArgParser } String autoCounterString = null; - boolean usingAutoCounterLinkedId = false; String defaultLinkedId = defaultLinkedId(false); boolean usingDefaultLinkedId = false; if (a.hasOption(Opt.LINKED)) { if (linkedId == null) { - if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL) + if (a.hasOption(Opt.OUTPUTFILE) && a.hasOption(Opt.ALLOWALL) && val.startsWith(MATCHALLLINKEDIDS)) { // --output=*.ext is shorthand for --all --output {basename}.ext @@ -429,7 +464,7 @@ public class ArgParser val = LINKEDIDDIRNAME + File.separator + LINKEDIDBASENAME + val.substring(MATCHALLLINKEDIDS.length()); } - else if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL) + else if (a.hasOption(Opt.OUTPUTFILE) && a.hasOption(Opt.ALLOWALL) && val.startsWith(MATCHOPENEDLINKEDIDS)) { // --output=open*.ext is shorthand for --opened --output @@ -458,25 +493,26 @@ public class ArgParser + arg); } } - else if (linkedId.contains(LINKEDIDAUTOCOUNTER)) - { - // turn {n} to the autoCounter - autoCounterString = Integer.toString(linkedIdAutoCounter); - linkedId = linkedId.replace(LINKEDIDAUTOCOUNTER, - autoCounterString); - usingAutoCounterLinkedId = true; - Console.debug( - "Changing linkedId to '" + linkedId + "' from " + arg); - } - else if (linkedId.contains(INCREMENTLINKEDIDAUTOCOUNTER)) + else { - // turn {++n} to the incremented autoCounter - autoCounterString = Integer.toString(++linkedIdAutoCounter); - linkedId = linkedId.replace(INCREMENTLINKEDIDAUTOCOUNTER, - autoCounterString); - usingAutoCounterLinkedId = true; - Console.debug( - "Changing linkedId to '" + linkedId + "' from " + arg); + if (linkedId.contains(LINKEDIDAUTOCOUNTER)) + { + // turn {n} to the autoCounter + autoCounterString = Integer.toString(linkedIdAutoCounter); + linkedId = linkedId.replace(LINKEDIDAUTOCOUNTER, + autoCounterString); + Console.debug("Changing linkedId to '" + linkedId + "' from " + + arg); + } + if (linkedId.contains(INCREMENTLINKEDIDAUTOCOUNTER)) + { + // turn {++n} to the incremented autoCounter + autoCounterString = Integer.toString(++linkedIdAutoCounter); + linkedId = linkedId.replace(INCREMENTLINKEDIDAUTOCOUNTER, + autoCounterString); + Console.debug("Changing linkedId to '" + linkedId + "' from " + + arg); + } } } @@ -496,8 +532,9 @@ public class ArgParser } // check for unique id - SubVals idsv = new SubVals(val); - String id = idsv.get(ArgValues.ID); + SubVals subvals = new SubVals(val); + boolean addNewSubVals = false; + String id = subvals.get(ArgValues.ID); if (id != null && avm.hasId(a, id)) { Console.error("Argument '" + a.argString() @@ -505,10 +542,21 @@ public class ArgParser continue; } - /* TODO - * Change all avs.addValue() avs.setBoolean avs.setNegated() avs.incrementCount calls to checkfor linkedId == "*" - * DONE, need to check - */ + // set allstructures to all non-primary structure options in this linked + // id if --allstructures has been set + if (allStructures + && (a.getType() == Type.STRUCTURE + || a.getType() == Type.STRUCTUREIMAGE) + && !a.hasOption(Opt.PRIMARY)) + { + if (!subvals.has(Arg.ALLSTRUCTURES.getName())) + // && !subvals.has("structureid")) + { + subvals.put(Arg.ALLSTRUCTURES.getName(), "true"); + addNewSubVals = true; + } + } + ArgValues avs = avm.getOrCreateArgValues(a); // store appropriate String value(s) @@ -522,7 +570,7 @@ public class ArgParser { String v = gve.nextElement(); SubVals vsv = new SubVals(globSubVals, v); - addValue(linkedId, avs, vsv, v, argIndex++, true); + addValue(linkedId, type, avs, vsv, v, argIndex++, true); // if we're using defaultLinkedId and the arg increments the // counter: if (gve.hasMoreElements() && usingDefaultLinkedId @@ -538,17 +586,19 @@ public class ArgParser } else { - addValue(linkedId, avs, val, argIndex, true); + // addValue(linkedId, type, avs, val, argIndex, true); + addValue(linkedId, type, avs, addNewSubVals ? subvals : null, + val, argIndex, true); } } else if (a.hasOption(Opt.BOOLEAN)) { - setBoolean(linkedId, avs, !negated, argIndex); + setBoolean(linkedId, type, avs, !negated, argIndex); setNegated(linkedId, avs, negated); } else if (a.hasOption(Opt.UNARY)) { - setBoolean(linkedId, avs, true, argIndex); + setBoolean(linkedId, type, avs, true, argIndex); } // remove the '*' or 'open*' linkedId that should be empty if it was @@ -637,6 +687,10 @@ public class ArgParser { rest = rest.replace(LINKEDIDBASENAME, avm.getBasename()); } + if (rest.contains(LINKEDIDEXTENSION)) + { + rest = rest.replace(LINKEDIDEXTENSION, avm.getExtension()); + } if (rest.contains(LINKEDIDDIRNAME)) { rest = rest.replace(LINKEDIDDIRNAME, avm.getDirname()); @@ -896,8 +950,23 @@ public class ArgParser else if (pos == Position.AFTER && avm.getClosestNextArgValueOfArg(av, a) != null) value = avm.getClosestNextArgValueOfArg(av, a).getValue(); + + // look for allstructures subval for Type.STRUCTURE* + Arg arg = av.getArg(); + if (value == null && arg.hasOption(Opt.PRIMARY) + && arg.getType() == Type.STRUCTURE + && !a.hasOption(Opt.PRIMARY) && (a.getType() == Type.STRUCTURE + || a.getType() == Type.STRUCTUREIMAGE)) + { + ArgValue av2 = avm.getArgValueOfArgWithSubValKey(a, + Arg.ALLSTRUCTURES.getName()); + if (av2 != null) + { + value = av2.getValue(); + } + } } - else + if (value == null) { value = pref != null ? Cache.getDefault(pref, def) : def; } @@ -913,6 +982,13 @@ public class ArgParser public static boolean getFromSubValArgOrPref(ArgValuesMap avm, Arg a, SubVals sv, String key, String pref, boolean def) { + return getFromSubValArgOrPref(avm, a, sv, key, pref, def, false); + } + + public static boolean getFromSubValArgOrPref(ArgValuesMap avm, Arg a, + SubVals sv, String key, String pref, boolean def, + boolean invertPref) + { if ((key == null && a == null) || (sv == null && a == null)) return false; @@ -966,351 +1042,79 @@ public class ArgParser return avm.getBoolean(a); // return preference or default - return pref != null ? Cache.getDefault(pref, def) : def; + boolean prefVal = pref != null ? Cache.getDefault(pref, def) : false; + return pref != null ? (invertPref ? !prefVal : prefVal) : def; } // the following methods look for the "*" linkedId and add the argvalue to all // linkedId ArgValues if it does. // This version inserts the subvals sv into all created values - private void addValue(String linkedId, ArgValues avs, SubVals sv, - String v, int argIndex, boolean doSubs) + private void addValue(String linkedId, Type type, ArgValues avs, + SubVals sv, String v, int argIndex, boolean doSubs) { - this.argValueOperation(Op.ADDVALUE, linkedId, avs, sv, v, false, + this.argValueOperation(Op.ADDVALUE, linkedId, type, avs, sv, v, false, argIndex, doSubs); } - private void NOTaddValue(String linkedId, ArgValues avs, SubVals sv, - String v, int argIndex, boolean doSubs) - { - Arg a = avs.arg(); - - List wildcardLinkedIds = null; - if (a.hasOption(Opt.ALLOWALL)) - { - switch (linkedId) - { - case MATCHALLLINKEDIDS: - wildcardLinkedIds = getLinkedIds(); - break; - case MATCHOPENEDLINKEDIDS: - wildcardLinkedIds = this.storedLinkedIds; - break; - } - } - - // if we're not a wildcard linkedId and the arg is marked to be stored, add - // to storedLinkedIds - if (linkedId != null && wildcardLinkedIds == null - && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - // if we are a wildcard linkedId, apply the arg and value to all appropriate - // linkedIds - if (wildcardLinkedIds != null) - { - for (String id : wildcardLinkedIds) - { - // skip incorrectly stored wildcard ids! - if (id == null || MATCHALLLINKEDIDS.equals(id) - || MATCHOPENEDLINKEDIDS.equals(id)) - continue; - ArgValuesMap avm = linkedArgs.get(id); - if (a.hasOption(Opt.REQUIREINPUT) - && !avm.hasArgWithOption(Opt.INPUT)) - continue; - ArgValues tavs = avm.getOrCreateArgValues(a); - String val = v; - if (doSubs) - { - val = makeSubstitutions(v, id); - sv = new SubVals(sv, val); - } - tavs.addValue(sv, val, argIndex); - finaliseStoringArgValue(id, tavs); - } - } - else - { - String val = v; - if (doSubs) - { - val = makeSubstitutions(v, linkedId); - sv = new SubVals(sv, val); - } - avs.addValue(sv, val, argIndex); - finaliseStoringArgValue(linkedId, avs); - } - } - - private void addValue(String linkedId, ArgValues avs, String v, + private void addValue(String linkedId, Type type, ArgValues avs, String v, int argIndex, boolean doSubs) { - this.argValueOperation(Op.ADDVALUE, linkedId, avs, null, v, false, + this.argValueOperation(Op.ADDVALUE, linkedId, type, avs, null, v, false, argIndex, doSubs); } - // the following methods look for the "*" linkedId and add the argvalue to all - // linkedId ArgValues if it does. - private void NOTaddValue(String linkedId, ArgValues avs, String v, - int argIndex, boolean doSubs) - { - Arg a = avs.arg(); - if (linkedId != null && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - List wildcardLinkedIds = null; - if (a.hasOption(Opt.ALLOWALL)) - { - switch (linkedId) - { - case MATCHALLLINKEDIDS: - wildcardLinkedIds = getLinkedIds(); - break; - case MATCHOPENEDLINKEDIDS: - wildcardLinkedIds = this.storedLinkedIds; - break; - } - } - - // if we're not a wildcard linkedId and the arg is marked to be stored, add - // to storedLinkedIds - if (linkedId != null && wildcardLinkedIds == null - && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - // if we are a wildcard linkedId, apply the arg and value to all appropriate - // linkedIds - if (wildcardLinkedIds != null) - { - for (String id : wildcardLinkedIds) - { - // skip incorrectly stored wildcard ids! - if (id == null || MATCHALLLINKEDIDS.equals(id) - || MATCHOPENEDLINKEDIDS.equals(id)) - continue; - ArgValuesMap avm = linkedArgs.get(id); - // don't set an output if there isn't an input - if (a.hasOption(Opt.REQUIREINPUT) - && !avm.hasArgWithOption(Opt.INPUT)) - continue; - ArgValues tavs = avm.getOrCreateArgValues(a); - String val = doSubs ? makeSubstitutions(v, id) : v; - tavs.addValue(val, argIndex); - finaliseStoringArgValue(id, tavs); - } - } - else - { - String val = doSubs ? makeSubstitutions(v, linkedId) : v; - avs.addValue(val, argIndex); - finaliseStoringArgValue(linkedId, avs); - } - } - - private void setBoolean(String linkedId, ArgValues avs, boolean b, - int argIndex) + private void setBoolean(String linkedId, Type type, ArgValues avs, + boolean b, int argIndex) { - this.argValueOperation(Op.SETBOOLEAN, linkedId, avs, null, null, b, - argIndex, false); - } - - private void NOTsetBoolean(String linkedId, ArgValues avs, boolean b, - int argIndex) - { - Arg a = avs.arg(); - if (linkedId != null && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - List wildcardLinkedIds = null; - if (a.hasOption(Opt.ALLOWALL)) - { - switch (linkedId) - { - case MATCHALLLINKEDIDS: - wildcardLinkedIds = getLinkedIds(); - break; - case MATCHOPENEDLINKEDIDS: - wildcardLinkedIds = this.storedLinkedIds; - break; - } - } - - // if we're not a wildcard linkedId and the arg is marked to be stored, add - // to storedLinkedIds - if (linkedId != null && wildcardLinkedIds == null - && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - // if we are a wildcard linkedId, apply the arg and value to all appropriate - // linkedIds - if (wildcardLinkedIds != null) - { - for (String id : wildcardLinkedIds) - { - // skip incorrectly stored wildcard ids! - if (id == null || MATCHALLLINKEDIDS.equals(id) - || MATCHOPENEDLINKEDIDS.equals(id)) - continue; - ArgValuesMap avm = linkedArgs.get(id); - if (a.hasOption(Opt.REQUIREINPUT) - && !avm.hasArgWithOption(Opt.INPUT)) - continue; - ArgValues tavs = avm.getOrCreateArgValues(a); - tavs.setBoolean(b, argIndex); - finaliseStoringArgValue(id, tavs); - } - } - else - { - avs.setBoolean(b, argIndex); - finaliseStoringArgValue(linkedId, avs); - } + this.argValueOperation(Op.SETBOOLEAN, linkedId, type, avs, null, null, + b, argIndex, false); } private void setNegated(String linkedId, ArgValues avs, boolean b) { - this.argValueOperation(Op.SETNEGATED, linkedId, avs, null, null, b, 0, - false); - } - - private void NOTsetNegated(String linkedId, ArgValues avs, boolean b) - { - Arg a = avs.arg(); - if (linkedId != null && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - List wildcardLinkedIds = null; - if (a.hasOption(Opt.ALLOWALL)) - { - switch (linkedId) - { - case MATCHALLLINKEDIDS: - wildcardLinkedIds = getLinkedIds(); - break; - case MATCHOPENEDLINKEDIDS: - wildcardLinkedIds = this.storedLinkedIds; - break; - } - } - - // if we're not a wildcard linkedId and the arg is marked to be stored, add - // to storedLinkedIds - if (linkedId != null && wildcardLinkedIds == null - && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - // if we are a wildcard linkedId, apply the arg and value to all appropriate - // linkedIds - if (wildcardLinkedIds != null) - { - for (String id : wildcardLinkedIds) - { - // skip incorrectly stored wildcard ids! - if (id == null || MATCHALLLINKEDIDS.equals(id) - || MATCHOPENEDLINKEDIDS.equals(id)) - continue; - ArgValuesMap avm = linkedArgs.get(id); - if (a.hasOption(Opt.REQUIREINPUT) - && !avm.hasArgWithOption(Opt.INPUT)) - continue; - ArgValues tavs = avm.getOrCreateArgValues(a); - tavs.setNegated(b); - } - } - else - { - avs.setNegated(b); - } + this.argValueOperation(Op.SETNEGATED, linkedId, null, avs, null, null, + b, 0, false); } private void incrementCount(String linkedId, ArgValues avs) { - this.argValueOperation(Op.INCREMENTCOUNT, linkedId, avs, null, null, - false, 0, false); + this.argValueOperation(Op.INCREMENTCOUNT, linkedId, null, avs, null, + null, false, 0, false); } - private void NOTincrementCount(String linkedId, ArgValues avs) + private enum Op { - Arg a = avs.arg(); - - List wildcardLinkedIds = null; - if (a.hasOption(Opt.ALLOWALL)) - { - switch (linkedId) - { - case MATCHALLLINKEDIDS: - wildcardLinkedIds = getLinkedIds(); - break; - case MATCHOPENEDLINKEDIDS: - wildcardLinkedIds = this.storedLinkedIds; - break; - } - } - - // if we're not a wildcard linkedId and the arg is marked to be stored, add - // to storedLinkedIds - if (linkedId != null && wildcardLinkedIds == null - && a.hasOption(Opt.STORED) - && !storedLinkedIds.contains(linkedId)) - { - storedLinkedIds.add(linkedId); - } - - // if we are a wildcard linkedId, apply the arg and value to all appropriate - // linkedIds - if (wildcardLinkedIds != null) - { - for (String id : wildcardLinkedIds) - { - // skip incorrectly stored wildcard ids! - if (id == null || MATCHALLLINKEDIDS.equals(id) - || MATCHOPENEDLINKEDIDS.equals(id)) - continue; - ArgValuesMap avm = linkedArgs.get(id); - if (a.hasOption(Opt.REQUIREINPUT) - && !avm.hasArgWithOption(Opt.INPUT)) - continue; - ArgValues tavs = avm.getOrCreateArgValues(a); - tavs.incrementCount(); - } - } - else - { - avs.incrementCount(); - } + ADDVALUE, SETBOOLEAN, SETNEGATED, INCREMENTCOUNT } - private enum Op + private void argValueOperation(Op op, String linkedId, Type type, + ArgValues avs, SubVals sv, String v, boolean b, int argIndex, + boolean doSubs) { - ADDVALUE, SETBOOLEAN, SETNEGATED, INCREMENTCOUNT + // default to merge subvals if subvals are provided + argValueOperation(op, linkedId, type, avs, sv, true, v, b, argIndex, + doSubs); } - // The following operations look for the "*" and "open*" linkedIds and add the - // argvalue to all appropriate linkedId ArgValues if it does. - // If subvals are supplied, they are inserted into all new set values. - private void argValueOperation(Op op, String linkedId, ArgValues avs, - SubVals sv, String v, boolean b, int argIndex, boolean doSubs) + /* + * The following operations look for the "*" and "open*" linkedIds and add the + * argvalue to all appropriate linkedId ArgValues if it does. + * If subvals are supplied, they are inserted into all new set values. + * + * @param op The ArgParser.Op operation + * @param linkedId The String linkedId from the ArgValuesMap + * @param type The Arg.Type to attach to this ArgValue + * @param avs The ArgValues for this linkedId + * @param sv Use these SubVals on the ArgValue + * @param merge Merge the SubVals with any existing on the value. False will replace unless sv is null + * @param v The value of the ArgValue (may contain subvals). + * @param b The boolean value of the ArgValue. + * @param argIndex The argIndex for the ArgValue. + * @param doSubs Whether to perform substitutions on the subvals and value. + */ + private void argValueOperation(Op op, String linkedId, Type type, + ArgValues avs, SubVals sv, boolean merge, String v, boolean b, + int argIndex, boolean doSubs) { Arg a = avs.arg(); @@ -1363,10 +1167,10 @@ public class ArgParser { if (doSubs) { - val = makeSubstitutions(v, id); - sv = new SubVals(sv, val); + sv = new SubVals(sv, val, merge); + val = makeSubstitutions(sv.getContent(), id); } - tavs.addValue(sv, val, argIndex); + tavs.addValue(sv, type, val, argIndex, true); } else { @@ -1374,18 +1178,18 @@ public class ArgParser { val = makeSubstitutions(v, id); } - tavs.addValue(val, argIndex); + tavs.addValue(type, val, argIndex, true); } finaliseStoringArgValue(id, tavs); break; case SETBOOLEAN: - tavs.setBoolean(b, argIndex); + tavs.setBoolean(type, b, argIndex, true); finaliseStoringArgValue(id, tavs); break; case SETNEGATED: - tavs.setNegated(b); + tavs.setNegated(b, true); break; case INCREMENTCOUNT: @@ -1412,7 +1216,7 @@ public class ArgParser val = makeSubstitutions(v, linkedId); sv = new SubVals(sv, val); } - avs.addValue(sv, val, argIndex); + avs.addValue(sv, type, val, argIndex, false); } else { @@ -1420,18 +1224,18 @@ public class ArgParser { val = makeSubstitutions(v, linkedId); } - avs.addValue(val, argIndex); + avs.addValue(type, val, argIndex, false); } finaliseStoringArgValue(linkedId, avs); break; case SETBOOLEAN: - avs.setBoolean(b, argIndex); + avs.setBoolean(type, b, argIndex, false); finaliseStoringArgValue(linkedId, avs); break; case SETNEGATED: - avs.setNegated(b); + avs.setNegated(b, false); break; case INCREMENTCOUNT: