src/jalview/bin/argparser/ArgParser.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.bin.argparser;
  22
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.nio.file.Files;
  26 import java.nio.file.Paths;
  27 import java.util.ArrayList;
  28 import java.util.Arrays;
  29 import java.util.Collections;
  30 import java.util.EnumSet;
  31 import java.util.Enumeration;
  32 import java.util.HashMap;
  33 import java.util.List;
  34 import java.util.Locale;
  35 import java.util.Map;
  36
  37 import jalview.bin.Cache;
  38 import jalview.bin.Console;
  39 import jalview.bin.Jalview;
  40 import jalview.bin.argparser.Arg.Opt;
  41 import jalview.bin.argparser.Arg.Type;
  42 import jalview.util.FileUtils;
  43 import jalview.util.HttpUtils;
  44
  45 public class ArgParser
  46 {
  47   protected static final String SINGLEDASH = "-";
  48
  49   protected static final String DOUBLEDASH = "--";
  50
  51   protected static final char EQUALS = '=';
  52
  53   protected static final String NEGATESTRING = "no";
  54
  55   // the default linked id prefix used for no id (not even square braces)
  56   protected static final String DEFAULTLINKEDIDPREFIX = "JALVIEW:";
  57
  58   // the linkedId string used to match all linkedIds seen so far
  59   protected static final String MATCHALLLINKEDIDS = "*";
  60
  61   // the linkedId string used to match all of the last --open'ed linkedIds
  62   protected static final String MATCHOPENEDLINKEDIDS = "open*";
  63
  64   // the counter added to the default linked id prefix
  65   private int defaultLinkedIdCounter = 0;
  66
  67   // the substitution string used to use the defaultLinkedIdCounter
  68   private static final String DEFAULTLINKEDIDCOUNTER = "{}";
  69
  70   // the counter added to the default linked id prefix. NOW using
  71   // linkedIdAutoCounter
  72   // private int openLinkedIdCounter = 0;
  73
  74   // the linked id prefix used for --open files. NOW the same as DEFAULT
  75   protected static final String OPENLINKEDIDPREFIX = DEFAULTLINKEDIDPREFIX;
  76
  77   // the counter used for {n} substitutions
  78   private int linkedIdAutoCounter = 0;
  79
  80   // the linked id substitution string used to increment the idCounter (and use
  81   // the incremented value)
  82   private static final String INCREMENTLINKEDIDAUTOCOUNTER = "{++n}";
  83
  84   // the linked id substitution string used to use the idCounter
  85   private static final String LINKEDIDAUTOCOUNTER = "{n}";
  86
  87   // the linked id substitution string used to use the filename extension of
  88   // --append
  89   // or --open
  90   private static final String LINKEDIDEXTENSION = "{extension}";
  91
  92   // the linked id substitution string used to use the base filename of --append
  93   // or --open
  94   private static final String LINKEDIDBASENAME = "{basename}";
  95
  96   // the linked id substitution string used to use the dir path of --append
  97   // or --open
  98   private static final String LINKEDIDDIRNAME = "{dirname}";
  99
 100   // the current argfile
 101   private String argFile = null;
 102
 103   // the linked id substitution string used to use the dir path of the latest
 104   // --argfile name
 105   private static final String ARGFILEBASENAME = "{argfilebasename}";
 106
 107   // the linked id substitution string used to use the dir path of the latest
 108   // --argfile name
 109   private static final String ARGFILEDIRNAME = "{argfiledirname}";
 110
 111   // flag to say whether {n} subtitutions in output filenames should be made.
 112   // Turn on and off with --substitutions and --nosubstitutions
 113   // Start with it on
 114   private boolean substitutions = true;
 115
 116   // flag to say whether the default linkedId is the current default linked id
 117   // or ALL linkedIds
 118   private boolean allLinkedIds = false;
 119
 120   // flag to say whether the default linkedId is the current default linked id
 121   // or OPENED linkedIds
 122   private boolean openedLinkedIds = false;
 123
 124   // flag to say whether the structure arguments should be applied to all
 125   // structures with this linked id
 126   private boolean allStructures = false;
 127
 128   protected static final Map<String, Arg> argMap;
 129
 130   protected Map<String, ArgValuesMap> linkedArgs = new HashMap<>();
 131
 132   protected List<String> linkedOrder = new ArrayList<>();
 133
 134   protected List<String> storedLinkedIds = new ArrayList<>();
 135
 136   protected List<Arg> argList = new ArrayList<>();
 137
 138   private static final char ARGFILECOMMENT = '#';
 139
 140   private int argIndex = 0;
 141
 142   private BootstrapArgs bootstrapArgs = null;
 143
 144   static
 145   {
 146     argMap = new HashMap<>();
 147     for (Arg a : EnumSet.allOf(Arg.class))
 148     {
 149       for (String argName : a.getNames())
 150       {
 151         if (argMap.containsKey(argName))
 152         {
 153           Console.warn("Trying to add argument name multiple times: '"
 154                   + argName + "'");
 155           if (argMap.get(argName) != a)
 156           {
 157             Console.error(
 158                     "Trying to add argument name multiple times for different Args: '"
 159                             + argMap.get(argName).getName() + ":" + argName
 160                             + "' and '" + a.getName() + ":" + argName
 161                             + "'");
 162           }
 163           continue;
 164         }
 165         argMap.put(argName, a);
 166       }
 167     }
 168   }
 169
 170   public ArgParser(String[] args)
 171   {
 172     this(args, false, null);
 173   }
 174
 175   public ArgParser(String[] args, boolean initsubstitutions,
 176           BootstrapArgs bsa)
 177   {
 178     // Make a mutable new ArrayList so that shell globbing parser works.
 179     // (When shell file globbing is used, there are a sequence of non-Arg
 180     // arguments (which are the expanded globbed filenames) that need to be
 181     // consumed by the --append/--argfile/etc Arg which is most easily done by
 182     // removing these filenames from the list one at a time. This can't be done
 183     // with an ArrayList made with only Arrays.asList(String[] args). )
 184     this(new ArrayList<>(Arrays.asList(args)), initsubstitutions, false,
 185             bsa);
 186   }
 187
 188   public ArgParser(List<String> args, boolean initsubstitutions)
 189   {
 190     this(args, initsubstitutions, false, null);
 191   }
 192
 193   public ArgParser(List<String> args, boolean initsubstitutions,
 194           boolean allowPrivate, BootstrapArgs bsa)
 195   {
 196     // do nothing if there are no "--" args and (some "-" args || >0 arg is
 197     // "open")
 198     boolean d = false;
 199     boolean dd = false;
 200     for (String arg : args)
 201     {
 202       if (arg.startsWith(DOUBLEDASH))
 203       {
 204         dd = true;
 205         break;
 206       }
 207       else if (arg.startsWith("-") || arg.equals("open"))
 208       {
 209         d = true;
 210       }
 211     }
 212     if (d && !dd)
 213     {
 214       // leave it to the old style -- parse an empty list
 215       parse(new ArrayList<String>(), false, false);
 216       return;
 217     }
 218     if (bsa != null)
 219       this.bootstrapArgs = bsa;
 220     else
 221       this.bootstrapArgs = BootstrapArgs.getBootstrapArgs(args);
 222     parse(args, initsubstitutions, allowPrivate);
 223   }
 224
 225   private void parse(List<String> args, boolean initsubstitutions,
 226           boolean allowPrivate)
 227   {
 228     this.substitutions = initsubstitutions;
 229     boolean openEachInitialFilenames = true;
 230     for (int i = 0; i < args.size(); i++)
 231     {
 232       String arg = args.get(i);
 233
 234       // If the first arguments do not start with "--" or "-" or is not "open"
 235       // and` is a filename that exists it is probably a file/list of files to
 236       // open so we fake an Arg.OPEN argument and when adding files only add the
 237       // single arg[i] and increment the defaultLinkedIdCounter so that each of
 238       // these files is opened separately.
 239       if (openEachInitialFilenames && !arg.startsWith(DOUBLEDASH)
 240               && !arg.startsWith("-") && !arg.equals("open")
 241               && (new File(arg).exists()
 242                       || HttpUtils.startsWithHttpOrHttps(arg)))
 243       {
 244         arg = Arg.OPEN.argString();
 245       }
 246       else
 247       {
 248         openEachInitialFilenames = false;
 249       }
 250
 251       // look for double-dash, e.g. --arg
 252       if (arg.startsWith(DOUBLEDASH))
 253       {
 254         String argName = null;
 255         String val = null;
 256         List<String> globVals = null; // for Opt.GLOB only
 257         SubVals globSubVals = null; // also for use by Opt.GLOB only
 258         String linkedId = null;
 259         Type type = null;
 260
 261         // look for equals e.g. --arg=value
 262         int equalPos = arg.indexOf(EQUALS);
 263         if (equalPos > -1)
 264         {
 265           argName = arg.substring(DOUBLEDASH.length(), equalPos);
 266           val = arg.substring(equalPos + 1);
 267         }
 268         else
 269         {
 270           argName = arg.substring(DOUBLEDASH.length());
 271         }
 272
 273         // look for linked ID e.g. --arg[linkedID]
 274         int idOpen = argName.indexOf('[');
 275         int idClose = argName.indexOf(']');
 276         if (idOpen > -1 && idClose == argName.length() - 1)
 277         {
 278           linkedId = argName.substring(idOpen + 1, idClose);
 279           argName = argName.substring(0, idOpen);
 280         }
 281
 282         // look for type modification e.g. --help-opening
 283         int dashPos = argName.indexOf(SINGLEDASH);
 284         if (dashPos > -1)
 285         {
 286           String potentialArgName = argName.substring(0, dashPos);
 287           Arg potentialArg = argMap.get(potentialArgName);
 288           if (potentialArg != null && potentialArg.hasOption(Opt.HASTYPE))
 289           {
 290             String typeName = argName.substring(dashPos + 1);
 291             try
 292             {
 293               type = Type.valueOf(typeName);
 294             } catch (IllegalArgumentException e)
 295             {
 296               type = Type.INVALID;
 297             }
 298             argName = argName.substring(0, dashPos);
 299           }
 300         }
 301
 302         Arg a = argMap.get(argName);
 303         // check for boolean prepended by "no" e.g. --nowrap
 304         boolean negated = false;
 305         if (a == null && argName.startsWith(NEGATESTRING) && argMap
 306                 .containsKey(argName.substring(NEGATESTRING.length())))
 307         {
 308           argName = argName.substring(NEGATESTRING.length());
 309           a = argMap.get(argName);
 310           negated = true;
 311         }
 312
 313         // check for config errors
 314         if (a == null)
 315         {
 316           // arg not found
 317           Console.error("Argument '" + arg + "' not recognised.  Exiting.");
 318           Jalview.exit("Invalid argument used." + System.lineSeparator()
 319                   + "Use" + System.lineSeparator() + "jalview "
 320                   + Arg.HELP.argString() + System.lineSeparator()
 321                   + "for a usage statement.", 13);
 322           continue;
 323         }
 324         if (a.hasOption(Opt.PRIVATE) && !allowPrivate)
 325         {
 326           Console.error(
 327                   "Argument '" + a.argString() + "' is private. Ignoring.");
 328           continue;
 329         }
 330         if (!a.hasOption(Opt.BOOLEAN) && negated)
 331         {
 332           // used "no" with a non-boolean option
 333           Console.error("Argument '" + DOUBLEDASH + NEGATESTRING + argName
 334                   + "' not a boolean option. Ignoring.");
 335           continue;
 336         }
 337         if (!a.hasOption(Opt.STRING) && equalPos > -1)
 338         {
 339           // set --argname=value when arg does not accept values
 340           Console.error("Argument '" + a.argString()
 341                   + "' does not expect a value (given as '" + arg
 342                   + "').  Ignoring.");
 343           continue;
 344         }
 345         if (!a.hasOption(Opt.LINKED) && linkedId != null)
 346         {
 347           // set --argname[linkedId] when arg does not use linkedIds
 348           Console.error("Argument '" + a.argString()
 349                   + "' does not expect a linked id (given as '" + arg
 350                   + "'). Ignoring.");
 351           continue;
 352         }
 353
 354         // String value(s)
 355         if (a.hasOption(Opt.STRING))
 356         {
 357           if (equalPos >= 0)
 358           {
 359             if (a.hasOption(Opt.GLOB))
 360             {
 361               // strip off and save the SubVals to be added individually later
 362               globSubVals = new SubVals(val);
 363               // make substitutions before looking for files
 364               String fileGlob = makeSubstitutions(globSubVals.getContent(),
 365                       linkedId);
 366               globVals = FileUtils.getFilenamesFromGlob(fileGlob);
 367             }
 368             else
 369             {
 370               // val is already set -- will be saved in the ArgValue later in
 371               // the normal way
 372             }
 373           }
 374           else
 375           {
 376             // There is no "=" so value is next arg or args (possibly shell
 377             // glob-expanded)
 378             if ((openEachInitialFilenames ? i : i + 1) >= args.size())
 379             {
 380               // no value to take for arg, which wants a value
 381               Console.error("Argument '" + a.getName()
 382                       + "' requires a value, none given. Ignoring.");
 383               continue;
 384             }
 385             // deal with bash globs here (--arg val* is expanded before reaching
 386             // the JVM). Note that SubVals cannot be used in this case.
 387             // If using the --arg=val then the glob is preserved and Java globs
 388             // will be used later. SubVals can be used.
 389             if (a.hasOption(Opt.GLOB))
 390             {
 391               // if this is the first argument with a file list at the start of
 392               // the args we add filenames from index i instead of i+1
 393               globVals = getShellGlobbedFilenameValues(a, args,
 394                       openEachInitialFilenames ? i : i + 1);
 395             }
 396             else
 397             {
 398               val = args.get(i + 1);
 399             }
 400           }
 401         }
 402
 403         // make NOACTION adjustments
 404         // default and auto counter increments
 405         if (a == Arg.NPP)
 406         {
 407           linkedIdAutoCounter++;
 408         }
 409         else if (a == Arg.SUBSTITUTIONS)
 410         {
 411           substitutions = !negated;
 412         }
 413         else if (a == Arg.SETARGFILE)
 414         {
 415           argFile = val;
 416         }
 417         else if (a == Arg.UNSETARGFILE)
 418         {
 419           argFile = null;
 420         }
 421         else if (a == Arg.ALL)
 422         {
 423           allLinkedIds = !negated;
 424           openedLinkedIds = false;
 425         }
 426         else if (a == Arg.OPENED)
 427         {
 428           openedLinkedIds = !negated;
 429           allLinkedIds = false;
 430         }
 431         else if (a == Arg.ALLSTRUCTURES)
 432         {
 433           allStructures = !negated;
 434         }
 435
 436         if (a.hasOption(Opt.STORED))
 437         {
 438           // reset the lastOpenedLinkedIds list
 439           this.storedLinkedIds = new ArrayList<>();
 440         }
 441
 442         // this is probably only Arg.NEW and Arg.OPEN
 443         if (a.hasOption(Opt.INCREMENTDEFAULTCOUNTER))
 444         {
 445           // use the next default prefixed OPENLINKEDID
 446           defaultLinkedId(true);
 447         }
 448
 449         String autoCounterString = null;
 450         String defaultLinkedId = defaultLinkedId(false);
 451         boolean usingDefaultLinkedId = false;
 452         if (a.hasOption(Opt.LINKED))
 453         {
 454           if (linkedId == null)
 455           {
 456             if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL)
 457                     && val.startsWith(MATCHALLLINKEDIDS))
 458             {
 459               // --output=*.ext is shorthand for --all --output {basename}.ext
 460               // (or --image=*.ext)
 461               allLinkedIds = true;
 462               openedLinkedIds = false;
 463               linkedId = MATCHALLLINKEDIDS;
 464               val = LINKEDIDDIRNAME + File.separator + LINKEDIDBASENAME
 465                       + val.substring(MATCHALLLINKEDIDS.length());
 466             }
 467             else if (a.hasOption(Opt.OUTPUT) && a.hasOption(Opt.ALLOWALL)
 468                     && val.startsWith(MATCHOPENEDLINKEDIDS))
 469             {
 470               // --output=open*.ext is shorthand for --opened --output
 471               // {basename}.ext
 472               // (or --image=open*.ext)
 473               openedLinkedIds = true;
 474               allLinkedIds = false;
 475               linkedId = MATCHOPENEDLINKEDIDS;
 476               val = LINKEDIDDIRNAME + File.separator + LINKEDIDBASENAME
 477                       + val.substring(MATCHOPENEDLINKEDIDS.length());
 478             }
 479             else if (allLinkedIds && a.hasOption(Opt.ALLOWALL))
 480             {
 481               linkedId = MATCHALLLINKEDIDS;
 482             }
 483             else if (openedLinkedIds && a.hasOption(Opt.ALLOWALL))
 484             {
 485               linkedId = MATCHOPENEDLINKEDIDS;
 486             }
 487             else
 488             {
 489               // use default linkedId for linked arguments
 490               linkedId = defaultLinkedId;
 491               usingDefaultLinkedId = true;
 492               Console.debug("Changing linkedId to '" + linkedId + "' from "
 493                       + arg);
 494             }
 495           }
 496           else
 497           {
 498             if (linkedId.contains(LINKEDIDAUTOCOUNTER))
 499             {
 500               // turn {n} to the autoCounter
 501               autoCounterString = Integer.toString(linkedIdAutoCounter);
 502               linkedId = linkedId.replace(LINKEDIDAUTOCOUNTER,
 503                       autoCounterString);
 504               Console.debug("Changing linkedId to '" + linkedId + "' from "
 505                       + arg);
 506             }
 507             if (linkedId.contains(INCREMENTLINKEDIDAUTOCOUNTER))
 508             {
 509               // turn {++n} to the incremented autoCounter
 510               autoCounterString = Integer.toString(++linkedIdAutoCounter);
 511               linkedId = linkedId.replace(INCREMENTLINKEDIDAUTOCOUNTER,
 512                       autoCounterString);
 513               Console.debug("Changing linkedId to '" + linkedId + "' from "
 514                       + arg);
 515             }
 516           }
 517         }
 518
 519         // do not continue in this block for NOACTION args
 520         if (a.hasOption(Opt.NOACTION))
 521           continue;
 522
 523         ArgValuesMap avm = getOrCreateLinkedArgValuesMap(linkedId);
 524
 525         // not dealing with both NODUPLICATEVALUES and GLOB
 526         if (a.hasOption(Opt.NODUPLICATEVALUES) && avm.hasValue(a, val))
 527         {
 528           Console.error("Argument '" + a.argString()
 529                   + "' cannot contain a duplicate value ('" + val
 530                   + "'). Ignoring this and subsequent occurrences.");
 531           continue;
 532         }
 533
 534         // check for unique id
 535         SubVals subvals = new SubVals(val);
 536         boolean addNewSubVals = false;
 537         String id = subvals.get(ArgValues.ID);
 538         if (id != null && avm.hasId(a, id))
 539         {
 540           Console.error("Argument '" + a.argString()
 541                   + "' has a duplicate id ('" + id + "'). Ignoring.");
 542           continue;
 543         }
 544
 545         // set allstructures to all non-primary structure options in this linked
 546         // id if --allstructures has been set
 547         if (allStructures
 548                 && (a.getType() == Type.STRUCTURE
 549                         || a.getType() == Type.STRUCTUREIMAGE)
 550                 && !a.hasOption(Opt.PRIMARY))
 551         {
 552           if (!subvals.has(Arg.ALLSTRUCTURES.getName()))
 553           // && !subvals.has("structureid"))
 554           {
 555             subvals.put(Arg.ALLSTRUCTURES.getName(), "true");
 556             addNewSubVals = true;
 557           }
 558         }
 559
 560         ArgValues avs = avm.getOrCreateArgValues(a);
 561
 562         // store appropriate String value(s)
 563         if (a.hasOption(Opt.STRING))
 564         {
 565           if (a.hasOption(Opt.GLOB) && globVals != null
 566                   && globVals.size() > 0)
 567           {
 568             Enumeration<String> gve = Collections.enumeration(globVals);
 569             while (gve.hasMoreElements())
 570             {
 571               String v = gve.nextElement();
 572               SubVals vsv = new SubVals(globSubVals, v);
 573               addValue(linkedId, type, avs, vsv, v, argIndex++, true);
 574               // if we're using defaultLinkedId and the arg increments the
 575               // counter:
 576               if (gve.hasMoreElements() && usingDefaultLinkedId
 577                       && a.hasOption(Opt.INCREMENTDEFAULTCOUNTER))
 578               {
 579                 // increment the default linkedId
 580                 linkedId = defaultLinkedId(true);
 581                 // get new avm and avs
 582                 avm = linkedArgs.get(linkedId);
 583                 avs = avm.getOrCreateArgValues(a);
 584               }
 585             }
 586           }
 587           else
 588           {
 589             // addValue(linkedId, type, avs, val, argIndex, true);
 590             addValue(linkedId, type, avs, addNewSubVals ? subvals : null,
 591                     val, argIndex, true);
 592           }
 593         }
 594         else if (a.hasOption(Opt.BOOLEAN))
 595         {
 596           setBoolean(linkedId, type, avs, !negated, argIndex);
 597           setNegated(linkedId, avs, negated);
 598         }
 599         else if (a.hasOption(Opt.UNARY))
 600         {
 601           setBoolean(linkedId, type, avs, true, argIndex);
 602         }
 603
 604         // remove the '*' or 'open*' linkedId that should be empty if it was
 605         // created
 606         if ((MATCHALLLINKEDIDS.equals(linkedId)
 607                 && linkedArgs.containsKey(linkedId))
 608                 || (MATCHOPENEDLINKEDIDS.equals(linkedId)
 609                         && linkedArgs.containsKey(linkedId)))
 610         {
 611           linkedArgs.remove(linkedId);
 612         }
 613       }
 614     }
 615   }
 616
 617   private void finaliseStoringArgValue(String linkedId, ArgValues avs)
 618   {
 619     Arg a = avs.arg();
 620     incrementCount(linkedId, avs);
 621     argIndex++;
 622
 623     // store in appropriate place
 624     if (a.hasOption(Opt.LINKED))
 625     {
 626       // store the order of linkedIds
 627       if (!linkedOrder.contains(linkedId))
 628         linkedOrder.add(linkedId);
 629     }
 630
 631     // store arg in the list of args used
 632     if (!argList.contains(a))
 633       argList.add(a);
 634   }
 635
 636   private String defaultLinkedId(boolean increment)
 637   {
 638     String defaultLinkedId = new StringBuilder(DEFAULTLINKEDIDPREFIX)
 639             .append(Integer.toString(defaultLinkedIdCounter)).toString();
 640     if (increment)
 641     {
 642       while (linkedArgs.containsKey(defaultLinkedId))
 643       {
 644         defaultLinkedIdCounter++;
 645         defaultLinkedId = new StringBuilder(DEFAULTLINKEDIDPREFIX)
 646                 .append(Integer.toString(defaultLinkedIdCounter))
 647                 .toString();
 648       }
 649     }
 650     getOrCreateLinkedArgValuesMap(defaultLinkedId);
 651     return defaultLinkedId;
 652   }
 653
 654   public String makeSubstitutions(String val, String linkedId)
 655   {
 656     if (!this.substitutions || val == null)
 657       return val;
 658
 659     String subvals;
 660     String rest;
 661     if (val.indexOf('[') == 0 && val.indexOf(']') > 1)
 662     {
 663       int closeBracket = val.indexOf(']');
 664       if (val.length() == closeBracket)
 665         return val;
 666       subvals = val.substring(0, closeBracket + 1);
 667       rest = val.substring(closeBracket + 1);
 668     }
 669     else
 670     {
 671       subvals = "";
 672       rest = val;
 673     }
 674     if (rest.contains(LINKEDIDAUTOCOUNTER))
 675       rest = rest.replace(LINKEDIDAUTOCOUNTER,
 676               String.valueOf(linkedIdAutoCounter));
 677     if (rest.contains(INCREMENTLINKEDIDAUTOCOUNTER))
 678       rest = rest.replace(INCREMENTLINKEDIDAUTOCOUNTER,
 679               String.valueOf(++linkedIdAutoCounter));
 680     if (rest.contains(DEFAULTLINKEDIDCOUNTER))
 681       rest = rest.replace(DEFAULTLINKEDIDCOUNTER,
 682               String.valueOf(defaultLinkedIdCounter));
 683     ArgValuesMap avm = linkedArgs.get(linkedId);
 684     if (avm != null)
 685     {
 686       if (rest.contains(LINKEDIDBASENAME))
 687       {
 688         rest = rest.replace(LINKEDIDBASENAME, avm.getBasename());
 689       }
 690       if (rest.contains(LINKEDIDEXTENSION))
 691       {
 692         rest = rest.replace(LINKEDIDEXTENSION, avm.getExtension());
 693       }
 694       if (rest.contains(LINKEDIDDIRNAME))
 695       {
 696         rest = rest.replace(LINKEDIDDIRNAME, avm.getDirname());
 697       }
 698     }
 699     if (argFile != null)
 700     {
 701       if (rest.contains(ARGFILEBASENAME))
 702       {
 703         rest = rest.replace(ARGFILEBASENAME,
 704                 FileUtils.getBasename(new File(argFile)));
 705       }
 706       if (rest.contains(ARGFILEDIRNAME))
 707       {
 708         rest = rest.replace(ARGFILEDIRNAME,
 709                 FileUtils.getDirname(new File(argFile)));
 710       }
 711     }
 712
 713     return new StringBuilder(subvals).append(rest).toString();
 714   }
 715
 716   /*
 717    * A helper method to take a list of String args where we're expecting
 718    * {"--previousargs", "--arg", "file1", "file2", "file3", "--otheroptionsornot"}
 719    * and the index of the globbed arg, here 1. It returns a List<String> {"file1",
 720    * "file2", "file3"} *and remove these from the original list object* so that
 721    * processing can continue from where it has left off, e.g. args has become
 722    * {"--previousargs", "--arg", "--otheroptionsornot"} so the next increment
 723    * carries on from the next --arg if available.
 724    */
 725   protected static List<String> getShellGlobbedFilenameValues(Arg a,
 726           List<String> args, int i)
 727   {
 728     List<String> vals = new ArrayList<>();
 729     while (i < args.size() && !args.get(i).startsWith(DOUBLEDASH))
 730     {
 731       vals.add(FileUtils.substituteHomeDir(args.remove(i)));
 732       if (!a.hasOption(Opt.GLOB))
 733         break;
 734     }
 735     return vals;
 736   }
 737
 738   public BootstrapArgs getBootstrapArgs()
 739   {
 740     return bootstrapArgs;
 741   }
 742
 743   public boolean isSet(Arg a)
 744   {
 745     return a.hasOption(Opt.LINKED) ? isSetAtAll(a) : isSet(null, a);
 746   }
 747
 748   public boolean isSetAtAll(Arg a)
 749   {
 750     for (String linkedId : linkedOrder)
 751     {
 752       if (isSet(linkedId, a))
 753         return true;
 754     }
 755     return false;
 756   }
 757
 758   public boolean isSet(String linkedId, Arg a)
 759   {
 760     ArgValuesMap avm = linkedArgs.get(linkedId);
 761     return avm == null ? false : avm.containsArg(a);
 762   }
 763
 764   public boolean getBoolean(Arg a)
 765   {
 766     if (!a.hasOption(Opt.BOOLEAN) && !a.hasOption(Opt.UNARY))
 767     {
 768       Console.warn("Getting boolean from non boolean Arg '" + a.getName()
 769               + "'.");
 770     }
 771     return a.hasOption(Opt.LINKED) ? getBool("", a) : getBool(null, a);
 772   }
 773
 774   public boolean getBool(String linkedId, Arg a)
 775   {
 776     ArgValuesMap avm = linkedArgs.get(linkedId);
 777     if (avm == null)
 778       return a.getDefaultBoolValue();
 779     ArgValues avs = avm.getArgValues(a);
 780     return avs == null ? a.getDefaultBoolValue() : avs.getBoolean();
 781   }
 782
 783   public List<String> getLinkedIds()
 784   {
 785     return linkedOrder;
 786   }
 787
 788   public ArgValuesMap getLinkedArgs(String id)
 789   {
 790     return linkedArgs.get(id);
 791   }
 792
 793   @Override
 794   public String toString()
 795   {
 796     StringBuilder sb = new StringBuilder();
 797     sb.append("UNLINKED\n");
 798     sb.append(argValuesMapToString(linkedArgs.get(null)));
 799     if (getLinkedIds() != null)
 800     {
 801       sb.append("LINKED\n");
 802       for (String id : getLinkedIds())
 803       {
 804         // already listed these as UNLINKED args
 805         if (id == null)
 806           continue;
 807
 808         ArgValuesMap avm = getLinkedArgs(id);
 809         sb.append("ID: '").append(id).append("'\n");
 810         sb.append(argValuesMapToString(avm));
 811       }
 812     }
 813     return sb.toString();
 814   }
 815
 816   private static String argValuesMapToString(ArgValuesMap avm)
 817   {
 818     if (avm == null)
 819       return null;
 820     StringBuilder sb = new StringBuilder();
 821     for (Arg a : avm.getArgKeys())
 822     {
 823       ArgValues v = avm.getArgValues(a);
 824       sb.append(v.toString());
 825       sb.append("\n");
 826     }
 827     return sb.toString();
 828   }
 829
 830   public static ArgParser parseArgFiles(List<String> argFilenameGlobs,
 831           boolean initsubstitutions, BootstrapArgs bsa)
 832   {
 833     List<File> argFiles = new ArrayList<>();
 834
 835     for (String pattern : argFilenameGlobs)
 836     {
 837       // I don't think we want to dedup files, making life easier
 838       argFiles.addAll(FileUtils.getFilesFromGlob(pattern));
 839     }
 840
 841     return parseArgFileList(argFiles, initsubstitutions, bsa);
 842   }
 843
 844   public static ArgParser parseArgFileList(List<File> argFiles,
 845           boolean initsubstitutions, BootstrapArgs bsa)
 846   {
 847     List<String> argsList = new ArrayList<>();
 848     for (File argFile : argFiles)
 849     {
 850       if (!argFile.exists())
 851       {
 852         String message = Arg.ARGFILE.argString() + EQUALS + "\""
 853                 + argFile.getPath() + "\": File does not exist.";
 854         Jalview.exit(message, 2);
 855       }
 856       try
 857       {
 858         String setargfile = new StringBuilder(Arg.SETARGFILE.argString())
 859                 .append(EQUALS).append(argFile.getCanonicalPath())
 860                 .toString();
 861         argsList.add(setargfile);
 862         argsList.addAll(readArgFile(argFile));
 863         argsList.add(Arg.UNSETARGFILE.argString());
 864       } catch (IOException e)
 865       {
 866         String message = Arg.ARGFILE.argString() + "=\"" + argFile.getPath()
 867                 + "\": File could not be read.";
 868         Jalview.exit(message, 3);
 869       }
 870     }
 871     // Third param "true" uses Opt.PRIVATE args --setargile=argfile and
 872     // --unsetargfile
 873     return new ArgParser(argsList, initsubstitutions, true, bsa);
 874   }
 875
 876   protected static List<String> readArgFile(File argFile)
 877   {
 878     List<String> args = new ArrayList<>();
 879     if (argFile != null && argFile.exists())
 880     {
 881       try
 882       {
 883         for (String line : Files.readAllLines(Paths.get(argFile.getPath())))
 884         {
 885           if (line != null && line.length() > 0
 886                   && line.charAt(0) != ARGFILECOMMENT)
 887             args.add(line);
 888         }
 889       } catch (IOException e)
 890       {
 891         String message = Arg.ARGFILE.argString() + "=\"" + argFile.getPath()
 892                 + "\": File could not be read.";
 893         Console.debug(message, e);
 894         Jalview.exit(message, 3);
 895       }
 896     }
 897     return args;
 898   }
 899
 900   public static enum Position
 901   {
 902     FIRST, BEFORE, AFTER
 903   }
 904
 905   // get from following Arg of type a or subval of same name (lowercase)
 906   public static String getValueFromSubValOrArg(ArgValuesMap avm,
 907           ArgValue av, Arg a, SubVals sv)
 908   {
 909     return getFromSubValArgOrPref(avm, av, a, sv, null, null, null);
 910   }
 911
 912   // get from following Arg of type a or subval key or preference pref or
 913   // default def
 914   public static String getFromSubValArgOrPref(ArgValuesMap avm, ArgValue av,
 915           Arg a, SubVals sv, String key, String pref, String def)
 916   {
 917     return getFromSubValArgOrPref(avm, a, Position.AFTER, av, sv, key, pref,
 918             def);
 919   }
 920
 921   // get from following(AFTER), first occurence of (FIRST) or previous (BEFORE)
 922   // Arg of type a or subval key or preference pref or default def
 923   public static String getFromSubValArgOrPref(ArgValuesMap avm, Arg a,
 924           Position pos, ArgValue av, SubVals sv, String key, String pref,
 925           String def)
 926   {
 927     return getFromSubValArgOrPrefWithSubstitutions(null, avm, a, pos, av,
 928             sv, key, pref, def);
 929   }
 930
 931   public static String getFromSubValArgOrPrefWithSubstitutions(ArgParser ap,
 932           ArgValuesMap avm, Arg a, Position pos, ArgValue av, SubVals sv,
 933           String key, String pref, String def)
 934   {
 935     if (key == null)
 936       key = a.getName();
 937     String value = null;
 938     if (sv != null && sv.has(key) && sv.get(key) != null)
 939     {
 940       value = ap == null ? sv.get(key)
 941               : sv.getWithSubstitutions(ap, avm.getLinkedId(), key);
 942     }
 943     else if (avm != null && avm.containsArg(a))
 944     {
 945       if (pos == Position.FIRST && avm.getValue(a) != null)
 946         value = avm.getValue(a);
 947       else if (pos == Position.BEFORE
 948               && avm.getClosestPreviousArgValueOfArg(av, a) != null)
 949         value = avm.getClosestPreviousArgValueOfArg(av, a).getValue();
 950       else if (pos == Position.AFTER
 951               && avm.getClosestNextArgValueOfArg(av, a) != null)
 952         value = avm.getClosestNextArgValueOfArg(av, a).getValue();
 953
 954       // look for allstructures subval for Type.STRUCTURE*
 955       Arg arg = av.getArg();
 956       if (value == null && arg.hasOption(Opt.PRIMARY)
 957               && arg.getType() == Type.STRUCTURE
 958               && !a.hasOption(Opt.PRIMARY) && (a.getType() == Type.STRUCTURE
 959                       || a.getType() == Type.STRUCTUREIMAGE))
 960       {
 961         ArgValue av2 = avm.getArgValueOfArgWithSubValKey(a,
 962                 Arg.ALLSTRUCTURES.getName());
 963         if (av2 != null)
 964         {
 965           value = av2.getValue();
 966         }
 967       }
 968     }
 969     if (value == null)
 970     {
 971       value = pref != null ? Cache.getDefault(pref, def) : def;
 972     }
 973     return value;
 974   }
 975
 976   public static boolean getBoolFromSubValOrArg(ArgValuesMap avm, Arg a,
 977           SubVals sv)
 978   {
 979     return getFromSubValArgOrPref(avm, a, sv, null, null, false);
 980   }
 981
 982   public static boolean getFromSubValArgOrPref(ArgValuesMap avm, Arg a,
 983           SubVals sv, String key, String pref, boolean def)
 984   {
 985     return getFromSubValArgOrPref(avm, a, sv, key, pref, def, false);
 986   }
 987
 988   public static boolean getFromSubValArgOrPref(ArgValuesMap avm, Arg a,
 989           SubVals sv, String key, String pref, boolean def,
 990           boolean invertPref)
 991   {
 992     if ((key == null && a == null) || (sv == null && a == null))
 993       return false;
 994
 995     boolean usingArgKey = false;
 996     if (key == null)
 997     {
 998       key = a.getName();
 999       usingArgKey = true;
1000     }
1001
1002     String nokey = ArgParser.NEGATESTRING + key;
1003
1004     // look for key or nokey in subvals first (if using Arg check options)
1005     if (sv != null)
1006     {
1007       // check for true boolean
1008       if (sv.has(key) && sv.get(key) != null)
1009       {
1010         if (usingArgKey)
1011         {
1012           if (!(a.hasOption(Opt.BOOLEAN) || a.hasOption(Opt.UNARY)))
1013           {
1014             Console.debug(
1015                     "Looking for boolean in subval from non-boolean/non-unary Arg "
1016                             + a.getName());
1017             return false;
1018           }
1019         }
1020         return sv.get(key).toLowerCase(Locale.ROOT).equals("true");
1021       }
1022
1023       // check for negative boolean (subval "no..." will be "true")
1024       if (sv.has(nokey) && sv.get(nokey) != null)
1025       {
1026         if (usingArgKey)
1027         {
1028           if (!(a.hasOption(Opt.BOOLEAN)))
1029           {
1030             Console.debug(
1031                     "Looking for negative boolean in subval from non-boolean Arg "
1032                             + a.getName());
1033             return false;
1034           }
1035         }
1036         return !sv.get(nokey).toLowerCase(Locale.ROOT).equals("true");
1037       }
1038     }
1039
1040     // check argvalues
1041     if (avm != null && avm.containsArg(a))
1042       return avm.getBoolean(a);
1043
1044     // return preference or default
1045     boolean prefVal = pref != null ? Cache.getDefault(pref, def) : false;
1046     return pref != null ? (invertPref ? !prefVal : prefVal) : def;
1047   }
1048
1049   // the following methods look for the "*" linkedId and add the argvalue to all
1050   // linkedId ArgValues if it does.
1051   // This version inserts the subvals sv into all created values
1052   private void addValue(String linkedId, Type type, ArgValues avs,
1053           SubVals sv, String v, int argIndex, boolean doSubs)
1054   {
1055     this.argValueOperation(Op.ADDVALUE, linkedId, type, avs, sv, v, false,
1056             argIndex, doSubs);
1057   }
1058
1059   private void addValue(String linkedId, Type type, ArgValues avs, String v,
1060           int argIndex, boolean doSubs)
1061   {
1062     this.argValueOperation(Op.ADDVALUE, linkedId, type, avs, null, v, false,
1063             argIndex, doSubs);
1064   }
1065
1066   private void setBoolean(String linkedId, Type type, ArgValues avs,
1067           boolean b, int argIndex)
1068   {
1069     this.argValueOperation(Op.SETBOOLEAN, linkedId, type, avs, null, null,
1070             b, argIndex, false);
1071   }
1072
1073   private void setNegated(String linkedId, ArgValues avs, boolean b)
1074   {
1075     this.argValueOperation(Op.SETNEGATED, linkedId, null, avs, null, null,
1076             b, 0, false);
1077   }
1078
1079   private void incrementCount(String linkedId, ArgValues avs)
1080   {
1081     this.argValueOperation(Op.INCREMENTCOUNT, linkedId, null, avs, null,
1082             null, false, 0, false);
1083   }
1084
1085   private enum Op
1086   {
1087     ADDVALUE, SETBOOLEAN, SETNEGATED, INCREMENTCOUNT
1088   }
1089
1090   private void argValueOperation(Op op, String linkedId, Type type,
1091           ArgValues avs, SubVals sv, String v, boolean b, int argIndex,
1092           boolean doSubs)
1093   {
1094     // default to merge subvals if subvals are provided
1095     argValueOperation(op, linkedId, type, avs, sv, true, v, b, argIndex,
1096             doSubs);
1097   }
1098
1099   /*
1100    * The following operations look for the "*" and "open*" linkedIds and add the
1101    * argvalue to all appropriate linkedId ArgValues if it does.
1102    * If subvals are supplied, they are inserted into all new set values.
1103    *
1104    * @param op The ArgParser.Op operation
1105    * @param linkedId The String linkedId from the ArgValuesMap
1106    * @param type The Arg.Type to attach to this ArgValue
1107    * @param avs The ArgValues for this linkedId
1108    * @param sv Use these SubVals on the ArgValue
1109    * @param merge Merge the SubVals with any existing on the value.  False will replace unless sv is null
1110    * @param v The value of the ArgValue (may contain subvals).
1111    * @param b The boolean value of the ArgValue.
1112    * @param argIndex The argIndex for the ArgValue.
1113    * @param doSubs Whether to perform substitutions on the subvals and value.
1114    */
1115   private void argValueOperation(Op op, String linkedId, Type type,
1116           ArgValues avs, SubVals sv, boolean merge, String v, boolean b,
1117           int argIndex, boolean doSubs)
1118   {
1119     Arg a = avs.arg();
1120
1121     List<String> wildcardLinkedIds = null;
1122     if (a.hasOption(Opt.ALLOWALL))
1123     {
1124       switch (linkedId)
1125       {
1126       case MATCHALLLINKEDIDS:
1127         wildcardLinkedIds = getLinkedIds();
1128         break;
1129       case MATCHOPENEDLINKEDIDS:
1130         wildcardLinkedIds = this.storedLinkedIds;
1131         break;
1132       }
1133     }
1134
1135     // if we're not a wildcard linkedId and the arg is marked to be stored, add
1136     // to storedLinkedIds
1137     if (linkedId != null && wildcardLinkedIds == null
1138             && a.hasOption(Opt.STORED)
1139             && !storedLinkedIds.contains(linkedId))
1140     {
1141       storedLinkedIds.add(linkedId);
1142     }
1143
1144     // if we are a wildcard linkedId, apply the arg and value to all appropriate
1145     // linkedIds
1146     if (wildcardLinkedIds != null)
1147     {
1148       for (String id : wildcardLinkedIds)
1149       {
1150         // skip incorrectly stored wildcard ids!
1151         if (id == null || MATCHALLLINKEDIDS.equals(id)
1152                 || MATCHOPENEDLINKEDIDS.equals(id))
1153           continue;
1154         ArgValuesMap avm = linkedArgs.get(id);
1155         // don't set an output if there isn't an input
1156         if (a.hasOption(Opt.REQUIREINPUT)
1157                 && !avm.hasArgWithOption(Opt.INPUT))
1158           continue;
1159
1160         ArgValues tavs = avm.getOrCreateArgValues(a);
1161         switch (op)
1162         {
1163
1164         case ADDVALUE:
1165           String val = v;
1166           if (sv != null)
1167           {
1168             if (doSubs)
1169             {
1170               sv = new SubVals(sv, val, merge);
1171               val = makeSubstitutions(sv.getContent(), id);
1172             }
1173             tavs.addValue(sv, type, val, argIndex, true);
1174           }
1175           else
1176           {
1177             if (doSubs)
1178             {
1179               val = makeSubstitutions(v, id);
1180             }
1181             tavs.addValue(type, val, argIndex, true);
1182           }
1183           finaliseStoringArgValue(id, tavs);
1184           break;
1185
1186         case SETBOOLEAN:
1187           tavs.setBoolean(type, b, argIndex, true);
1188           finaliseStoringArgValue(id, tavs);
1189           break;
1190
1191         case SETNEGATED:
1192           tavs.setNegated(b, true);
1193           break;
1194
1195         case INCREMENTCOUNT:
1196           tavs.incrementCount();
1197           break;
1198
1199         default:
1200           break;
1201
1202         }
1203
1204       }
1205     }
1206     else // no wildcard linkedId -- do it simpler
1207     {
1208       switch (op)
1209       {
1210       case ADDVALUE:
1211         String val = v;
1212         if (sv != null)
1213         {
1214           if (doSubs)
1215           {
1216             val = makeSubstitutions(v, linkedId);
1217             sv = new SubVals(sv, val);
1218           }
1219           avs.addValue(sv, type, val, argIndex, false);
1220         }
1221         else
1222         {
1223           if (doSubs)
1224           {
1225             val = makeSubstitutions(v, linkedId);
1226           }
1227           avs.addValue(type, val, argIndex, false);
1228         }
1229         finaliseStoringArgValue(linkedId, avs);
1230         break;
1231
1232       case SETBOOLEAN:
1233         avs.setBoolean(type, b, argIndex, false);
1234         finaliseStoringArgValue(linkedId, avs);
1235         break;
1236
1237       case SETNEGATED:
1238         avs.setNegated(b, false);
1239         break;
1240
1241       case INCREMENTCOUNT:
1242         avs.incrementCount();
1243         break;
1244
1245       default:
1246         break;
1247       }
1248     }
1249   }
1250
1251   private ArgValuesMap getOrCreateLinkedArgValuesMap(String linkedId)
1252   {
1253     if (linkedArgs.containsKey(linkedId)
1254             && linkedArgs.get(linkedId) != null)
1255       return linkedArgs.get(linkedId);
1256
1257     linkedArgs.put(linkedId, new ArgValuesMap(linkedId));
1258     return linkedArgs.get(linkedId);
1259   }
1260
1261 }