X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fjalview%2Fbin%2Fargparser%2FArgParser.java;h=223cc53bacb9a8edd0e3c8f14fca7f18c441b519;hb=ec24991b1786e17158a43f713c8ae9c4f8647393;hp=82b1b92a193b7e5642c905ee1acc49bdc217f539;hpb=2e59bc7938c0f10bde61fd30d1841bedb3d8319e;p=jalview.git diff --git a/src/jalview/bin/argparser/ArgParser.java b/src/jalview/bin/argparser/ArgParser.java index 82b1b92..223cc53 100644 --- a/src/jalview/bin/argparser/ArgParser.java +++ b/src/jalview/bin/argparser/ArgParser.java @@ -26,49 +26,99 @@ import java.nio.file.Files; import java.nio.file.Paths; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.EnumSet; +import java.util.Enumeration; import java.util.HashMap; import java.util.List; import java.util.Locale; import java.util.Map; +import jalview.bin.Cache; import jalview.bin.Console; import jalview.bin.Jalview; import jalview.bin.argparser.Arg.Opt; import jalview.util.FileUtils; +import jalview.util.HttpUtils; public class ArgParser { protected static final String DOUBLEDASH = "--"; + protected static final char EQUALS = '='; + protected static final String NEGATESTRING = "no"; // the default linked id prefix used for no id (not even square braces) protected static final String DEFAULTLINKEDIDPREFIX = "JALVIEW:"; + // the linkedId string used to match all linkedIds seen so far + protected static final String MATCHALLLINKEDIDS = "*"; + // the counter added to the default linked id prefix private int defaultLinkedIdCounter = 0; - // the linked id used to increment the idCounter (and use the incremented - // value) - private static final String INCREMENTAUTOCOUNTERLINKEDID = "{++n}"; + // the substitution string used to use the defaultLinkedIdCounter + private static final String DEFAULTLINKEDIDCOUNTER = "{}"; + + // the counter added to the default linked id prefix. NOW using + // linkedIdAutoCounter + // private int openLinkedIdCounter = 0; + + // the linked id prefix used for --open files. NOW the same as DEFAULT + protected static final String OPENLINKEDIDPREFIX = DEFAULTLINKEDIDPREFIX; + + // the counter used for {n} substitutions + private int linkedIdAutoCounter = 0; + + // the linked id substitution string used to increment the idCounter (and use + // the incremented value) + private static final String INCREMENTLINKEDIDAUTOCOUNTER = "{++n}"; + + // 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 base filename of --append + // or --open + private static final String LINKEDIDBASENAME = "{basename}"; - // the linked id used to use the idCounter - private static final String AUTOCOUNTERLINKEDID = "{n}"; + // the linked id substitution string used to use the dir path of --append + // or --open + private static final String LINKEDIDDIRNAME = "{dirname}"; - private int idCounter = 0; + // the current argfile + private String argFile = null; + + // the linked id substitution string used to use the dir path of the latest + // --argfile name + private static final String ARGFILEBASENAME = "{argfilebasename}"; + + // the linked id substitution string used to use the dir path of the latest + // --argfile name + private static final String ARGFILEDIRNAME = "{argfiledirname}"; // flag to say whether {n} subtitutions in output filenames should be made. - // Turn on and off with --subs and --nosubs - private boolean substitutions = false; + // Turn on and off with --substitutions and --nosubstitutions + // Start with it on + private boolean substitutions = true; + + // flag to say whether the default linkedId is the current default linked id + // or ALL linkedIds + private boolean allLinkedIds = false; protected static final Map argMap; protected Map linkedArgs = new HashMap<>(); - protected List linkedOrder = null; + protected List linkedOrder = new ArrayList<>(); + + protected List argList = new ArrayList<>(); - protected List argList; + private static final char ARGFILECOMMENT = '#'; + + private int argIndex = 0; + + private BootstrapArgs bootstrapArgs = null; static { @@ -80,7 +130,8 @@ public class ArgParser if (argMap.containsKey(argName)) { Console.warn("Trying to add argument name multiple times: '" - + argName + "'"); // RESTORE THIS WHEN MERGED + + argName + "'"); // RESTORE THIS WHEN + // MERGED if (argMap.get(argName) != a) { Console.error( @@ -98,31 +149,93 @@ public class ArgParser public ArgParser(String[] args) { - // make a mutable new ArrayList so that shell globbing parser works - this(new ArrayList<>(Arrays.asList(args))); + this(args, false, null); + } + + public ArgParser(String[] args, boolean initsubstitutions, + BootstrapArgs bsa) + { + // Make a mutable new ArrayList so that shell globbing parser works. + // (When shell file globbing is used, there are a sequence of non-Arg + // arguments (which are the expanded globbed filenames) that need to be + // consumed by the --append/--argfile/etc Arg which is most easily done by + // removing these filenames from the list one at a time. This can't be done + // with an ArrayList made with only Arrays.asList(String[] args). ) + this(new ArrayList<>(Arrays.asList(args)), initsubstitutions, false, + bsa); + } + + public ArgParser(List args, boolean initsubstitutions) + { + this(args, initsubstitutions, false, null); } - public ArgParser(List args) + public ArgParser(List args, boolean initsubstitutions, + boolean allowPrivate, BootstrapArgs bsa) { - init(args); + // do nothing if there are no "--" args and (some "-" args || >0 arg is + // "open") + boolean d = false; + boolean dd = false; + for (String arg : args) + { + if (arg.startsWith(DOUBLEDASH)) + { + dd = true; + break; + } + else if (arg.startsWith("-") || arg.equals("open")) + { + d = true; + } + } + if (d && !dd) + { + // leave it to the old style -- parse an empty list + parse(new ArrayList(), false, false); + return; + } + if (bsa != null) + this.bootstrapArgs = bsa; + else + this.bootstrapArgs = BootstrapArgs.getBootstrapArgs(args); + parse(args, initsubstitutions, allowPrivate); } - private void init(List args) + private void parse(List args, boolean initsubstitutions, + boolean allowPrivate) { - // Enumeration argE = Collections.enumeration(args); - int argIndex = 0; - // while (argE.hasMoreElements()) + this.substitutions = initsubstitutions; + boolean openEachInitialFilenames = true; for (int i = 0; i < args.size(); i++) { - // String arg = argE.nextElement(); String arg = args.get(i); + + // If the first arguments do not start with "--" or "-" or is not "open" + // and` is a filename that exists it is probably a file/list of files to + // open so we fake an Arg.OPEN argument and when adding files only add the + // single arg[i] and increment the defaultLinkedIdCounter so that each of + // these files is opened separately. + if (openEachInitialFilenames && !arg.startsWith(DOUBLEDASH) + && !arg.startsWith("-") && !arg.equals("open") + && (new File(arg).exists() + || HttpUtils.startsWithHttpOrHttps(arg))) + { + arg = Arg.OPEN.argString(); + } + else + { + openEachInitialFilenames = false; + } + String argName = null; String val = null; - List vals = null; // for Opt.GLOB only + List globVals = null; // for Opt.GLOB only + SubVals globSubVals = null; // also for use by Opt.GLOB only String linkedId = null; if (arg.startsWith(DOUBLEDASH)) { - int equalPos = arg.indexOf('='); + int equalPos = arg.indexOf(EQUALS); if (equalPos > -1) { argName = arg.substring(DOUBLEDASH.length(), equalPos); @@ -156,20 +269,30 @@ public class ArgParser if (a == null) { // arg not found - Console.error("Argument '" + arg + "' not recognised. Ignoring."); + Console.error("Argument '" + arg + "' not recognised. Exiting."); + Jalview.exit("Invalid argument used." + System.lineSeparator() + + "Use" + System.lineSeparator() + "jalview " + + Arg.HELP.argString() + System.lineSeparator() + + "for a usage statement.", 13); + continue; + } + if (a.hasOption(Opt.PRIVATE) && !allowPrivate) + { + Console.error( + "Argument '" + a.argString() + "' is private. Ignoring."); continue; } if (!a.hasOption(Opt.BOOLEAN) && negated) { // used "no" with a non-boolean option - Console.error("Argument '--" + NEGATESTRING + argName + Console.error("Argument '" + DOUBLEDASH + NEGATESTRING + argName + "' not a boolean option. Ignoring."); continue; } if (!a.hasOption(Opt.STRING) && equalPos > -1) { // set --argname=value when arg does not accept values - Console.error("Argument '--" + argName + Console.error("Argument '" + a.argString() + "' does not expect a value (given as '" + arg + "'). Ignoring."); continue; @@ -177,172 +300,255 @@ public class ArgParser if (!a.hasOption(Opt.LINKED) && linkedId != null) { // set --argname[linkedId] when arg does not use linkedIds - Console.error("Argument '--" + argName + Console.error("Argument '" + a.argString() + "' does not expect a linked id (given as '" + arg + "'). Ignoring."); continue; } - if (a.hasOption(Opt.STRING) && equalPos == -1) + // String value(s) + if (a.hasOption(Opt.STRING)) { - // take next arg as value if required, and '=' was not found - // if (!argE.hasMoreElements()) - if (i + 1 >= args.size()) - { - // no value to take for arg, which wants a value - Console.error("Argument '" + a.getName() - + "' requires a value, none given. Ignoring."); - continue; - } - // deal with bash globs here (--arg val* is expanded before reaching - // the JVM). Note that SubVals cannot be used in this case. - // If using the --arg=val then the glob is preserved and Java globs - // will be used later. SubVals can be used. - if (a.hasOption(Opt.GLOB)) + if (equalPos >= 0) { - vals.addAll(getShellGlobbedFilenameValues(a, args, i + 1)); + if (a.hasOption(Opt.GLOB)) + { + // strip off and save the SubVals to be added individually later + globSubVals = new SubVals(val); + // make substitutions before looking for files + String fileGlob = makeSubstitutions(globSubVals.getContent(), + linkedId); + globVals = FileUtils.getFilenamesFromGlob(fileGlob); + } + else + { + // val is already set -- will be saved in the ArgValue later in + // the normal way + } } else { - val = args.get(i + 1); + // There is no "=" so value is next arg or args (possibly shell + // glob-expanded) + if ((openEachInitialFilenames ? i : i + 1) >= args.size()) + { + // no value to take for arg, which wants a value + Console.error("Argument '" + a.getName() + + "' requires a value, none given. Ignoring."); + continue; + } + // deal with bash globs here (--arg val* is expanded before reaching + // the JVM). Note that SubVals cannot be used in this case. + // If using the --arg=val then the glob is preserved and Java globs + // will be used later. SubVals can be used. + if (a.hasOption(Opt.GLOB)) + { + // if this is the first argument with a file list at the start of + // the args we add filenames from index i instead of i+1 + globVals = getShellGlobbedFilenameValues(a, args, + openEachInitialFilenames ? i : i + 1); + } + else + { + val = args.get(i + 1); + } } } // make NOACTION adjustments // default and auto counter increments - if (a == Arg.INCREMENT) - { - defaultLinkedIdCounter++; - } - else if (a == Arg.NPP) + if (a == Arg.NPP) { - idCounter++; + linkedIdAutoCounter++; } else if (a == Arg.SUBSTITUTIONS) { substitutions = !negated; } + else if (a == Arg.SETARGFILE) + { + argFile = val; + } + else if (a == Arg.UNSETARGFILE) + { + argFile = null; + } + else if (a == Arg.ALL) + { + allLinkedIds = !negated; + } + + // this is probably only Arg.NEW and Arg.OPEN + if (a.hasOption(Opt.INCREMENTDEFAULTCOUNTER)) + { + // use the next default prefixed OPENLINKEDID + defaultLinkedId(true); + } String autoCounterString = null; boolean usingAutoCounterLinkedId = false; - String defaultLinkedId = new StringBuilder(DEFAULTLINKEDIDPREFIX) - .append(Integer.toString(defaultLinkedIdCounter)) - .toString(); + String defaultLinkedId = defaultLinkedId(false); boolean usingDefaultLinkedId = false; if (a.hasOption(Opt.LINKED)) { if (linkedId == null) { - // use default linkedId for linked arguments - linkedId = defaultLinkedId; - usingDefaultLinkedId = true; - Console.debug( - "Changing linkedId to '" + linkedId + "' from " + arg); + if (allLinkedIds && a.hasOption(Opt.ALLOWALL)) + { + linkedId = MATCHALLLINKEDIDS; + } + else + { + // use default linkedId for linked arguments + linkedId = defaultLinkedId; + usingDefaultLinkedId = true; + Console.debug("Changing linkedId to '" + linkedId + "' from " + + arg); + } } - else if (linkedId.equals(AUTOCOUNTERLINKEDID)) + else if (linkedId.contains(LINKEDIDAUTOCOUNTER)) { // turn {n} to the autoCounter - autoCounterString = Integer.toString(idCounter); - linkedId = autoCounterString; + autoCounterString = Integer.toString(linkedIdAutoCounter); + linkedId = linkedId.replace(LINKEDIDAUTOCOUNTER, + autoCounterString); usingAutoCounterLinkedId = true; Console.debug( "Changing linkedId to '" + linkedId + "' from " + arg); } - else if (linkedId.equals(INCREMENTAUTOCOUNTERLINKEDID)) + else if (linkedId.contains(INCREMENTLINKEDIDAUTOCOUNTER)) { // turn {++n} to the incremented autoCounter - autoCounterString = Integer.toString(++idCounter); - linkedId = autoCounterString; + autoCounterString = Integer.toString(++linkedIdAutoCounter); + linkedId = linkedId.replace(INCREMENTLINKEDIDAUTOCOUNTER, + autoCounterString); usingAutoCounterLinkedId = true; Console.debug( "Changing linkedId to '" + linkedId + "' from " + arg); } } - if (!linkedArgs.containsKey(linkedId)) - linkedArgs.put(linkedId, new ArgValuesMap()); - - // do not continue for NOACTION args + // do not continue in this block for NOACTION args if (a.hasOption(Opt.NOACTION)) continue; - ArgValuesMap avm = linkedArgs.get(linkedId); + ArgValuesMap avm = getOrCreateLinkedArgValuesMap(linkedId); // not dealing with both NODUPLICATEVALUES and GLOB if (a.hasOption(Opt.NODUPLICATEVALUES) && avm.hasValue(a, val)) { - Console.error("Argument '--" + argName + Console.error("Argument '" + a.argString() + "' cannot contain a duplicate value ('" + val + "'). Ignoring this and subsequent occurrences."); continue; } // check for unique id - SubVals sv = ArgParser.getSubVals(val); - String id = sv.get(ArgValues.ID); + SubVals idsv = new SubVals(val); + String id = idsv.get(ArgValues.ID); if (id != null && avm.hasId(a, id)) { - Console.error("Argument '--" + argName + "' has a duplicate id ('" - + id + "'). Ignoring."); + Console.error("Argument '" + a.argString() + + "' has a duplicate id ('" + id + "'). Ignoring."); continue; } + /* TODO + * Change all avs.addValue() avs.setBoolean avs.setNegated() avs.incrementCount calls to checkfor linkedId == "*" + * DONE, need to check + */ ArgValues avs = avm.getOrCreateArgValues(a); - if (avs == null) - { - avs = new ArgValues(a); - } - // store appropriate value + + // store appropriate String value(s) if (a.hasOption(Opt.STRING)) { - if (a.hasOption(Opt.GLOB) && vals != null && vals.size() > 0) + if (a.hasOption(Opt.GLOB) && globVals != null + && globVals.size() > 0) { - for (String v : vals) + Enumeration gve = Collections.enumeration(globVals); + while (gve.hasMoreElements()) { - avs.addValue(makeSubstitutions(v), argIndex++); + String v = gve.nextElement(); + SubVals vsv = new SubVals(globSubVals, v); + addValue(linkedId, avs, vsv, v, argIndex++, true); + // if we're using defaultLinkedId and the arg increments the + // counter: + if (gve.hasMoreElements() && usingDefaultLinkedId + && a.hasOption(Opt.INCREMENTDEFAULTCOUNTER)) + { + // increment the default linkedId + linkedId = defaultLinkedId(true); + // get new avm and avs + avm = linkedArgs.get(linkedId); + avs = avm.getOrCreateArgValues(a); + } } } else { - avs.addValue(makeSubstitutions(val), argIndex); + addValue(linkedId, avs, val, argIndex, true); } } else if (a.hasOption(Opt.BOOLEAN)) { - avs.setBoolean(!negated, argIndex); - avs.setNegated(negated); + setBoolean(linkedId, avs, !negated, argIndex); + setNegated(linkedId, avs, negated); } else if (a.hasOption(Opt.UNARY)) { - avs.setBoolean(true, argIndex); + setBoolean(linkedId, avs, true, argIndex); } - avs.incrementCount(); - // store in appropriate place - if (a.hasOption(Opt.LINKED)) + // remove the '*' linkedId that should be empty if it was created + if (MATCHALLLINKEDIDS.equals(linkedId) + && linkedArgs.containsKey(linkedId)) { - // allow a default linked id for single usage - if (linkedId == null) - linkedId = defaultLinkedId; - // store the order of linkedIds - if (linkedOrder == null) - linkedOrder = new ArrayList<>(); - if (!linkedOrder.contains(linkedId)) - linkedOrder.add(linkedId); + linkedArgs.remove(linkedId); } + } + } + } + + private void finaliseStoringArgValue(String linkedId, ArgValues avs) + { + Arg a = avs.arg(); + incrementCount(linkedId, avs); + argIndex++; + + // store in appropriate place + if (a.hasOption(Opt.LINKED)) + { + // store the order of linkedIds + if (!linkedOrder.contains(linkedId)) + linkedOrder.add(linkedId); + } + + // store arg in the list of args used + if (!argList.contains(a)) + argList.add(a); + } - // store arg in the list of args used - if (argList == null) - argList = new ArrayList<>(); - if (!argList.contains(a)) - argList.add(a); + private String defaultLinkedId(boolean increment) + { + String defaultLinkedId = new StringBuilder(DEFAULTLINKEDIDPREFIX) + .append(Integer.toString(defaultLinkedIdCounter)).toString(); + if (increment) + { + while (linkedArgs.containsKey(defaultLinkedId)) + { + defaultLinkedIdCounter++; + defaultLinkedId = new StringBuilder(DEFAULTLINKEDIDPREFIX) + .append(Integer.toString(defaultLinkedIdCounter)) + .toString(); } } + getOrCreateLinkedArgValuesMap(defaultLinkedId); + return defaultLinkedId; } - private String makeSubstitutions(String val) + public String makeSubstitutions(String val, String linkedId) { - if (!this.substitutions) + if (!this.substitutions || val == null) return val; String subvals; @@ -360,9 +566,40 @@ public class ArgParser subvals = ""; rest = val; } - rest.replace(AUTOCOUNTERLINKEDID, String.valueOf(idCounter)); - rest.replace(INCREMENTAUTOCOUNTERLINKEDID, String.valueOf(++idCounter)); - rest.replace("{}", String.valueOf(defaultLinkedIdCounter)); + if (rest.contains(LINKEDIDAUTOCOUNTER)) + rest = rest.replace(LINKEDIDAUTOCOUNTER, + String.valueOf(linkedIdAutoCounter)); + if (rest.contains(INCREMENTLINKEDIDAUTOCOUNTER)) + rest = rest.replace(INCREMENTLINKEDIDAUTOCOUNTER, + String.valueOf(++linkedIdAutoCounter)); + if (rest.contains(DEFAULTLINKEDIDCOUNTER)) + rest = rest.replace(DEFAULTLINKEDIDCOUNTER, + String.valueOf(defaultLinkedIdCounter)); + ArgValuesMap avm = linkedArgs.get(linkedId); + if (avm != null) + { + if (rest.contains(LINKEDIDBASENAME)) + { + rest = rest.replace(LINKEDIDBASENAME, avm.getBasename()); + } + if (rest.contains(LINKEDIDDIRNAME)) + { + rest = rest.replace(LINKEDIDDIRNAME, avm.getDirname()); + } + } + if (argFile != null) + { + if (rest.contains(ARGFILEBASENAME)) + { + rest = rest.replace(ARGFILEBASENAME, + FileUtils.getBasename(new File(argFile))); + } + if (rest.contains(ARGFILEDIRNAME)) + { + rest = rest.replace(ARGFILEDIRNAME, + FileUtils.getDirname(new File(argFile))); + } + } return new StringBuilder(subvals).append(rest).toString(); } @@ -370,12 +607,11 @@ public class ArgParser /* * A helper method to take a list of String args where we're expecting * {"--previousargs", "--arg", "file1", "file2", "file3", "--otheroptionsornot"} - * and the index of the globbed arg, here 1. It returns a - * List {"file1", "file2", "file3"} - * *and remove these from the original list object* so that processing - * can continue from where it has left off, e.g. args has become - * {"--previousargs", "--arg", "--otheroptionsornot"} - * so the next increment carries on from the next --arg if available. + * and the index of the globbed arg, here 1. It returns a List {"file1", + * "file2", "file3"} *and remove these from the original list object* so that + * processing can continue from where it has left off, e.g. args has become + * {"--previousargs", "--arg", "--otheroptionsornot"} so the next increment + * carries on from the next --arg if available. */ protected static List getShellGlobbedFilenameValues(Arg a, List args, int i) @@ -383,16 +619,31 @@ public class ArgParser List vals = new ArrayList<>(); while (i < args.size() && !args.get(i).startsWith(DOUBLEDASH)) { - vals.add(args.remove(i)); + vals.add(FileUtils.substituteHomeDir(args.remove(i))); if (!a.hasOption(Opt.GLOB)) break; } return vals; } + public BootstrapArgs getBootstrapArgs() + { + return bootstrapArgs; + } + public boolean isSet(Arg a) { - return a.hasOption(Opt.LINKED) ? isSet("", a) : isSet(null, a); + return a.hasOption(Opt.LINKED) ? isSetAtAll(a) : isSet(null, a); + } + + public boolean isSetAtAll(Arg a) + { + for (String linkedId : linkedOrder) + { + if (isSet(linkedId, a)) + return true; + } + return false; } public boolean isSet(String linkedId, Arg a) @@ -401,7 +652,7 @@ public class ArgParser return avm == null ? false : avm.containsArg(a); } - public boolean getBool(Arg a) + public boolean getBoolean(Arg a) { if (!a.hasOption(Opt.BOOLEAN) && !a.hasOption(Opt.UNARY)) { @@ -420,12 +671,12 @@ public class ArgParser return avs == null ? a.getDefaultBoolValue() : avs.getBoolean(); } - public List linkedIds() + public List getLinkedIds() { return linkedOrder; } - public ArgValuesMap linkedArgs(String id) + public ArgValuesMap getLinkedArgs(String id) { return linkedArgs.get(id); } @@ -436,16 +687,16 @@ public class ArgParser StringBuilder sb = new StringBuilder(); sb.append("UNLINKED\n"); sb.append(argValuesMapToString(linkedArgs.get(null))); - if (linkedIds() != null) + if (getLinkedIds() != null) { sb.append("LINKED\n"); - for (String id : linkedIds()) + for (String id : getLinkedIds()) { // already listed these as UNLINKED args if (id == null) continue; - ArgValuesMap avm = linkedArgs(id); + ArgValuesMap avm = getLinkedArgs(id); sb.append("ID: '").append(id).append("'\n"); sb.append(argValuesMapToString(avm)); } @@ -467,12 +718,8 @@ public class ArgParser return sb.toString(); } - public static SubVals getSubVals(String item) - { - return new SubVals(item); - } - - public static ArgParser parseArgFiles(List argFilenameGlobs) + public static ArgParser parseArgFiles(List argFilenameGlobs, + boolean initsubstitutions, BootstrapArgs bsa) { List argFiles = new ArrayList<>(); @@ -482,33 +729,340 @@ public class ArgParser argFiles.addAll(FileUtils.getFilesFromGlob(pattern)); } - return parseArgFileList(argFiles); + return parseArgFileList(argFiles, initsubstitutions, bsa); } - public static ArgParser parseArgFileList(List argFiles) + public static ArgParser parseArgFileList(List argFiles, + boolean initsubstitutions, BootstrapArgs bsa) { List argsList = new ArrayList<>(); for (File argFile : argFiles) { if (!argFile.exists()) { - String message = DOUBLEDASH - + Arg.ARGFILE.name().toLowerCase(Locale.ROOT) + "=\"" + String message = Arg.ARGFILE.argString() + EQUALS + "\"" + argFile.getPath() + "\": File does not exist."; Jalview.exit(message, 2); } try { - argsList.addAll(Files.readAllLines(Paths.get(argFile.getPath()))); + String setargfile = new StringBuilder(Arg.SETARGFILE.argString()) + .append(EQUALS).append(argFile.getCanonicalPath()) + .toString(); + argsList.add(setargfile); + argsList.addAll(readArgFile(argFile)); + argsList.add(Arg.UNSETARGFILE.argString()); } catch (IOException e) { - String message = DOUBLEDASH - + Arg.ARGFILE.name().toLowerCase(Locale.ROOT) + "=\"" - + argFile.getPath() + "\": File could not be read."; + String message = Arg.ARGFILE.argString() + "=\"" + argFile.getPath() + + "\": File could not be read."; Jalview.exit(message, 3); } } - return new ArgParser(argsList); + // Third param "true" uses Opt.PRIVATE args --setargile=argfile and + // --unsetargfile + return new ArgParser(argsList, initsubstitutions, true, bsa); + } + + protected static List readArgFile(File argFile) + { + List args = new ArrayList<>(); + if (argFile != null && argFile.exists()) + { + try + { + for (String line : Files.readAllLines(Paths.get(argFile.getPath()))) + { + if (line != null && line.length() > 0 + && line.charAt(0) != ARGFILECOMMENT) + args.add(line); + } + } catch (IOException e) + { + String message = Arg.ARGFILE.argString() + "=\"" + argFile.getPath() + + "\": File could not be read."; + Console.debug(message, e); + Jalview.exit(message, 3); + } + } + return args; + } + + public static enum Position + { + FIRST, BEFORE, AFTER + } + + // get from following Arg of type a or subval of same name (lowercase) + public static String getValueFromSubValOrArg(ArgValuesMap avm, + ArgValue av, Arg a, SubVals sv) + { + return getFromSubValArgOrPref(avm, av, a, sv, null, null, null); + } + + // get from following Arg of type a or subval key or preference pref or + // default def + public static String getFromSubValArgOrPref(ArgValuesMap avm, ArgValue av, + Arg a, SubVals sv, String key, String pref, String def) + { + return getFromSubValArgOrPref(avm, a, Position.AFTER, av, sv, key, pref, + def); + } + + // get from following(AFTER), first occurence of (FIRST) or previous (BEFORE) + // Arg of type a or subval key or preference pref or default def + public static String getFromSubValArgOrPref(ArgValuesMap avm, Arg a, + Position pos, ArgValue av, SubVals sv, String key, String pref, + String def) + { + return getFromSubValArgOrPrefWithSubstitutions(null, avm, a, pos, av, + sv, key, pref, def); + } + + public static String getFromSubValArgOrPrefWithSubstitutions(ArgParser ap, + ArgValuesMap avm, Arg a, Position pos, ArgValue av, SubVals sv, + String key, String pref, String def) + { + if (key == null) + key = a.getName(); + String value = null; + if (sv != null && sv.has(key) && sv.get(key) != null) + { + value = ap == null ? sv.get(key) + : sv.getWithSubstitutions(ap, avm.getLinkedId(), key); + } + else if (avm != null && avm.containsArg(a)) + { + if (pos == Position.FIRST && avm.getValue(a) != null) + value = avm.getValue(a); + else if (pos == Position.BEFORE + && avm.getClosestPreviousArgValueOfArg(av, a) != null) + value = avm.getClosestPreviousArgValueOfArg(av, a).getValue(); + else if (pos == Position.AFTER + && avm.getClosestNextArgValueOfArg(av, a) != null) + value = avm.getClosestNextArgValueOfArg(av, a).getValue(); + } + else + { + value = pref != null ? Cache.getDefault(pref, def) : def; + } + return value; + } + + public static boolean getBoolFromSubValOrArg(ArgValuesMap avm, Arg a, + SubVals sv) + { + return getFromSubValArgOrPref(avm, a, sv, null, null, false); + } + + public static boolean getFromSubValArgOrPref(ArgValuesMap avm, Arg a, + SubVals sv, String key, String pref, boolean def) + { + if ((key == null && a == null) || (sv == null && a == null)) + return false; + + boolean usingArgKey = false; + if (key == null) + { + key = a.getName(); + usingArgKey = true; + } + + String nokey = ArgParser.NEGATESTRING + key; + + // look for key or nokey in subvals first (if using Arg check options) + if (sv != null) + { + // check for true boolean + if (sv.has(key) && sv.get(key) != null) + { + if (usingArgKey) + { + if (!(a.hasOption(Opt.BOOLEAN) || a.hasOption(Opt.UNARY))) + { + Console.debug( + "Looking for boolean in subval from non-boolean/non-unary Arg " + + a.getName()); + return false; + } + } + return sv.get(key).toLowerCase(Locale.ROOT).equals("true"); + } + + // check for negative boolean (subval "no..." will be "true") + if (sv.has(nokey) && sv.get(nokey) != null) + { + if (usingArgKey) + { + if (!(a.hasOption(Opt.BOOLEAN))) + { + Console.debug( + "Looking for negative boolean in subval from non-boolean Arg " + + a.getName()); + return false; + } + } + return !sv.get(nokey).toLowerCase(Locale.ROOT).equals("true"); + } + } + + // check argvalues + if (avm != null && avm.containsArg(a)) + return avm.getBoolean(a); + + // return preference or default + return pref != null ? Cache.getDefault(pref, def) : def; + } + + // the following methods look for the "*" linkedId and add the argvalue to all + // linkedId ArgValues if it does + private void addValue(String linkedId, ArgValues avs, SubVals sv, + String v, int argIndex, boolean doSubs) + { + Arg a = avs.arg(); + if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL)) + { + for (String id : getLinkedIds()) + { + if (id == null || MATCHALLLINKEDIDS.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, + int argIndex, boolean doSubs) + { + Arg a = avs.arg(); + if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL)) + { + for (String id : getLinkedIds()) + { + if (id == null || MATCHALLLINKEDIDS.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) + { + Arg a = avs.arg(); + if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL)) + { + for (String id : getLinkedIds()) + { + if (id == null || MATCHALLLINKEDIDS.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); + } + } + + private void setNegated(String linkedId, ArgValues avs, boolean b) + { + Arg a = avs.arg(); + if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL)) + { + for (String id : getLinkedIds()) + { + if (id == null || MATCHALLLINKEDIDS.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); + } + } + + private void incrementCount(String linkedId, ArgValues avs) + { + Arg a = avs.arg(); + if (MATCHALLLINKEDIDS.equals(linkedId) && a.hasOption(Opt.ALLOWALL)) + { + for (String id : getLinkedIds()) + { + if (id == null || MATCHALLLINKEDIDS.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(); + } + } + + private ArgValuesMap getOrCreateLinkedArgValuesMap(String linkedId) + { + if (linkedArgs.containsKey(linkedId) + && linkedArgs.get(linkedId) != null) + return linkedArgs.get(linkedId); + + linkedArgs.put(linkedId, new ArgValuesMap(linkedId)); + return linkedArgs.get(linkedId); } } \ No newline at end of file