| /* Copyright (C) 2003 Vladimir Roubtsov. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under |
| * the terms of the Common Public License v1.0 which accompanies this distribution, |
| * and is available at http://www.eclipse.org/legal/cpl-v10.html |
| * |
| * $Id: OptsParser.java,v 1.1.1.1 2004/05/09 16:57:57 vlad_r Exp $ |
| */ |
| package com.vladium.util.args; |
| |
| import java.io.CharArrayWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.io.PrintWriter; |
| import java.io.Reader; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import com.vladium.util.IConstants; |
| import com.vladium.util.ResourceLoader; |
| |
| // ---------------------------------------------------------------------------- |
| /** |
| * @author Vlad Roubtsov, (C) 2002 |
| */ |
| final class OptsParser implements IOptsParser |
| { |
| // public: ................................................................ |
| |
| // TODO: #-comments |
| // TODO: prefixing for error messages |
| // TODO: support var subst (main class name, etc) |
| // TODO: support short/full usage |
| // TODO: support marking opts as for displayable in full usage only |
| |
| public synchronized void usage (final PrintWriter out, final int level, final int width) |
| { |
| // TODO: use width |
| // TODO: cache? |
| |
| final String prefix = OPT_PREFIXES [CANONICAL_OPT_PREFIX]; |
| |
| for (Iterator i = m_metadata.getOptDefs (); i.hasNext (); ) |
| { |
| final OptDef optdef = (OptDef) i.next (); |
| |
| if ((level < 2) && optdef.isDetailedOnly ()) // skip detailed usage only options |
| continue; |
| |
| final StringBuffer line = new StringBuffer (" "); |
| |
| final String canonicalName = optdef.getCanonicalName (); |
| final boolean isPattern = optdef.isPattern (); |
| |
| line.append (prefix); |
| line.append (canonicalName); |
| if (isPattern) line.append ('*'); |
| |
| final String [] names = optdef.getNames (); |
| for (int n = 0; n < names.length; ++ n) |
| { |
| final String name = names [n]; |
| if (! name.equals (canonicalName)) |
| { |
| line.append (", "); |
| |
| line.append (prefix); |
| line.append (name); |
| if (isPattern) line.append ('*'); |
| } |
| } |
| |
| final String vmnemonic = optdef.getValueMnemonic (); |
| if (vmnemonic != null) |
| { |
| line.append (' '); |
| line.append (vmnemonic); |
| } |
| |
| |
| int padding = 16 - line.length (); |
| if (padding < 2) |
| { |
| // end the current line |
| out.println (line); |
| |
| line.setLength (0); |
| for (int p = 0; p < 16; ++ p) line.append (' '); |
| } |
| else |
| { |
| for (int p = 0; p < padding; ++ p) line.append (' '); |
| } |
| |
| if (optdef.isRequired ()) line.append ("{required} "); |
| line.append (optdef.getDescription ()); |
| |
| out.println (line); |
| } |
| |
| if (level < DETAILED_USAGE) |
| { |
| final OptDef usageOptDef = m_metadata.getUsageOptDef (); |
| if ((usageOptDef != null) && (usageOptDef.getNames () != null) && (usageOptDef.getNames ().length > 1)) |
| { |
| out.println (); |
| out.println (" {use '" + usageOptDef.getNames () [1] + "' option to see detailed usage help}"); |
| } |
| } |
| } |
| |
| public synchronized IOpts parse (final String [] args) |
| { |
| if (args == null) throw new IllegalArgumentException ("null input: args"); |
| |
| final Opts opts = new Opts (); |
| |
| { |
| final String [] nv = new String [2]; // out buffer for getOptNameAndValue() |
| final String [] pp = new String [1]; // out buffer for getOptDef() |
| |
| // running state/current vars: |
| int state = STATE_OPT; |
| OptDef optdef = null; |
| Opt opt = null; |
| String value = null; |
| int valueCount = 0; |
| |
| int a; |
| scan: for (a = 0; a < args.length; ) |
| { |
| final String av = args [a]; |
| if (av == null) throw new IllegalArgumentException ("null input: args[" + a + "]"); |
| |
| //System.out.println ("[state: " + state + "] av = " + av); |
| |
| switch (state) |
| { |
| case STATE_OPT: |
| { |
| if (isOpt (av, valueCount, optdef)) |
| { |
| // 'av' looks like an option: get its name and see if it |
| // is in the metadata |
| |
| valueCount = 0; |
| |
| getOptNameAndValue (av, nv); // this can leave nv[1] as null |
| |
| // [assertion: nv [0] != null] |
| |
| final String optName = nv [0]; // is not necessarily canonical |
| optdef = m_metadata.getOptDef (optName, pp); // pp [0] is always set by this |
| |
| if (optdef == null) |
| { |
| // unknown option: |
| |
| // TODO: coded messages? |
| opts.addError (formatMessage ("unknown option \'" + optName + "\'")); |
| |
| state = STATE_ERROR; |
| } |
| else |
| { |
| // merge if necessary: |
| |
| final String canonicalName = getOptCanonicalName (optName, optdef); |
| final String patternPrefix = pp [0]; |
| |
| opt = opts.getOpt (canonicalName); |
| |
| if (optdef.isMergeable ()) |
| { |
| if (opt == null) |
| { |
| opt = new Opt (optName, canonicalName, patternPrefix); |
| opts.addOpt (opt, optdef, optName); |
| } |
| } |
| else |
| { |
| if (opt == null) |
| { |
| opt = new Opt (optName, canonicalName, patternPrefix); |
| opts.addOpt (opt, optdef, optName); |
| } |
| else |
| { |
| opts.addError (formatMessage ("option \'" + optName + "\' cannot be specified more than once")); |
| |
| state = STATE_ERROR; |
| } |
| } |
| |
| value = nv [1]; |
| |
| if (value == null) ++ a; |
| state = STATE_OPT_VALUE; |
| } |
| } |
| else |
| { |
| // not in STATE_OPT_VALUE and 'av' does not look |
| // like an option: the rest of args are free |
| |
| state = STATE_FREE_ARGS; |
| } |
| } |
| break; |
| |
| |
| case STATE_OPT_VALUE: |
| { |
| // [assertion: opt != null and optdef != null] |
| |
| if (value != null) |
| { |
| // value specified explicitly using the <name>separator<value> syntax: |
| // [don't shift a] |
| |
| valueCount = 1; |
| |
| final int [] cardinality = optdef.getValueCardinality (); |
| |
| if (cardinality [1] < 1) |
| { |
| opts.addError (formatMessage ("option \'" + opt.getName () + "\' does not accept values: \'" + value + "\'")); |
| |
| state = STATE_ERROR; |
| } |
| else |
| { |
| ++ a; |
| opt.addValue (value); |
| } |
| } |
| else |
| { |
| value = args [a]; |
| |
| final int [] cardinality = optdef.getValueCardinality (); |
| |
| if (isOpt (value, valueCount, optdef)) |
| { |
| if (valueCount < cardinality [0]) |
| { |
| opts.addError (formatMessage ("option \'" + opt.getName () + "\' does not accept fewer than " + cardinality [0] + " value(s)")); |
| |
| state = STATE_ERROR; |
| } |
| else |
| state = STATE_OPT; |
| } |
| else |
| { |
| if (valueCount < cardinality [1]) |
| { |
| ++ valueCount; |
| ++ a; |
| opt.addValue (value); |
| } |
| else |
| { |
| // this check is redundant: |
| // if (valueCount < cardinality [0]) |
| // { |
| // opts.addError (formatMessage ("option \'" + opt.getName () + "\' does not accept fewer than " + cardinality [0] + " value(s)")); |
| // |
| // state = STATE_ERROR; |
| // } |
| // else |
| state = STATE_FREE_ARGS; |
| } |
| } |
| } |
| |
| value = null; |
| } |
| break; |
| |
| |
| case STATE_FREE_ARGS: |
| { |
| if (isOpt (args [a], valueCount, optdef)) |
| { |
| state = STATE_OPT; |
| } |
| else |
| { |
| opts.setFreeArgs (args, a); |
| break scan; |
| } |
| } |
| break; |
| |
| |
| case STATE_ERROR: |
| { |
| break scan; // TODO: could use the current value of 'a' for a better error message |
| } |
| |
| } // end of switch |
| } |
| |
| if (a == args.length) |
| { |
| if (opt != null) // validate the last option's min cardinality |
| { |
| final int [] cardinality = optdef.getValueCardinality (); |
| |
| if (valueCount < cardinality [0]) |
| { |
| opts.addError (formatMessage ("option \'" + opt.getName () + "\' does not accept fewer than " + cardinality [0] + " value(s)")); |
| } |
| } |
| else |
| { |
| opts.setFreeArgs (args, a); |
| } |
| } |
| |
| } // end of 'args' parsing |
| |
| |
| final IOpt [] specified = opts.getOpts (); |
| if (specified != null) |
| { |
| // validation: all required parameters must be specified |
| |
| final Set /* String(canonical name) */ required = new HashSet (); |
| required.addAll (m_metadata.getRequiredOpts ()); |
| |
| for (int s = 0; s < specified.length; ++ s) |
| { |
| required.remove (specified [s].getCanonicalName ()); |
| } |
| |
| if (! required.isEmpty ()) |
| { |
| for (Iterator i = required.iterator (); i.hasNext (); ) |
| { |
| opts.addError (formatMessage ("missing required option \'" + (String) i.next () + "\'")); |
| } |
| } |
| |
| for (int s = 0; s < specified.length; ++ s) |
| { |
| final IOpt opt = specified [s]; |
| final OptDef optdef = m_metadata.getOptDef (opt.getCanonicalName (), null); |
| |
| // // validation: value cardinality constraints |
| // |
| // final int [] cardinality = optdef.getValueCardinality (); |
| // if (opt.getValueCount () < cardinality [0]) |
| // opts.addError (formatMessage ("option \'" + opt.getName () + "\' must have at least " + cardinality [0] + " value(s)")); |
| // else if (opt.getValueCount () > cardinality [1]) |
| // opts.addError (formatMessage ("option \'" + opt.getName () + "\' must not have more than " + cardinality [1] + " value(s)")); |
| |
| // validation: "requires" constraints |
| |
| final String [] requires = optdef.getRequiresSet (); // not canonicalized |
| if (requires != null) |
| { |
| for (int r = 0; r < requires.length; ++ r) |
| { |
| if (opts.getOpt (requires [r]) == null) |
| opts.addError (formatMessage ("option \'" + opt.getName () + "\' requires option \'" + requires [r] + "\'")); |
| } |
| } |
| |
| // validation: "not with" constraints |
| |
| final String [] excludes = optdef.getExcludesSet (); // not canonicalized |
| if (excludes != null) |
| { |
| for (int x = 0; x < excludes.length; ++ x) |
| { |
| final Opt xopt = opts.getOpt (excludes [x]); |
| if (xopt != null) |
| opts.addError (formatMessage ("option \'" + opt.getName () + "\' cannot be used with option \'" + xopt.getName () + "\'")); |
| } |
| } |
| |
| // side effect: determine if usage is requested |
| |
| if (optdef.isUsage ()) |
| { |
| opts.setUsageRequested (opt.getName ().equals (opt.getCanonicalName ()) ? SHORT_USAGE : DETAILED_USAGE); |
| } |
| } |
| } |
| |
| return opts; |
| } |
| |
| private static String getOptCanonicalName (final String n, final OptDef optdef) |
| { |
| if (optdef.isPattern ()) |
| { |
| final String canonicalPattern = optdef.getCanonicalName (); |
| final String [] patterns = optdef.getNames (); |
| |
| for (int p = 0; p < patterns.length; ++ p) |
| { |
| final String pattern = patterns [p]; |
| |
| if (n.startsWith (pattern)) |
| { |
| return canonicalPattern.concat (n.substring (pattern.length ())); |
| } |
| } |
| |
| // this should never happen: |
| throw new IllegalStateException ("failed to detect pattern prefix for [" + n + "]"); |
| } |
| else |
| { |
| return optdef.getCanonicalName (); |
| } |
| } |
| |
| /* |
| * ['optdef' can be null if no current opt def context has been established] |
| * |
| * pre: av != null |
| * input not validated |
| */ |
| private static boolean isOpt (final String av, final int valueCount, final OptDef optdef) |
| { |
| if (optdef != null) |
| { |
| // if the current optdef calls for more values, consume the next token |
| // as an op value greedily, without looking at its prefix: |
| |
| final int [] cardinality = optdef.getValueCardinality (); |
| |
| if (valueCount < cardinality [1]) return false; |
| } |
| |
| // else check av's prefix: |
| |
| for (int p = 0; p < OPT_PREFIXES.length; ++ p) |
| { |
| if (av.startsWith (OPT_PREFIXES [p])) |
| return (av.length () > OPT_PREFIXES [p].length ()); |
| } |
| |
| return false; |
| } |
| |
| /* |
| * pre: av != null and isOpt(av)=true |
| * input not validated |
| */ |
| private static void getOptNameAndValue (final String av, final String [] nv) |
| { |
| nv [0] = null; |
| nv [1] = null; |
| |
| for (int p = 0; p < OPT_PREFIXES.length; ++ p) |
| { |
| if ((av.startsWith (OPT_PREFIXES [p])) && (av.length () > OPT_PREFIXES [p].length ())) |
| { |
| final String name = av.substring (OPT_PREFIXES [p].length ()); // with a possible value after a separator |
| |
| char separator = 0; |
| int sindex = Integer.MAX_VALUE; |
| |
| for (int s = 0; s < OPT_VALUE_SEPARATORS.length; ++ s) |
| { |
| final int index = name.indexOf (OPT_VALUE_SEPARATORS [s]); |
| if ((index > 0) && (index < sindex)) |
| { |
| separator = OPT_VALUE_SEPARATORS [s]; |
| sindex = index; |
| } |
| } |
| |
| if (separator != 0) |
| { |
| nv [0] = name.substring (0, sindex); |
| nv [1] = name.substring (sindex + 1); |
| } |
| else |
| { |
| nv [0] = name; |
| } |
| |
| return; |
| } |
| } |
| } |
| |
| // protected: ............................................................. |
| |
| // package: ............................................................... |
| |
| |
| static final class Opt implements IOptsParser.IOpt |
| { |
| public String getName () |
| { |
| return m_name; |
| } |
| |
| public String getCanonicalName () |
| { |
| return m_canonicalName; |
| } |
| |
| public int getValueCount () |
| { |
| if (m_values == null) return 0; |
| |
| return m_values.size (); |
| } |
| |
| public String getFirstValue () |
| { |
| if (m_values == null) return null; |
| |
| return (String) m_values.get (0); |
| } |
| |
| public String [] getValues () |
| { |
| if (m_values == null) return IConstants.EMPTY_STRING_ARRAY; |
| |
| final String [] result = new String [m_values.size ()]; |
| m_values.toArray (result); |
| |
| return result; |
| } |
| |
| public String getPatternPrefix () |
| { |
| return m_patternPrefix; |
| } |
| |
| public String toString () |
| { |
| final StringBuffer s = new StringBuffer (m_name); |
| if (! m_canonicalName.equals (m_name)) s.append (" [" + m_canonicalName + "]"); |
| |
| if (m_values != null) |
| { |
| s.append (": "); |
| s.append (m_values); |
| } |
| |
| return s.toString (); |
| } |
| |
| Opt (final String name, final String canonicalName, final String patternPrefix) |
| { |
| m_name = name; |
| m_canonicalName = canonicalName; |
| m_patternPrefix = patternPrefix; |
| } |
| |
| void addValue (final String value) |
| { |
| if (value == null) throw new IllegalArgumentException ("null input: value"); |
| |
| if (m_values == null) m_values = new ArrayList (); |
| m_values.add (value); |
| } |
| |
| |
| private final String m_name, m_canonicalName, m_patternPrefix; |
| private ArrayList m_values; |
| |
| } // end of nested class |
| |
| |
| static final class Opts implements IOptsParser.IOpts |
| { |
| public int usageRequestLevel () |
| { |
| return m_usageRequestLevel; |
| } |
| |
| public void error (final PrintWriter out, final int width) |
| { |
| // TODO: use width |
| if (hasErrors ()) |
| { |
| for (Iterator i = m_errors.iterator (); i.hasNext (); ) |
| { |
| out.println (i.next ()); |
| } |
| } |
| } |
| |
| public String [] getFreeArgs () |
| { |
| if (hasErrors ()) |
| throw new IllegalStateException (errorsToString ()); |
| |
| return m_freeArgs; |
| } |
| |
| public IOpt [] getOpts () |
| { |
| if (hasErrors ()) return null; |
| |
| if (m_opts.isEmpty ()) |
| return EMPTY_OPT_ARRAY; |
| else |
| { |
| final IOpt [] result = new IOpt [m_opts.size ()]; |
| m_opts.toArray (result); |
| |
| return result; |
| } |
| } |
| |
| public IOpt [] getOpts (final String pattern) |
| { |
| if (hasErrors ()) return null; |
| |
| final List /* Opt */ patternOpts = (List) m_patternMap.get (pattern); |
| |
| if ((patternOpts == null) || patternOpts.isEmpty ()) |
| return EMPTY_OPT_ARRAY; |
| else |
| { |
| final IOpt [] result = new IOpt [patternOpts.size ()]; |
| patternOpts.toArray (result); |
| |
| return result; |
| } |
| } |
| |
| |
| public boolean hasArg (final String name) |
| { |
| if (hasErrors ()) |
| throw new IllegalStateException (errorsToString ()); |
| |
| return m_nameMap.containsKey (name); |
| } |
| |
| Opts () |
| { |
| m_opts = new ArrayList (); |
| m_nameMap = new HashMap (); |
| m_patternMap = new HashMap (); |
| } |
| |
| void addOpt (final Opt opt, final OptDef optdef, final String occuranceName) |
| { |
| if (opt == null) throw new IllegalArgumentException ("null input: opt"); |
| if (optdef == null) throw new IllegalArgumentException ("null input: optdef"); |
| if (occuranceName == null) throw new IllegalArgumentException ("null input: occuranceName"); |
| |
| // [name collisions detected elsewhere] |
| |
| m_opts.add (opt); |
| |
| final String [] names = optdef.getNames (); |
| final boolean isPattern = (opt.getPatternPrefix () != null); |
| |
| if (isPattern) |
| { |
| final String unprefixedName = occuranceName.substring (opt.getPatternPrefix ().length ()); |
| |
| for (int n = 0; n < names.length; ++ n) |
| { |
| m_nameMap.put (names [n].concat (unprefixedName), opt); |
| } |
| |
| { |
| final String canonicalPattern = optdef.getCanonicalName (); |
| |
| List patternList = (List) m_patternMap.get (canonicalPattern); |
| if (patternList == null) |
| { |
| patternList = new ArrayList (); |
| for (int n = 0; n < names.length; ++ n) |
| { |
| m_patternMap.put (names [n], patternList); |
| } |
| } |
| |
| patternList.add (opt); |
| } |
| } |
| else |
| { |
| for (int n = 0; n < names.length; ++ n) |
| { |
| m_nameMap.put (names [n], opt); |
| } |
| } |
| } |
| |
| Opt getOpt (final String occuranceName) |
| { |
| if (occuranceName == null) throw new IllegalArgumentException ("null input: occuranceName"); |
| |
| return (Opt) m_nameMap.get (occuranceName); |
| } |
| |
| void setFreeArgs (final String [] args, final int start) |
| { |
| if (args == null) throw new IllegalArgumentException ("null input: args"); |
| if ((start < 0) || (start > args.length)) throw new IllegalArgumentException ("invalid start index: " + start); |
| |
| m_freeArgs = new String [args.length - start]; |
| System.arraycopy (args, start, m_freeArgs, 0, m_freeArgs.length); |
| } |
| |
| void setUsageRequested (final int level) |
| { |
| m_usageRequestLevel = level; |
| } |
| |
| void addError (final String msg) |
| { |
| if (msg != null) |
| { |
| if (m_errors == null) m_errors = new ArrayList (); |
| |
| m_errors.add (msg); |
| } |
| } |
| |
| boolean hasErrors () |
| { |
| return (m_errors != null) && ! m_errors.isEmpty (); |
| } |
| |
| String errorsToString () |
| { |
| if (! hasErrors ()) return "<no errors>"; |
| |
| final CharArrayWriter caw = new CharArrayWriter (); |
| final PrintWriter pw = new PrintWriter (caw); |
| |
| error (pw, DEFAULT_ERROR_WIDTH); |
| pw.flush (); |
| |
| return caw.toString (); |
| } |
| |
| |
| private final List /* Opt */ m_opts; |
| private final Map /* String(name/pattern-prefixed name)->Opt */ m_nameMap; |
| private final Map /* String(pattern prefix)->List<Opt> */ m_patternMap; |
| private String [] m_freeArgs; |
| private List /* String */ m_errors; |
| private int m_usageRequestLevel; |
| |
| private static final int DEFAULT_ERROR_WIDTH = 80; |
| private static final IOpt [] EMPTY_OPT_ARRAY = new IOpt [0]; |
| |
| } // end of nested class |
| |
| |
| static final class OptDef // TODO: merge with Opt? |
| { |
| OptDef (final boolean usage) |
| { |
| m_usage = usage; |
| } |
| |
| boolean isUsage () |
| { |
| return m_usage; |
| } |
| |
| String getCanonicalName () |
| { |
| return m_names [0]; |
| } |
| |
| String [] getNames () |
| { |
| return m_names; |
| } |
| |
| boolean isRequired () |
| { |
| return m_required; |
| } |
| |
| String getValueMnemonic () |
| { |
| return m_valueMnemonic; |
| } |
| |
| boolean isMergeable () |
| { |
| return m_mergeable; |
| } |
| |
| boolean isDetailedOnly () |
| { |
| return m_detailedOnly; |
| } |
| |
| boolean isPattern () |
| { |
| return m_pattern; |
| } |
| |
| int [] getValueCardinality () |
| { |
| return m_valueCardinality; |
| } |
| |
| String [] getRequiresSet () |
| { |
| return m_requiresSet; |
| } |
| |
| String [] getExcludesSet () |
| { |
| return m_excludesSet; |
| } |
| |
| String getDescription () |
| { |
| return m_description; |
| } |
| |
| void setNames (final String [] names) |
| { |
| if (names == null) throw new IllegalArgumentException ("null input: names"); |
| |
| m_names = names; |
| } |
| |
| void setRequired (final boolean required) |
| { |
| m_required = required; |
| } |
| |
| void setValueMnemonic (final String mnemonic) |
| { |
| if (mnemonic == null) throw new IllegalArgumentException ("null input: mnemonic"); |
| |
| m_valueMnemonic = mnemonic; |
| } |
| |
| void setMergeable (final boolean mergeable) |
| { |
| m_mergeable = mergeable; |
| } |
| |
| void setDetailedOnly (final boolean detailedOnly) |
| { |
| m_detailedOnly = detailedOnly; |
| } |
| |
| void setPattern (final boolean pattern) |
| { |
| m_pattern = pattern; |
| } |
| |
| void setValueCardinality (final int [] cardinality) |
| { |
| if ((cardinality == null) || (cardinality.length != 2)) throw new IllegalArgumentException ("null or invalid input: cardinality"); |
| |
| m_valueCardinality = cardinality; |
| } |
| |
| void setRequiresSet (final String [] names) |
| { |
| if (names == null) throw new IllegalArgumentException ("null input: names"); |
| |
| m_requiresSet = names.length > 0 ? names : null; |
| } |
| |
| void setExcludesSet (final String [] names) |
| { |
| if (names == null) throw new IllegalArgumentException ("null input: names"); |
| |
| m_excludesSet = names.length > 0 ? names : null; |
| } |
| |
| void setDescription (final String description) |
| { |
| if (description == null) throw new IllegalArgumentException ("null input: description"); |
| |
| m_description = description; |
| } |
| |
| |
| static final int [] C_ZERO = new int [] {0, 0}; |
| static final int [] C_ONE = new int [] {1, 1}; |
| static final int [] C_ZERO_OR_ONE = new int [] {0, 1}; |
| static final int [] C_ZERO_OR_MORE = new int [] {0, Integer.MAX_VALUE}; |
| static final int [] C_ONE_OR_MORE = new int [] {1, Integer.MAX_VALUE}; |
| |
| |
| private final boolean m_usage; |
| private String [] m_names; |
| private boolean m_required; |
| private String m_valueMnemonic; |
| private boolean m_mergeable; |
| private boolean m_detailedOnly; |
| private boolean m_pattern; |
| private int [] m_valueCardinality; |
| private String [] m_requiresSet, m_excludesSet; |
| private String m_description; |
| |
| } // end of nested class |
| |
| |
| static final class OptDefMetadata |
| { |
| OptDefMetadata () |
| { |
| m_optdefs = new ArrayList (); |
| m_optdefMap = new HashMap (); |
| m_requiredOpts = new HashSet (); |
| m_patternOptDefMap = new HashMap (); |
| } |
| |
| OptDef getOptDef (final String name, final String [] prefixout) |
| { |
| if (name == null) throw new IllegalArgumentException ("null input: name"); |
| |
| if (prefixout != null) prefixout [0] = null; |
| |
| // first, see if this is a regular option: |
| OptDef result = (OptDef) m_optdefMap.get (name); |
| |
| // next, see if this is a prefixed option: |
| if (result == null) |
| { |
| for (Iterator ps = m_patternOptDefMap.entrySet ().iterator (); |
| ps.hasNext (); ) |
| { |
| final Map.Entry entry = (Map.Entry) ps.next (); |
| final String pattern = (String) entry.getKey (); |
| |
| if (name.startsWith (pattern)) |
| { |
| if (prefixout != null) prefixout [0] = pattern; |
| result = (OptDef) entry.getValue (); |
| break; |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| Iterator /* OptDef */ getOptDefs () |
| { |
| return m_optdefs.iterator (); |
| } |
| |
| OptDef getPatternOptDefs (final String pattern) // returns null if no such pattern is defined |
| { |
| if (pattern == null) throw new IllegalArgumentException ("null input: pattern"); |
| |
| return (OptDef) m_patternOptDefMap.get (pattern); |
| } |
| |
| Set /* String(canonical name) */ getRequiredOpts () |
| { |
| return m_requiredOpts; |
| } |
| |
| OptDef getUsageOptDef () |
| { |
| return m_usageOptDef; |
| } |
| |
| void addOptDef (final OptDef optdef) |
| { |
| if (optdef == null) throw new IllegalArgumentException ("null input: optdef"); |
| |
| final Map map = optdef.isPattern () ? m_patternOptDefMap : m_optdefMap; |
| final String [] names = optdef.getNames (); |
| |
| for (int n = 0; n < names.length; ++ n) |
| { |
| if (map.containsKey (names [n])) |
| throw new IllegalArgumentException ("duplicate option name [" + names [n] + "]"); |
| |
| map.put (names [n], optdef); |
| } |
| |
| m_optdefs.add (optdef); |
| |
| if (optdef.isRequired ()) |
| m_requiredOpts.add (optdef.getCanonicalName ()); |
| |
| if (optdef.isUsage ()) |
| { |
| if (m_usageOptDef != null) |
| throw new IllegalArgumentException ("usage optdef set already"); |
| |
| m_usageOptDef = optdef; |
| } |
| } |
| |
| |
| final List /* OptDef */ m_optdefs; // keeps the addition order |
| final Map /* String(name)->OptDef */ m_optdefMap; |
| final Set /* String(canonical name) */ m_requiredOpts; |
| final Map /* String(pattern name)->OptDef */ m_patternOptDefMap; |
| private OptDef m_usageOptDef; |
| |
| } // end of nested class |
| |
| |
| static final class MetadataParser |
| { |
| /* |
| * metadata := ( optdef )* <EOF> |
| * |
| * optdef := optnamelist ":" optmetadata ";" |
| * optnamelist := namelist |
| * optmetadata := |
| * ("optional" | "required" ) |
| * [ "," "mergeable" ] |
| * [ "," "detailedonly" ] |
| * [ "," "pattern" ] |
| * "," "values" ":" cardinality |
| * [ "," name ] |
| * [ "," "requires" "{" namelist "}" ] |
| * [ "," "notwith" "{" namelist "}" ] |
| * "," text |
| * cardinality := "0" | "1" | "?" |
| * namelist := name ( "," name )* |
| * name := <single quoted string> |
| * text := <double quoted string> |
| */ |
| OptDef [] parse (final Reader in) |
| { |
| if (in == null) throw new IllegalArgumentException ("null input: in"); |
| m_in = in; |
| |
| nextChar (); |
| nextToken (); |
| |
| while (m_token != Token.EOF) |
| { |
| if (m_opts == null) m_opts = new ArrayList (); |
| m_opts.add (optdef ()); |
| } |
| |
| final OptDef [] result; |
| |
| if ((m_opts == null) || (m_opts.size () == 0)) |
| result = EMPTY_OPTDEF_ARRAY; |
| else |
| { |
| result = new OptDef [m_opts.size ()]; |
| m_opts.toArray (result); |
| } |
| |
| m_in = null; |
| m_opts = null; |
| |
| return result; |
| } |
| |
| OptDef optdef () |
| { |
| final OptDef optdef = new OptDef (false); |
| |
| optdef.setNames (optnamelist ()); |
| accept (Token.COLON_ID); |
| optmetadata (optdef); |
| accept (Token.SEMICOLON_ID); |
| |
| return optdef; |
| } |
| |
| String [] optnamelist () |
| { |
| return namelist (); |
| } |
| |
| void optmetadata (final OptDef optdef) |
| { |
| switch (m_token.getID ()) |
| { |
| case Token.REQUIRED_ID: |
| { |
| accept (); |
| optdef.setRequired (true); |
| } |
| break; |
| |
| case Token.OPTIONAL_ID: |
| { |
| accept (); |
| optdef.setRequired (false); |
| } |
| break; |
| |
| default: |
| throw new IllegalArgumentException ("parse error: invalid token " + m_token + ", expected " + Token.REQUIRED + " or " + Token.OPTIONAL); |
| |
| } // end of switch |
| |
| accept (Token.COMMA_ID); |
| |
| if (m_token.getID () == Token.MERGEABLE_ID) |
| { |
| accept (); |
| optdef.setMergeable (true); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| if (m_token.getID () == Token.DETAILEDONLY_ID) |
| { |
| accept (); |
| optdef.setDetailedOnly (true); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| if (m_token.getID () == Token.PATTERN_ID) |
| { |
| accept (); |
| optdef.setPattern (true); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| accept (Token.VALUES_ID); |
| accept (Token.COLON_ID); |
| optdef.setValueCardinality (cardinality ()); |
| |
| accept (Token.COMMA_ID); |
| if (m_token.getID () == Token.STRING_ID) |
| { |
| optdef.setValueMnemonic (m_token.getValue ()); |
| accept (); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| if (m_token.getID () == Token.REQUIRES_ID) |
| { |
| accept (); |
| |
| accept (Token.LBRACKET_ID); |
| optdef.setRequiresSet (namelist ()); |
| accept (Token.RBRACKET_ID); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| if (m_token.getID () == Token.EXCLUDES_ID) |
| { |
| accept (); |
| |
| accept (Token.LBRACKET_ID); |
| optdef.setExcludesSet (namelist ()); |
| accept (Token.RBRACKET_ID); |
| |
| accept (Token.COMMA_ID); |
| } |
| |
| optdef.setDescription (accept (Token.TEXT_ID).getValue ()); |
| } |
| |
| int [] cardinality () |
| { |
| final Token result = accept (Token.CARD_ID); |
| |
| if ("0".equals (result.getValue ())) |
| return OptDef.C_ZERO; |
| else if ("1".equals (result.getValue ())) |
| return OptDef.C_ONE; |
| else // ? |
| return OptDef.C_ZERO_OR_ONE; |
| } |
| |
| String [] namelist () |
| { |
| final List _result = new ArrayList (); |
| |
| _result.add (accept (Token.STRING_ID).getValue ()); |
| while (m_token.getID () == Token.COMMA_ID) |
| { |
| accept (); |
| _result.add (accept (Token.STRING_ID).getValue ()); |
| } |
| |
| final String [] result = new String [_result.size ()]; |
| _result.toArray (result); |
| |
| return result; |
| } |
| |
| |
| Token accept () |
| { |
| final Token current = m_token; |
| nextToken (); |
| |
| return current; |
| } |
| |
| Token accept (final int tokenID) |
| { |
| final Token current = m_token; |
| |
| if (m_token.getID () == tokenID) |
| nextToken (); |
| else |
| throw new IllegalArgumentException ("parse error: invalid token [" + m_token + "], expected type [" + tokenID + "]"); |
| |
| return current; |
| } |
| |
| // "scanner": |
| |
| void nextToken () |
| { |
| consumeWS (); |
| |
| switch (m_currentChar) |
| { |
| case -1: m_token = Token.EOF; break; |
| |
| case ':': |
| { |
| nextChar (); |
| m_token = Token.COLON; |
| } |
| break; |
| |
| case ';': |
| { |
| nextChar (); |
| m_token = Token.SEMICOLON; |
| } |
| break; |
| |
| case ',': |
| { |
| nextChar (); |
| m_token = Token.COMMA; |
| } |
| break; |
| |
| case '{': |
| { |
| nextChar (); |
| m_token = Token.LBRACKET; |
| } |
| break; |
| |
| case '}': |
| { |
| nextChar (); |
| m_token = Token.RBRACKET; |
| } |
| break; |
| |
| case '0': |
| { |
| nextChar (); |
| m_token = new Token (Token.CARD_ID, "0"); |
| } |
| break; |
| |
| case '1': |
| { |
| nextChar (); |
| m_token = new Token (Token.CARD_ID, "1"); |
| } |
| break; |
| |
| case '?': |
| { |
| nextChar (); |
| m_token = new Token (Token.CARD_ID, "?"); |
| } |
| break; |
| |
| case '\'': |
| { |
| final StringBuffer value = new StringBuffer (); |
| |
| nextChar (); |
| while (m_currentChar != '\'') |
| { |
| value.append ((char) m_currentChar); |
| nextChar (); |
| } |
| nextChar (); |
| |
| m_token = new Token (Token.STRING_ID, value.toString ()); |
| } |
| break; |
| |
| case '\"': |
| { |
| final StringBuffer value = new StringBuffer (); |
| |
| nextChar (); |
| while (m_currentChar != '\"') |
| { |
| value.append ((char) m_currentChar); |
| nextChar (); |
| } |
| nextChar (); |
| |
| m_token = new Token (Token.TEXT_ID, value.toString ()); |
| } |
| break; |
| |
| default: |
| { |
| final StringBuffer value = new StringBuffer (); |
| |
| while (Character.isLetter ((char) m_currentChar)) |
| { |
| value.append ((char) m_currentChar); |
| nextChar (); |
| } |
| |
| final Token token = (Token) KEYWORDS.get (value.toString ()); |
| if (token == null) |
| throw new IllegalArgumentException ("parse error: unrecognized keyword [" + value + "]"); |
| |
| m_token = token; |
| } |
| |
| } // end of switch |
| } |
| |
| |
| private void consumeWS () |
| { |
| if (m_currentChar == -1) |
| return; |
| else |
| { |
| while (Character.isWhitespace ((char) m_currentChar)) |
| { |
| nextChar (); |
| } |
| } |
| |
| // TODO: #-comments |
| } |
| |
| private void nextChar () |
| { |
| try |
| { |
| m_currentChar = m_in.read (); |
| } |
| catch (IOException ioe) |
| { |
| throw new RuntimeException ("I/O error while parsing: " + ioe); |
| } |
| } |
| |
| |
| private Reader m_in; |
| private List m_opts; |
| |
| private Token m_token; |
| private int m_currentChar; |
| |
| private static final Map KEYWORDS; |
| |
| private static final OptDef [] EMPTY_OPTDEF_ARRAY = new OptDef [0]; |
| |
| static |
| { |
| KEYWORDS = new HashMap (17); |
| |
| KEYWORDS.put (Token.OPTIONAL.getValue (), Token.OPTIONAL); |
| KEYWORDS.put (Token.REQUIRED.getValue (), Token.REQUIRED); |
| KEYWORDS.put (Token.VALUES.getValue (), Token.VALUES); |
| KEYWORDS.put (Token.REQUIRES.getValue (), Token.REQUIRES); |
| KEYWORDS.put (Token.EXCLUDES.getValue (), Token.EXCLUDES); |
| KEYWORDS.put (Token.MERGEABLE.getValue (), Token.MERGEABLE); |
| KEYWORDS.put (Token.DETAILEDONLY.getValue (), Token.DETAILEDONLY); |
| KEYWORDS.put (Token.PATTERN.getValue (), Token.PATTERN); |
| } |
| |
| } // end of nested class |
| |
| |
| OptsParser (final String metadataResourceName, final ClassLoader loader, final String [] usageOpts) |
| { |
| this (metadataResourceName, loader, null, usageOpts); |
| } |
| |
| OptsParser (final String metadataResourceName, final ClassLoader loader, final String msgPrefix, final String [] usageOpts) |
| { |
| if (metadataResourceName == null) throw new IllegalArgumentException ("null input: metadataResourceName"); |
| |
| m_msgPrefix = msgPrefix; |
| |
| InputStream in = null; |
| try |
| { |
| in = ResourceLoader.getResourceAsStream (metadataResourceName, loader); |
| if (in == null) |
| throw new IllegalArgumentException ("resource [" + metadataResourceName + "] could not be loaded via [" + loader + "]"); |
| |
| // TODO: encoding |
| final Reader rin = new InputStreamReader (in); |
| |
| m_metadata = parseOptDefMetadata (rin, usageOpts); |
| } |
| finally |
| { |
| if (in != null) try { in.close (); } catch (IOException ignore) {} |
| } |
| } |
| |
| // private: ............................................................... |
| |
| |
| private static final class Token |
| { |
| Token (final int ID, final String value) |
| { |
| if (value == null) throw new IllegalArgumentException ("null input: value"); |
| |
| m_ID = ID; |
| m_value = value; |
| } |
| |
| int getID () |
| { |
| return m_ID; |
| } |
| |
| String getValue () |
| { |
| return m_value; |
| } |
| |
| public String toString () |
| { |
| return m_ID + ": [" + m_value + "]"; |
| } |
| |
| |
| static final int EOF_ID = 0; |
| static final int STRING_ID = 1; |
| static final int COLON_ID = 2; |
| static final int SEMICOLON_ID = 3; |
| static final int COMMA_ID = 4; |
| static final int LBRACKET_ID = 5; |
| static final int RBRACKET_ID = 6; |
| static final int OPTIONAL_ID = 7; |
| static final int REQUIRED_ID = 8; |
| static final int CARD_ID = 9; |
| static final int VALUES_ID = 10; |
| static final int TEXT_ID = 11; |
| static final int REQUIRES_ID = 12; |
| static final int EXCLUDES_ID = 13; |
| static final int MERGEABLE_ID = 14; |
| static final int DETAILEDONLY_ID = 15; |
| static final int PATTERN_ID = 16; |
| |
| static final Token EOF = new Token (EOF_ID, "<EOF>"); |
| static final Token COLON = new Token (COLON_ID, ":"); |
| static final Token SEMICOLON = new Token (SEMICOLON_ID, ";"); |
| static final Token COMMA = new Token (COMMA_ID, ","); |
| static final Token LBRACKET = new Token (LBRACKET_ID, "{"); |
| static final Token RBRACKET = new Token (RBRACKET_ID, "}"); |
| static final Token OPTIONAL = new Token (OPTIONAL_ID, "optional"); |
| static final Token REQUIRED = new Token (REQUIRED_ID, "required"); |
| static final Token VALUES = new Token (VALUES_ID, "values"); |
| static final Token REQUIRES = new Token (REQUIRES_ID, "requires"); |
| static final Token EXCLUDES = new Token (EXCLUDES_ID, "excludes"); |
| static final Token MERGEABLE = new Token (MERGEABLE_ID, "mergeable"); |
| static final Token DETAILEDONLY = new Token (DETAILEDONLY_ID, "detailedonly"); |
| static final Token PATTERN = new Token (PATTERN_ID, "pattern"); |
| |
| private final int m_ID; |
| private final String m_value; |
| |
| } // end of nested class |
| |
| |
| private static OptDefMetadata parseOptDefMetadata (final Reader in, final String [] usageOpts) |
| { |
| final MetadataParser parser = new MetadataParser (); |
| final OptDef [] optdefs = parser.parse (in); |
| |
| // validate: |
| |
| // for (int o = 0; o < optdefs.length; ++ o) |
| // { |
| // final OptDef optdef = optdefs [o]; |
| // final int [] cardinality = optdef.getValueCardinality (); |
| // |
| // if (optdef.isMergeable ()) |
| // { |
| // if ((cardinality [1] != 0) && (cardinality [1] != Integer.MAX_VALUE)) |
| // throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] is mergeable and can only specify {0, +inf} for max value cardinality: " + cardinality [1]); |
| // } |
| // } |
| |
| final OptDefMetadata result = new OptDefMetadata (); |
| for (int o = 0; o < optdefs.length; ++ o) |
| { |
| result.addOptDef (optdefs [o]); |
| } |
| |
| // add usage opts: |
| if (usageOpts != null) |
| { |
| final OptDef usage = new OptDef (true); |
| |
| usage.setNames (usageOpts); |
| usage.setDescription ("display usage information"); |
| usage.setValueCardinality (OptDef.C_ZERO); |
| usage.setRequired (false); |
| usage.setDetailedOnly (false); |
| usage.setMergeable (false); |
| |
| result.addOptDef (usage); |
| } |
| |
| // TODO: fix this to be pattern-savvy |
| |
| for (int o = 0; o < optdefs.length; ++ o) |
| { |
| final OptDef optdef = optdefs [o]; |
| |
| final String [] requires = optdef.getRequiresSet (); |
| if (requires != null) |
| { |
| for (int r = 0; r < requires.length; ++ r) |
| { |
| final OptDef ropt = result.getOptDef (requires [r], null); |
| if (ropt == null) |
| throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] specifies an unknown option [" + requires [r] + "] in its \'requires\' set"); |
| |
| if (ropt == optdef) |
| throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] specifies itself in its \'requires\' set"); |
| } |
| } |
| |
| final String [] excludes = optdef.getExcludesSet (); |
| if (excludes != null) |
| { |
| for (int x = 0; x < excludes.length; ++ x) |
| { |
| final OptDef xopt = result.getOptDef (excludes [x], null); |
| if (xopt == null) |
| throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] specifies an unknown option [" + excludes [x] + "] in its \'excludes\' set"); |
| |
| if (xopt.isRequired ()) |
| throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] specifies a required option [" + excludes [x] + "] in its \'excludes\' set"); |
| |
| if (xopt == optdef) |
| throw new IllegalArgumentException ("option [" + optdef.getCanonicalName () + "] specifies itself in its \'excludes\' set"); |
| } |
| } |
| } |
| |
| return result; |
| } |
| |
| private String formatMessage (final String msg) |
| { |
| if (m_msgPrefix == null) return msg; |
| else |
| { |
| return m_msgPrefix.concat (msg); |
| } |
| } |
| |
| |
| private final String m_msgPrefix; |
| private final OptDefMetadata m_metadata; |
| |
| private static final int CANONICAL_OPT_PREFIX = 1; // indexes into OPT_PREFIXES |
| private static final String [] OPT_PREFIXES = new String [] {"--", "-"}; // HACK: these must appear in decreasing length order |
| private static final char [] OPT_VALUE_SEPARATORS = new char [] {':', '='}; |
| |
| private static final int STATE_OPT = 0, STATE_OPT_VALUE = 1, STATE_FREE_ARGS = 2, STATE_ERROR = 3; |
| |
| } // end of class |
| // ---------------------------------------------------------------------------- |
