aboutsummaryrefslogblamecommitdiffstats
path: root/src/ArgParser.java
blob: 798f7801e206bac6998cc64b658c991674d475a0 (plain) (tree)
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856





































































































































































                                                                                                                                               




                                                                                                   






































































































































































































































































































                                                                                                     
                               











                                                                                       
                                                                                              























































































































































































































































































































































































                                                                                                       
                                                                         












                                                                     



                                    









                                                                 
                                                                                        



























































































































                                                                                                           























































                                                                                    




                  
/**
 * argparser – command line argument parser library
 * 
 * Copyright © 2013  Mattias Andrée (maandree@member.fsf.org)
 * 
 * This library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this library.  If not, see <http://www.gnu.org/licenses/>.
 */
import java.util.*;
import java.io.*;


/**
 * Simple argument parser
 * 
 * @author  Mattias Andrée, <a href="mailto:maandree@member.fsf.org">maandree@member.fsf.org</a>
 */
public class ArgParser
{
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description  Short, single-line, description of the program
     * @param  usage        Formated, multi-line, usage text, may be {@code null}
     */
    public ArgParser(final String description, final String usage)
    {	this(description, usage, null, null, false);
    }
    
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description  Short, single-line, description of the program
     * @param  usage        Formated, multi-line, usage text, may be {@code null}
     * @param  useStderr    Whether to use stderr instead of stdout
     */
    public ArgParser(final String description, final String usage, final boolean useStderr)
    {	this(description, usage, null, null, useStderr);
    }
    
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description      Short, single-line, description of the program
     * @param  usage            Formated, multi-line, usage text, may be {@code null}
     * @param  longDescription  Long, multi-line, description of the program, may be {@code null}
     */
    public ArgParser(final String description, final String usage, final String longDescription)
    {	this(description, usage, longDescription, null, false);
    }
    
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description      Short, single-line, description of the program
     * @param  usage            Formated, multi-line, usage text, may be {@code null}
     * @param  longDescription  Long, multi-line, description of the program, may be {@code null}
     * @param  useStderr        Whether to use stderr instead of stdout
     */
    public ArgParser(final String description, final String usage, final String longDescription, final boolean useStderr)
    {	this(description, usage, longDescription, null, useStderr);
    }
    
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description      Short, single-line, description of the program
     * @param  usage            Formated, multi-line, usage text, may be {@code null}
     * @param  longDescription  Long, multi-line, description of the program, may be {@code null}
     * @param  program          The name of the program, {@code null} for automatic
     */
    public ArgParser(final String description, final String usage, final String longDescription, final String program)
    {	this(description, usage, longDescription, program, false);
    }
    
    /**
     * <p>Constructor</p>
     * <p>
     *   The short description is printed on same line as the program name
     * </p>
     * 
     * @param  description      Short, single-line, description of the program
     * @param  usage            Formated, multi-line, usage text, may be {@code null}
     * @param  longDescription  Long, multi-line, description of the program, may be {@code null}
     * @param  program          The name of the program, {@code null} for automatic
     * @param  useStderr        Whether to use stderr instead of stdout
     */
    public ArgParser(final String description, final String usage, final String longDescription, final String program, final boolean useStderr)
    {
	this.linuxvt = System.getenv("TERM") == null ? false : System.getenv("TERM").equals("linux");
	String prog = program == null ? ArgParser.parentName(0, true) : program;
	this.program = prog == null ? "?" : prog;
	this.description = description;
	this.usage = usage;
	this.longDescription = longDescription;
	this.out = useStderr ? System.err : System.out;
    }
    
    
    
    /**
     * Whether the Linux VT is being used
     */
    public boolean linuxvt;
    
    /**
     * The name of the executed command
     */
    public final String program;
    
    /**
     * Short, single-line, description of the program
     */
    private final String description;
    
    /**
     * Formated, multi-line, usage text, {@code null} if none
     */
    private final String usage;
    
    /**
     * Long, multi-line, description of the program, {@code null} if none
     */
    private final String longDescription;
    
    /**
     * The error output stream
     */
    private final OutputStream out;
    
    /**
     * The passed arguments
     */
    public String[] arguments = null;
    
    /**
     * The number of unrecognised arguments
     */
    public int unrecognisedCount = 0;
    
    /**
     * The concatination of {@link #files} with blankspaces as delimiters, {@code null} if no files
     */
    public String message = null;
    
    /**
     * Options, in order
     */
    private final ArrayList<Option> options = new ArrayList<Option>();
    
    /**
     * Option map
     */
    public final HashMap<String, Option> optmap = new HashMap<String, Option>();
    
    /**
     * The arguments passed that is not tied to an option
     */
    public final ArrayList<String> files = new ArrayList<String>();
    
    /**
     * Parsed arguments, a map from option to arguments, {@code null} if not used,
     * add one {@code null} element per argumentless use.
     */
    public final HashMap<String, String[]> opts = new HashMap<String, String[]>();
    
    
    
    /**
     * Option class
     */
    public class Option
    {
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  standard      Standard option index
	 * @param  argument      Argument name, not for argumentless options
	 */
	protected Option(final String[] alternatives, final int standard, final String argument)
	{
	    this.alternatives = alternatives;
	    this.standard = alternatives[standard < 0 ? (alternatives.length + standard) : standard];
	    this.argument = argument == null ? "ARG" : argument;
	}
	
	
	
	/**
	 * Alterative option names
	 */
	public final String[] alternatives;
	
	/**
	 * Standard option name
	 */
	public final String standard;
	
	/**
	 * Argument name, not for argumentless options
	 */
	public final String argument;
	
	/**
	 * Help text, multi-line
	 */
	public String help = null;
    }
    
    
    /**
     * Option takes no arguments
     */
    public class Argumentless extends Option
    {
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  standard      Standard option index
	 */
	public Argumentless(final String[] alternatives, final int standard)
	{   super(alternatives, standard, null);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  standard      Standard option index
	 * @param  alternatives  Alterative option names
	 */
	public Argumentless(final int standard, final String... alternatives)
	{   super(alternatives, standard, null);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 */
	public Argumentless(final String... alternatives)
	{   super(alternatives, 0, null);
	}
    }
    
    
    /**
     * Option takes one argument per instance
     */
    public class Argumented extends Option
    {
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  standard      Standard option index
	 * @param  argument      Argument name
	 */
	public Argumented(final String[] alternatives, final int standard, final String argument)
	{   super(alternatives, standard, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  argument      Argument name
	 * @param  standard      Standard option index
	 */
	public Argumented(final String[] alternatives, final String argument, final int standard)
	{   super(alternatives, standard, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  argument      Argument name
	 */
	public Argumented(final String[] alternatives, final String argument)
	{   super(alternatives, 0, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  standard      Standard option index
	 * @param  argument      Argument name
	 * @param  alternatives  Alterative option names
	 */
	public Argumented(final int standard, final String argument, final String... alternatives)
	{   super(alternatives, standard, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  argument      Argument name
	 * @param  standard      Standard option index
	 * @param  alternatives  Alterative option names
	 */
	public Argumented(final String argument, final int standard, final String... alternatives)
	{   super(alternatives, standard, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  argument      Argument name
	 * @param  alternatives  Alterative option names
	 */
	public Argumented(final String argument, final String... alternatives)
	{   super(alternatives, 0, argument);
	}
    }
    
    
    /**
     * Option consumes all following arguments
     */
    public class Variadic extends Argumented
    {
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  standard      Standard option index
	 * @param  argument      Argument name
	 */
	public Variadic(final String[] alternatives, final int standard, final String argument)
	{   super(alternatives, standard, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  argument      Argument name
	 * @param  standard      Standard option index
	 */
	public Variadic(final String[] alternatives, final String argument, final int standard)
	{   super(alternatives, argument, standard);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  alternatives  Alterative option names
	 * @param  argument      Argument name
	 */
	public Variadic(final String[] alternatives, final String argument)
	{   super(alternatives, argument);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  standard      Standard option index
	 * @param  argument      Argument name
	 * @param  alternatives  Alterative option names
	 */
	public Variadic(final int standard, final String argument, final String... alternatives)
	{   super(standard, argument, alternatives);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  argument      Argument name
	 * @param  standard      Standard option index
	 * @param  alternatives  Alterative option names
	 */
	public Variadic(final String argument, final int standard, final String... alternatives)
	{   super(argument, standard, alternatives);
	}
	
	/**
	 * Constructor
	 * 
	 * @param  argument      Argument name
	 * @param  alternatives  Alterative option names
	 */
	public Variadic(final String argument, final String... alternatives)
	{   super(argument, alternatives);
	}
    }
    
    
    
    /**
     * Gets the name of the parent process
     * 
     * @return  The name of the parent process
     */
    public static String parentName()
    {
	return ArgParser.parentName(1, false);
    }
    
    /**
     * Gets the name of the parent process
     * 
     * @param   levels  The number of parents to walk, 0 for self, and 1 for direct parent
     * @return          The name of the parent process
     */
    public static String parentName(final int levels)
    {
	return ArgParser.parentName(levels, false);
    }
    
    /**
     * Gets the name of the parent process
     * 
     * @param   hasInterpretor  Whether the parent process is an interpretor
     * @return                  The name of the parent process
     */
    public static String parentName(final boolean hasInterpretor)
    {
	return ArgParser.parentName(1, hasInterpretor);
    }
    
    /**
     * Gets the name of the parent process
     * 
     * @param   levels          The number of parents to walk, 0 for self, and 1 for direct parent
     * @param   hasInterpretor  Whether the parent process is an interpretor
     * @return                  The name of the parent process
     */
    public static String parentName(final int levels, final boolean hasInterpretor)
    {
	int pid;
	try
	{   pid = Integer.parseInt((new File("/proc/self")).getCanonicalPath().substring(6));
	}
	catch (final Throwable err)
	{   return null;
	}
	int lvl = levels;
	try
	{   outer:
	        while (lvl > 0)
		{
		    InputStream is = null;
		    try
		    {   is = new FileInputStream(new File("/proc/" + pid + "/status"));
			byte[] data = new byte[is.available()];
			int off = 0;
			while (off != data.length)
			    off += is.read(data, off, data.length - off);
			String[] lines = (new String(data, "UTF-8")).split("\n");
			for (String line : lines)
			{    if (line.startsWith("PPid:"))
			     {
				 line = line.substring(5).replace('\t', ' ').replace(" ", "");
				 pid = Integer.parseInt(line);
				 lvl -= 1;
				 continue outer;
			}    }
			return null;
		    }
		    finally
		    {   if (is != null)
			    try
			    {    is.close();
			    }
			    catch (final Throwable ignore)
			    {    /* ignore */
		    }       }
	         }
	    InputStream is = null;
	    try
	    {   is = new FileInputStream(new File("/proc/" + pid + "/cmdline"));
		byte[] data = new byte[is.available()];
		int off = 0;
		while (off != data.length)
		    off += is.read(data, off, data.length - off);
		String[] cmdline = new String(data, 0, off - 1, "UTF-8").split("\0");
		if (hasInterpretor == false)
		{   String rc = cmdline[0];
		    return rc.length() == 0 ? null : rc;
		}
		boolean dashed = false;
		for (int i = 1, n = cmdline.length; i < n; i++)
		{
		    if (dashed)
			return cmdline[i];
		    if (cmdline[i].equals("--"))
			dashed = true;
		    else if (cmdline[i].equals("-cp") || cmdline[i].equals("-classpath"))
			i++;
		    else if (cmdline[i].startsWith("-") == false)
			return cmdline[i];
		}
	    }
	    finally
	    {   if (is != null)
		    try
		    {    is.close();
		    }
		    catch (final Throwable ignore)
		    {    /* ignore */
	    }       }
	    return null;
	}
	catch (final Throwable err)
	{   return null;
	}
    }
    
    
    /**
     * Print an empty line to the selected error channel
     */
    private void println()
    {
	this.print("\n", true);
    }
    
    /**
     * Print an empty line to the selected error channel
     * 
     * @param  flush  Whether to flush the stream
     */
    private void println(final boolean flush)
    {
	this.print("\n", flush);
    }
    
    /**
     * Print a text with an added line break to the selected error channel
     */
    private void println(final String text)
    {
	this.print(text + "\n", true);
    }
    
    /**
     * Print a text with an added line break to the selected error channel
     * 
     * @param  flush  Whether to flush the stream
     */
    private void println(final String text, final boolean flush)
    {
	this.print(text + "\n", flush);
    }
    
    /**
     * Print a text to the selected error channel
     */
    private void print(final String text)
    {
	this.print(text, false);
    }
    
    /**
     * Print a text to the selected error channel
     * 
     * @param  flush  Whether to flush the stream
     */
    private void print(final String text, final boolean flush)
    {
	try
	{   if (text != null)
		this.out.write(text.getBytes("UTF-8"));
	    if (flush)
		this.out.flush();
	}
	catch (final Throwable ignore)
	{   /* ignore */
	}
    }
    
    
    /**
     * Add an option
     * 
     * @param  option  The option
     */
    public void add(final Option option)
    {
	this.options.add(option);
	for (final String alternative : option.alternatives)
	    this.optmap.put(alternative, option);
	this.opts.put(option.standard, null);
    }
    
    /**
     * Add an option
     * 
     * @param  option  The option
     * @param  help    Help text, multi-line
     */
    public void add(final Option option, final String help)
    {
	this.add(help, option);
    }
    
    /**
     * Add an option
     * 
     * @param  help    Help text, multi-line
     * @param  option  The option
     */
    public void add(final String help, final Option option)
    {
	this.add(option);
	option.help = help;
    }
    
    
    /**
     * Maps up options that are alternatives to the first alternative for each option
     */
    public void supportAlternatives()
    {
        for (final String opt : this.optmap.keySet())
	    this.opts.put(opt, this.opts.get(this.optmap.get(opt).standard));
    }
    
    
    /**
     * Checks for option conflicts
     * 
     * @param   exclusives  Exclusive options
     * @param   exitValue   The value to exit with on the check does not pass,
     * @return              Whether at most one exclusive option was used
     */
    public boolean testExclusiveness(final Set<String> exclusives, final int exitValue)
    {
	boolean rc = this.testExclusiveness(exclusives);
	if (rc == false)
	    System.exit(exitValue);
	return rc;
    }
    
    /**
     * Checks for option conflicts
     * 
     * @param   exclusives  Exclusive options
     * @return              Whether at most one exclusive option was used
     */
    public boolean testExclusiveness(final Set<String> exclusives)
    {
	final ArrayList<String> used = new ArrayList<String>();
	
	for (final String opt : this.opts.keySet())
	    if ((this.opts.get(opt) != null) && exclusives.contains(opt))
		used.add(opt);
	
	if (used.size() > 1)
	{   String msg = this.program + ": conflicting options:";
	    for (final String opt : used)
		if (this.optmap.get(opt).standard.equals(opt))
		    msg += " " + opt;
		else
		    msg += " " + opt + "(" + this.optmap.get(opt).standard + ")";
	    this.println(msg, true);
	    return false;
	}
	return true;
    }
    
    
    /**
     * Checks for out of context option usage
     * 
     * @param   allowed     Allowed options
     * @param   exitValue   The value to exit with on the check does not pass,
     * @return              Whether only allowed options was used
     */
    public boolean testAllowed(final Set<String> allowed, final int exitValue)
    {
	boolean rc = this.testAllowed(allowed);
	if (rc == false)
	    System.exit(exitValue);
	return rc;
    }
    
    /**
     * Checks for out of context option usage
     * 
     * @param   allowed  Allowed options
     * @return           Whether only allowed options was used
     */
    public boolean testAllowed(final Set<String> allowed)
    {
	boolean rc = true;
	for (final String opt : this.opts.keySet())
	    if ((this.opts.get(opt) != null) && (allowed.contains(opt) == false))
	    {   String msg = this.program + ": option used out of context: " + opt;
		if (opt.equals(this.optmap.get(opt).standard) == false)
		    msg += "(" + this.optmap.get(opt).standard + ")";
		this.println(msg, true);
		rc = false;
	    }
	return rc;
    }
    
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   min        The minimum number of files
     * @param   exitValue  The value to exit with on the check does not pass
     * @return             Whether the usage was correct
     */
    public boolean testFilesMin(final int min, final int exitValue)
    {
	boolean rc = this.testFilesMin(min);
	if (rc == false)
	    System.exit(exitValue);
	return rc;
    }
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   min  The minimum number of files
     * @return       Whether the usage was correct
     */
    public boolean testFilesMin(final int min)
    {
	return min <= this.files.size();
    }
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   max        The maximum number of files
     * @param   exitValue  The value to exit with on the check does not pass
     * @return             Whether the usage was correct
     */
    public boolean testFilesMax(final int max, final int exitValue)
    {
	boolean rc = this.testFilesMax(max);
	if (rc == false)
	    System.exit(exitValue);
	return rc;
    }
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   max  The maximum number of files
     * @return       Whether the usage was correct
     */
    public boolean testFilesMax(final int max)
    {
	return this.files.size() <= max;
    }
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   min        The minimum number of files
     * @param   max        The maximum number of files
     * @param   exitValue  The value to exit with on the check does not pass
     * @return             Whether the usage was correct
     */
    public boolean testFiles(final int min, final int max, final int exitValue)
    {
	boolean rc = this.testFiles(min, max);
	if (rc == false)
	    System.exit(exitValue);
	return rc;
    }
    
    /**
     * Checks the correctness of the number of used non-option arguments
     * 
     * @param   min  The minimum number of files
     * @param   max  The maximum number of files
     * @return       Whether the usage was correct
     */
    public boolean testFiles(final int min, final int max)
    {
	return (min <= this.files.size()) && (this.files.size() <= max);
    }
    
    
    /**
     * Prints a colourful help message
     */
    public void help()
    {
	final String dash = this.linuxvt ? "-" : "—";
	this.println("\033[01m" + program + "\033[21m " + dash + " " + this.description + "\n", false);
	if (this.longDescription != null)
	    this.println(longDescription, false);
	this.println(false);
	
	if (this.usage != null)
	{   this.print("\033[01mUSAGE:\033[21m");
	    boolean first = true;
	    for (final String line : this.usage.split("\n"))
	    {   if (first)
		    first = false;
		else
		    this.print("    or");
		this.println("\t" + line, false);
	    }
	    this.println(false);
	}
	
	int maxfirstlen = 0;
	for (final Option opt : this.options)
	{   if (opt.help == null)
		continue;
	    if (opt.alternatives.length > 1)
		if (maxfirstlen < opt.alternatives[0].length())
		    maxfirstlen = opt.alternatives[0].length();
	}
	String empty = "        ";
	while (empty.length() < maxfirstlen)
	    empty += empty;
	empty = empty.substring(0, maxfirstlen);
	
	this.println("\033[01mSYNOPSIS:\033[21m", false);
	final ArrayList<String> lines = new ArrayList<String>();
	final ArrayList<int[]>  lens  = new ArrayList<int[]>();
	for (final Option opt : this.options)
	{   if (opt.help == null)
		continue;
	    int l = 0;
	    String first = opt.alternatives[0];
	    String last  = opt.alternatives[opt.alternatives.length - 1];
	    if (first == last)
		first = empty;
	    else
		first += empty.substring(first.length());
	    String line = "    \033[02m" + first + "\033[22m  \0" + last;
	    l += first.length() + 6 + last.length();
	    if (opt instanceof Variadic)
	    {	line += " [\033[04m" + opt.argument + "\033[24m...]";
		l += opt.argument.length() + 6;
	    }
	    else if (opt instanceof Argumented)
	    {	line += " \033[04m" + opt.argument + "\033[24m";
		l += opt.argument.length() + 1;
	    }
	    lines.add(line);
	    lens.add(new int[] { l });
	}
	
	int col = 0;
	for (final int[] len : lens)
	    if (col < len[0])
		col = len[0];
	col += 8 - ((col - 4) & 7);
	int index = 0;
	while (empty.length() < col)
	    empty += empty;
	empty = empty.substring(0, col);
	for (final Option opt : this.options)
	{   if (opt.help == null)
		continue;
	    boolean first = true;
	    final String colour = (index & 1) == 0 ? "36" : "34";
	    {   String line = lines.get(index).replace("\0", "\033[" + colour + ";01m");
		line += empty.substring(lens.get(index)[0]);
		this.print(line, false);
	    }
	    for (final String line : opt.help.split("\n"))
		if (first)
		{   first = false;
		    print(line + "\033[00m\n");
		}
		else
		    print(empty + "\033[" + colour + "m" + line + "\033[00m\n");
	    index++;
	}
	
	this.println(true);
    }
    
    
    /**
     * Parse arguments
     * 
     * @param   args  The command line arguments, however it should not include the execute file at index 0
     * @return        Whether no unrecognised option is used
     */
    public boolean parse(final String[] argv)
    {
	this.arguments = argv;
	
	final ArrayList<String> argqueue = new ArrayList<String>();
	final ArrayList<String> optqueue = new ArrayList<String>();
	final ArrayList<String>    queue = new ArrayList<String>();
	for (final String arg : argv)
	    queue.add(arg);
	
	boolean dashed = false, tmpdashed = false, rc = true;
	int get = 0, dontget = 0;
	
	while (queue.size() > 0)
	{   final String arg = queue.remove(0);
	    if ((get > 0) && (dontget == 0))
	    {   get--;
		argqueue.add(arg);
	    }
	    else if (tmpdashed)
	    {	this.files.add(arg);
		tmpdashed = false;
	    }
	    else if (dashed)            this.files.add(arg);
	    else if (arg.equals("++"))  tmpdashed = true;
	    else if (arg.equals("--"))  dashed = true;
	    else if ((arg.length() > 1) && ((arg.charAt(0) == '-') || (arg.charAt(0) == '+')))
		if ((arg.length() > 2) && (arg.charAt(1) == arg.charAt(0)))
		{   Option opt = this.optmap.get(arg);
		    if (dontget > 0)
			dontget--;
		    else if ((opt != null) && (opt.getClass() == Argumentless.class))
		    {	optqueue.add(arg);
			argqueue.add(null);
		    }
		    else if (arg.contains("="))
		    {	String arg_opt = arg.substring(0, arg.indexOf('='));
			Option arg_opt_opt = this.optmap.get(arg_opt);
			if ((arg_opt_opt != null) && (arg_opt_opt instanceof Argumented))
			{   optqueue.add(arg_opt);
			    argqueue.add(arg.substring(arg.indexOf('=') + 1));
			    if (arg_opt_opt instanceof Variadic)
				dashed = true;
			}
			else
			{   if (++this.unrecognisedCount <= 5)
				this.println(this.program + ": warning: unrecognised option " + arg, true);
			    rc = false;
			}
		    }
		    else if ((opt != null) && (opt.getClass() == Argumented.class))
		    {	optqueue.add(arg);
			get++;
		    }
		    else if ((opt != null) && (opt.getClass() == Variadic.class))
		    {	optqueue.add(arg);
			argqueue.add(null);
			dashed = true;
		    }
		    else
		    {   if (++this.unrecognisedCount <= 5)
			    this.println(this.program + ": warning: unrecognised option " + arg, true);
			rc = false;
		    }
		}
		else
		{   String sign = String.valueOf(arg.charAt(0)), narg;
		    int i = 1, n = arg.length();
		    while (i < n)
		    {	Option opt = this.optmap.get(narg = sign + arg.charAt(i++));
			if (opt != null)
			    if (opt.getClass() == Argumentless.class)
			    {   optqueue.add(narg);
				argqueue.add(null);
			    }
			    else if (opt.getClass() == Argumented.class)
			    {	optqueue.add(narg);
				String nargarg = arg.substring(i);
				if (nargarg.length() == 0)
				    get++;
				else
				    argqueue.add(nargarg);
				break;
			    }
			    else
			    {	optqueue.add(narg);
				String nargarg = arg.substring(i);
				argqueue.add(nargarg.length() > 0 ? nargarg : null);
				dashed = true;
				break;
			    }
			else
			{   if (++this.unrecognisedCount <= 5)
				this.println(this.program + ": warning: unrecognised option " + arg, true);
			    rc = false;
			}
		}   }
	    else
		this.files.add(arg);
	}
	
	int i = 0, n = optqueue.size();
	while (i < n)
	{
	    final String opt = this.optmap.get(optqueue.get(i)).standard;
	    final String arg = argqueue.size() > i ? argqueue.get(i) : null;
	    i++;
	    if (this.opts.get(opt) == null)
		this.opts.put(opt, new String[] {});
	    if (argqueue.size() >= i)
		this.opts.put(opt, append(this.opts.get(opt), arg));
	}
	
	for (final Option opt : this.options)
	    if (opt.getClass() == Variadic.class)
	    {	final String[] varopt = this.opts.get(opt.standard);
		if (varopt != null)
		{
		    final String[] additional = new String[this.files.size()];
		    this.files.toArray(additional);
		    if (varopt[0] == null)
			this.opts.put(opt.standard, additional);
		    else
			this.opts.put(opt.standard, append(varopt, additional));
		    this.files.clear();
		    break;
	    }	}
	
	final StringBuilder sb = new StringBuilder();
	for (final String file : this.files)
	{   sb.append(' ');
	    sb.append(file);
	}
	this.message = sb.toString().substring(1);
	
	if (this.unrecognisedCount > 5)
	{   int more = this.unrecognisedCount - 5;
            this.print(this.program + ": warning: " + more + " more unrecognised ");
	    this.println(more == 1 ? "option" : "options");
	}
	
	return rc;
    }
    
    
    /**
     * Create a new identical array, except with extra items at the end
     * 
     * @param   array  The array
     * @param   items  The new items
     * @return         The new array
     */
    private String[] append(final String[] array, final String... items)
    {
	final String[] rc = new String[array.length + items.length];
	System.arraycopy(array, 0, rc, 0, array.length);
	System.arraycopy(items, 0, rc, array.length, items.length);
	return rc;
    }
    
}