return tei.validate(data);
  }
  
  public void setTagExtraInfo(TagExtraInfo tei)
  {
    tagExtraInfo = tei;
  }
  
  public TagExtraInfo getTagExtraInfo()
  {
    return tagExtraInfo;
  }
  
  public String getTagClassName()
  {
    return tagClassName;
  }
  
  public String getBodyContent()
  {
    return bodyContent;
  }
  
  public String getInfoString()
  {
    return infoString;
  }
  
  public void setTagLibrary(TagLibraryInfo tl)
  {
    tagLibrary = tl;
  }
  
  public TagLibraryInfo getTagLibrary()
  {
    return tagLibrary;
  }
  
  public String getDisplayName()
  {
    return displayName;
  }
  
  public String getSmallIcon()
  {
    return smallIcon;
  }
  
  public String getLargeIcon()
  {
    return largeIcon;
  }
  
  public TagVariableInfo[] getTagVariableInfos()
  {
    return tagVariableInfo;
  }
  
  public boolean hasDynamicAttributes()
  {
    return dynamicAttributes;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TagInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

public abstract class TagLibraryInfo
{
  protected String prefix;
  protected String uri;
  protected TagInfo[] tags;
  protected TagFileInfo[] tagFiles;
  protected FunctionInfo[] functions;
  protected String tlibversion;
  protected String jspversion;
  protected String shortname;
  protected String urn;
  protected String info;
  
  protected TagLibraryInfo(String prefix, String uri)
  {
    this.prefix = prefix;
    this.uri = uri;
  }
  
  public String getURI()
  {
    return uri;
  }
  
  public String getPrefixString()
  {
    return prefix;
  }
  
  public String getShortName()
  {
    return shortname;
  }
  
  public String getReliableURN()
  {
    return urn;
  }
  
  public String getInfoString()
  {
    return info;
  }
  
  public String getRequiredVersion()
  {
    return jspversion;
  }
  
  public TagInfo[] getTags()
  {
    return tags;
  }
  
  public TagFileInfo[] getTagFiles()
  {
    return tagFiles;
  }
  
  public TagInfo getTag(String shortname)
  {
    TagInfo[] tags = getTags();
    if ((tags == null) || (tags.length == 0)) {
      return null;
    }
    for (int i = 0; i < tags.length; i++) {
      if (tags[i].getTagName().equals(shortname)) {
        return tags[i];
      }
    }
    return null;
  }
  
  public TagFileInfo getTagFile(String shortname)
  {
    TagFileInfo[] tagFiles = getTagFiles();
    if ((tagFiles == null) || (tagFiles.length == 0)) {
      return null;
    }
    for (int i = 0; i < tagFiles.length; i++) {
      if (tagFiles[i].getName().equals(shortname)) {
        return tagFiles[i];
      }
    }
    return null;
  }
  
  public FunctionInfo[] getFunctions()
  {
    return functions;
  }
  
  public FunctionInfo getFunction(String name)
  {
    if ((functions == null) || (functions.length == 0)) {
      return null;
    }
    for (int i = 0; i < functions.length; i++) {
      if (functions[i].getName().equals(name)) {
        return functions[i];
      }
    }
    return null;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TagLibraryInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

import java.util.Map;

public abstract class TagLibraryValidator
{
  private Map initParameters;
  
  public void setInitParameters(Map map)
  {
    initParameters = map;
  }
  
  public Map getInitParameters()
  {
    return initParameters;
  }
  
  public ValidationMessage[] validate(String prefix, String uri, PageData page)
  {
    return null;
  }
  
  public void release()
  {
    initParameters = null;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TagLibraryValidator
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

import java.io.Serializable;
import java.util.Enumeration;
import java.util.Hashtable;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.PageContext;

public class TagSupport
  implements IterationTag, Serializable
{
  private Tag parent;
  private Hashtable values;
  protected String id;
  protected PageContext pageContext;
  
  public static final Tag findAncestorWithClass(Tag from, Class klass)
  {
    boolean isInterface = false;
    if ((from == null) || (klass == null) || ((!Tag.class.isAssignableFrom(klass)) && (!(isInterface = klass.isInterface())))) {
      return null;
    }
    for (;;)
    {
      Tag tag = from.getParent();
      if (tag == null) {
        return null;
      }
      if (((isInterface) && (klass.isInstance(tag))) || (klass.isAssignableFrom(tag.getClass()))) {
        return tag;
      }
      from = tag;
    }
  }
  
  public int doStartTag()
    throws JspException
  {
    return 0;
  }
  
  public int doEndTag()
    throws JspException
  {
    return 6;
  }
  
  public int doAfterBody()
    throws JspException
  {
    return 0;
  }
  
  public void release()
  {
    parent = null;
    id = null;
    if (values != null) {
      values.clear();
    }
    values = null;
  }
  
  public void setParent(Tag t)
  {
    parent = t;
  }
  
  public Tag getParent()
  {
    return parent;
  }
  
  public void setId(String id)
  {
    this.id = id;
  }
  
  public String getId()
  {
    return id;
  }
  
  public void setPageContext(PageContext pageContext)
  {
    this.pageContext = pageContext;
  }
  
  public void setValue(String k, Object o)
  {
    if (values == null) {
      values = new Hashtable();
    }
    values.put(k, o);
  }
  
  public Object getValue(String k)
  {
    if (values == null) {
      return null;
    }
    return values.get(k);
  }
  
  public void removeValue(String k)
  {
    if (values != null) {
      values.remove(k);
    }
  }
  
  public Enumeration getValues()
  {
    if (values == null) {
      return null;
    }
    return values.keys();
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TagSupport
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

public class TagVariableInfo
{
  private String nameGiven;
  private String nameFromAttribute;
  private String className;
  private boolean declare;
  private int scope;
  
  public TagVariableInfo(String nameGiven, String nameFromAttribute, String className, boolean declare, int scope)
  {
    this.nameGiven = nameGiven;
    this.nameFromAttribute = nameFromAttribute;
    this.className = className;
    this.declare = declare;
    this.scope = scope;
  }
  
  public String getNameGiven()
  {
    return nameGiven;
  }
  
  public String getNameFromAttribute()
  {
    return nameFromAttribute;
  }
  
  public String getClassName()
  {
    return className;
  }
  
  public boolean getDeclare()
  {
    return declare;
  }
  
  public int getScope()
  {
    return scope;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TagVariableInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

public abstract interface TryCatchFinally
{
  public abstract void doCatch(Throwable paramThrowable)
    throws Throwable;
  
  public abstract void doFinally();
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.TryCatchFinally
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

public class ValidationMessage
{
  private String id;
  private String message;
  
  public ValidationMessage(String id, String message)
  {
    this.id = id;
    this.message = message;
  }
  
  public String getId()
  {
    return id;
  }
  
  public String getMessage()
  {
    return message;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.ValidationMessage
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package javax.servlet.jsp.tagext;

public class VariableInfo
{
  public static final int NESTED = 0;
  public static final int AT_BEGIN = 1;
  public static final int AT_END = 2;
  private String varName;
  private String className;
  private boolean declare;
  private int scope;
  
  public VariableInfo(String varName, String className, boolean declare, int scope)
  {
    this.varName = varName;
    this.className = className;
    this.declare = declare;
    this.scope = scope;
  }
  
  public String getVarName()
  {
    return varName;
  }
  
  public String getClassName()
  {
    return className;
  }
  
  public boolean getDeclare()
  {
    return declare;
  }
  
  public int getScope()
  {
    return scope;
  }
}

/* Location:
 * Qualified Name:     javax.servlet.jsp.tagext.VariableInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package net.jcip.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({java.lang.annotation.ElementType.FIELD, java.lang.annotation.ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface GuardedBy
{
  String value();
}

/* Location:
 * Qualified Name:     net.jcip.annotations.GuardedBy
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package net.jcip.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Immutable {}

/* Location:
 * Qualified Name:     net.jcip.annotations.Immutable
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package net.jcip.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface NotThreadSafe {}

/* Location:
 * Qualified Name:     net.jcip.annotations.NotThreadSafe
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package net.jcip.annotations;

import java.lang.annotation.Annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({java.lang.annotation.ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ThreadSafe {}

/* Location:
 * Qualified Name:     net.jcip.annotations.ThreadSafe
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

import com.beust.jcommander.validators.NoValidator;
import com.beust.jcommander.validators.NoValueValidator;
import java.lang.annotation.Annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target({java.lang.annotation.ElementType.FIELD})
public @interface DynamicParameter
{
  String[] names() default {};
  
  boolean required() default false;
  
  String description() default "";
  
  String descriptionKey() default "";
  
  boolean hidden() default false;
  
  Class<? extends IParameterValidator> validateWith() default NoValidator.class;
  
  String assignment() default "=";
  
  Class<? extends IValueValidator> validateValueWith() default NoValueValidator.class;
}

/* Location:
 * Qualified Name:     com.beust.jcommander.DynamicParameter
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IDefaultProvider
{
  public abstract String getDefaultValueFor(String paramString);
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IDefaultProvider
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IParameterValidator
{
  public abstract void validate(String paramString1, String paramString2)
    throws ParameterException;
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IParameterValidator
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IStringConverter<T>
{
  public abstract T convert(String paramString);
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IStringConverter
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IStringConverterFactory
{
  public abstract <T> Class<? extends IStringConverter<T>> getConverter(Class<T> paramClass);
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IStringConverterFactory
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IValueValidator<T>
{
  public abstract void validate(String paramString, T paramT)
    throws ParameterException;
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IValueValidator
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

public abstract interface IVariableArity
{
  public abstract int processVariableArity(String paramString, String[] paramArrayOfString);
}

/* Location:
 * Qualified Name:     com.beust.jcommander.IVariableArity
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

import java.util.Comparator;

class JCommander$1
  implements Comparator<ParameterDescription>
{
  JCommander$1(JCommander paramJCommander) {}
  
  public int compare(ParameterDescription p0, ParameterDescription p1)
  {
    return p0.getLongestName().compareTo(p1.getLongestName());
  }
}

/* Location:
 * Qualified Name:     com.beust.jcommander.JCommander.1
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

class JCommander$DefaultVariableArity
  implements IVariableArity
{
  private JCommander$DefaultVariableArity(JCommander paramJCommander) {}
  
  public int processVariableArity(String optionName, String[] options)
  {
    int i = 0;
    while ((i < options.length) && (!JCommander.access$100(this$0, options, options[i]))) {
      i++;
    }
    return i;
  }
}

/* Location:
 * Qualified Name:     com.beust.jcommander.JCommander.DefaultVariableArity
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

import java.util.Iterator;
import java.util.List;

final class JCommander$ProgramName
{
  private final String m_name;
  private final List<String> m_aliases;
  
  JCommander$ProgramName(String name, List<String> aliases)
  {
    m_name = name;
    m_aliases = aliases;
  }
  
  public String getName()
  {
    return m_name;
  }
  
  private String getDisplayName()
  {
    StringBuilder sb = new StringBuilder();
    sb.append(m_name);
    if (!m_aliases.isEmpty())
    {
      sb.append("(");
      Iterator<String> aliasesIt = m_aliases.iterator();
      while (aliasesIt.hasNext())
      {
        sb.append((String)aliasesIt.next());
        if (aliasesIt.hasNext()) {
          sb.append(",");
        }
      }
      sb.append(")");
    }
    return sb.toString();
  }
  
  public int hashCode()
  {
    int prime = 31;
    int result = 1;
    result = 31 * result + (m_name == null ? 0 : m_name.hashCode());
    return result;
  }
  
  public boolean equals(Object obj)
  {
    if (this == obj) {
      return true;
    }
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }
    ProgramName other = (ProgramName)obj;
    if (m_name == null)
    {
      if (m_name != null) {
        return false;
      }
    }
    else if (!m_name.equals(m_name)) {
      return false;
    }
    return true;
  }
  
  public String toString()
  {
    return getDisplayName();
  }
}

/* Location:
 * Qualified Name:     com.beust.jcommander.JCommander.ProgramName
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package com.beust.jcommander;

import com.beust.jcommander.converters.IParameterSplitter;
import com.beust.jcommander.converters.NoConverter;
import com.beust.jcommander.converters.StringConverter;
import com.beust.jcommander.internal.Console;
import com.beust.jcommander.internal.DefaultConsole;
import com.beust.jcommander.internal.DefaultConverterFactory;
import com.beust.jcommander.internal.JDK6Console;
import com.beust.jcommander.internal.Lists;
import com.beust.jcommander.internal.Maps;
import com.beust.jcommander.internal.Nullable;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.ResourceBundle;

public class JCommander
{
  public static final String DEBUG_PROPERTY = "jcommander.debug";
  private Map<String, ParameterDescription> m_descriptions;
  private List<Object> m_objects = Lists.newArrayList();
  private Parameterized m_mainParameter = null;
  private Object m_mainParameterObject;
  private Parameter m_mainParameterAnnotation;
  private ParameterDescription m_mainParameterDescription;
  private Map<Parameterized, ParameterDescription> m_requiredFields = Maps.newHashMap();
  private Map<Parameterized, ParameterDescription> m_fields = Maps.newHashMap();
  private ResourceBundle m_bundle;
  private IDefaultProvider m_defaultProvider;
  private Map<ProgramName, JCommander> m_commands = Maps.newLinkedHashMap();
  private Map<String, ProgramName> aliasMap = Maps.newLinkedHashMap();
  private String m_parsedCommand;
  private String m_parsedAlias;
  private ProgramName m_programName;
  private Comparator<? super ParameterDescription> m_parameterDescriptionComparator = new Comparator()
  {
    public int compare(ParameterDescription p0, ParameterDescription p1)
    {
      return p0.getLongestName().compareTo(p1.getLongestName());
    }
  };
  private int m_columnSize = 79;
  private boolean m_helpWasSpecified;
  private static Console m_console;
  private static LinkedList<IStringConverterFactory> CONVERTER_FACTORIES = ;
  
  static
  {
    CONVERTER_FACTORIES.addFirst(new DefaultConverterFactory());
  }
  
  public JCommander(Object object)
  {
    addObject(object);
    createDescriptions();
  }
  
  public JCommander(Object object, @Nullable ResourceBundle bundle)
  {
    addObject(object);
    setDescriptionsBundle(bundle);
  }
  
  public JCommander(Object object, ResourceBundle bundle, String... args)
  {
    addObject(object);
    setDescriptionsBundle(bundle);
    parse(args);
  }
  
  public JCommander(Object object, String... args)
  {
    addObject(object);
    parse(args);
  }
  
  public static Console getConsole()
  {
    if (m_console == null) {
      try
      {
        Method consoleMethod = System.class.getDeclaredMethod("console", new Class[0]);
        Object console = consoleMethod.invoke(null, new Object[0]);
        m_console = new JDK6Console(console);
      }
      catch (Throwable t)
      {
        m_console = new DefaultConsole();
      }
    }
    return m_console;
  }
  
  public final void addObject(Object object)
  {
    if ((object instanceof Iterable)) {
      for (Object o : (Iterable)object) {
        m_objects.add(o);
      }
    } else if (object.getClass().isArray()) {
      for (Object o : (Object[])object) {
        m_objects.add(o);
      }
    } else {
      m_objects.add(object);
    }
  }
  
  public final void setDescriptionsBundle(ResourceBundle bundle)
  {
    m_bundle = bundle;
  }
  
  public void parse(String... args)
  {
    parse(true, args);
  }
  
  public void parseWithoutValidation(String... args)
  {
    parse(false, args);
  }
  
  private void parse(boolean validate, String... args)
  {
    StringBuilder sb = new StringBuilder("Parsing \"");
    sb.append(join(args).append("\"\n  with:").append(join(m_objects.toArray())));
    p(sb.toString());
    if (m_descriptions == null) {
      createDescriptions();
    }
    initializeDefaultValues();
    parseValues(expandArgs(args));
    if (validate) {
      validateOptions();
    }
  }
  
  private StringBuilder join(Object[] args)
  {
    StringBuilder result = new StringBuilder();
    for (int i = 0; i < args.length; i++)
    {
      if (i > 0) {
        result.append(" ");
      }
      result.append(args[i]);
    }
    return result;
  }
  
  private void initializeDefaultValues()
  {
    if (m_defaultProvider != null)
    {
      for (ParameterDescription pd : m_descriptions.values()) {
        initializeDefaultValue(pd);
      }
      for (Map.Entry<ProgramName, JCommander> entry : m_commands.entrySet()) {
        ((JCommander)entry.getValue()).initializeDefaultValues();
      }
    }
  }
  
  private void validateOptions()
  {
    if (m_helpWasSpecified) {
      return;
    }
    if (!m_requiredFields.isEmpty())
    {
      StringBuilder missingFields = new StringBuilder();
      for (ParameterDescription pd : m_requiredFields.values()) {
        missingFields.append(pd.getNames()).append(" ");
      }
      throw new ParameterException("The following " + pluralize(m_requiredFields.size(), "option is required: ", "options are required: ") + missingFields);
    }
    if ((m_mainParameterDescription != null) && 
      (m_mainParameterDescription.getParameter().required()) && (!m_mainParameterDescription.isAssigned())) {
      throw new ParameterException("Main parameters are required (\"" + m_mainParameterDescription.getDescription() + "\")");
    }
  }
  
  private static String pluralize(int quantity, String singular, String plural)
  {
    return quantity == 1 ? singular : plural;
  }
  
  private String[] expandArgs(String[] originalArgv)
  {
    List<String> vResult1 = Lists.newArrayList();
    for (String arg : originalArgv) {
      if (arg.startsWith("@"))
      {
        String fileName = arg.substring(1);
        vResult1.addAll(readFile(fileName));
      }
      else
      {
        List<String> expanded = expandDynamicArg(arg);
        vResult1.addAll(expanded);
      }
    }
    List<String> vResult2 = Lists.newArrayList();
    for (int i = 0; i < vResult1.size(); i++)
    {
      String arg = (String)vResult1.get(i);
      String[] v1 = (String[])vResult1.toArray(new String[0]);
      if (isOption(v1, arg))
      {
        String sep = getSeparatorFor(v1, arg);
        if (!" ".equals(sep))
        {
          String[] sp = arg.split("[" + sep + "]", 2);
          for (String ssp : sp) {
            vResult2.add(ssp);
          }
        }
        else
        {
          vResult2.add(arg);
        }
      }
      else
      {
        vResult2.add(arg);
      }
    }
    return (String[])vResult2.toArray(new String[vResult2.size()]);
  }
  
  private List<String> expandDynamicArg(String arg)
  {
    for (ParameterDescription pd : m_descriptions.values()) {
      if (pd.isDynamicParameter()) {
        for (String name : pd.getParameter().names()) {
          if ((arg.startsWith(name)) && (!arg.equals(name))) {
            return Arrays.asList(new String[] { name, arg.substring(name.length()) });
          }
        }
      }
    }
    return Arrays.asList(new String[] { arg });
  }
  
  private boolean isOption(String[] args, String arg)
  {
    String prefixes = getOptionPrefixes(args, arg);
    return (arg.length() > 0) && (prefixes.indexOf(arg.charAt(0)) >= 0);
  }
  
  private ParameterDescription getPrefixDescriptionFor(String arg)
  {
    for (Map.Entry<String, ParameterDescription> es : m_descriptions.entrySet()) {
      if (arg.startsWith((String)es.getKey())) {
        return (ParameterDescription)es.getValue();
      }
    }
    return null;
  }
  
  private ParameterDescription getDescriptionFor(String[] args, String arg)
  {
    ParameterDescription result = getPrefixDescriptionFor(arg);
    if (result != null) {
      return result;
    }
    for (String a : args)
    {
      ParameterDescription pd = getPrefixDescriptionFor(arg);
      if (pd != null) {
        result = pd;
      }
      if (a.equals(arg)) {
        return result;
      }
    }
    throw new ParameterException("Unknown parameter: " + arg);
  }
  
  private String getSeparatorFor(String[] args, String arg)
  {
    ParameterDescription pd = getDescriptionFor(args, arg);
    if (pd != null)
    {
      Parameters p = (Parameters)pd.getObject().getClass().getAnnotation(Parameters.class);
      if (p != null) {
        return p.separators();
      }
    }
    return " ";
  }
  
  private String getOptionPrefixes(String[] args, String arg)
  {
    ParameterDescription pd = getDescriptionFor(args, arg);
    if (pd != null)
    {
      Parameters p = (Parameters)pd.getObject().getClass().getAnnotation(Parameters.class);
      if (p != null) {
        return p.optionPrefixes();
      }
    }
    String result = "-";
    
    StringBuilder sb = new StringBuilder();
    for (Object o : m_objects)
    {
      Parameters p = (Parameters)o.getClass().getAnnotation(Parameters.class);
      if ((p != null) && (!"-".equals(p.optionPrefixes()))) {
        sb.append(p.optionPrefixes());
      }
    }
    if (!Strings.isStringEmpty(sb.toString())) {
      result = sb.toString();
    }
    return result;
  }
  
  private static List<String> readFile(String fileName)
  {
    List<String> result = Lists.newArrayList();
    try
    {
      BufferedReader bufRead = new BufferedReader(new FileReader(fileName));
      String line;
      while ((line = bufRead.readLine()) != null) {
        if (line.length() > 0) {
          result.add(line);
        }
      }
      bufRead.close();
    }
    catch (IOException e)
    {
      throw new ParameterException("Could not read file " + fileName + ": " + e);
    }
    return result;
  }
  
  private static String trim(String string)
  {
    String result = string.trim();
    if ((result.startsWith("\"")) && (result.endsWith("\"")) && (result.length() > 1)) {
      result = result.substring(1, result.length() - 1);
    }
    return result;
  }
  
  private void createDescriptions()
  {
    m_descriptions = Maps.newHashMap();
    for (Object object : m_objects) {
      addDescription(object);
    }
  }
  
  private void addDescription(Object object)
  {
    Class<?> cls = object.getClass();
    
    List<Parameterized> parameterizeds = Parameterized.parseArg(object);
    for (Parameterized parameterized : parameterizeds)
    {
      WrappedParameter wp = parameterized.getWrappedParameter();
      if ((wp != null) && (wp.getParameter() != null))
      {
        Parameter annotation = wp.getParameter();
        
        Parameter p = annotation;
        if (p.names().length == 0)
        {
          p("Found main parameter:" + parameterized);
          if (m_mainParameter != null) {
            throw new ParameterException("Only one @Parameter with no names attribute is allowed, found:" + m_mainParameter + " and " + parameterized);
          }
          m_mainParameter = parameterized;
          m_mainParameterObject = object;
          m_mainParameterAnnotation = p;
          m_mainParameterDescription = new ParameterDescription(object, p, parameterized, m_bundle, this);
        }
        else
        {
          for (String name : p.names())
          {
            if (m_descriptions.containsKey(name)) {
              throw new ParameterException("Found the option " + name + " multiple times");
            }
            p("Adding description for " + name);
            ParameterDescription pd = new ParameterDescription(object, p, parameterized, m_bundle, this);
            
            m_fields.put(parameterized, pd);
            m_descriptions.put(name, pd);
            if (p.required()) {
              m_requiredFields.put(parameterized, pd);
            }
          }
        }
      }
      else if (parameterized.getDelegateAnnotation() != null)
      {
        Object delegateObject = parameterized.get(object);
        if (delegateObject == null) {
          throw new ParameterException("Delegate field '" + parameterized.getName() + "' cannot be null.");
        }
        addDescription(delegateObject);
      }
      else if ((wp != null) && (wp.getDynamicParameter() != null))
      {
        DynamicParameter dp = wp.getDynamicParameter();
        for (String name : dp.names())
        {
          if (m_descriptions.containsKey(name)) {
            throw new ParameterException("Found the option " + name + " multiple times");
          }
          p("Adding description for " + name);
          ParameterDescription pd = new ParameterDescription(object, dp, parameterized, m_bundle, this);
          
          m_fields.put(parameterized, pd);
          m_descriptions.put(name, pd);
          if (dp.required()) {
            m_requiredFields.put(parameterized, pd);
          }
        }
      }
    }
  }
  
  private void initializeDefaultValue(ParameterDescription pd)
  {
    for (String optionName : pd.getParameter().names())
    {
      String def = m_defaultProvider.getDefaultValueFor(optionName);
      if (def != null)
      {
        p("Initializing " + optionName + " with default value:" + def);
        pd.addValue(def, true);
        return;
      }
    }
  }
  
  private void parseValues(String[] args)
  {
    boolean commandParsed = false;
    int i = 0;
    while ((i < args.length) && (!commandParsed))
    {
      String arg = args[i];
      String a = trim(arg);
      p("Parsing arg: " + a);
      
      JCommander jc = findCommandByAlias(arg);
      int increment = 1;
      if ((isOption(args, a)) && (jc == null))
      {
        ParameterDescription pd = (ParameterDescription)m_descriptions.get(a);
        if (pd != null)
        {
          if (pd.getParameter().password())
          {
            char[] password = readPassword(pd.getDescription(), pd.getParameter().echoInput());
            pd.addValue(new String(password));
            m_requiredFields.remove(pd.getParameterized());
          }
          else if (pd.getParameter().variableArity())
          {
            increment = processVariableArity(args, i, pd);
          }
          else
          {
            Class<?> fieldType = pd.getParameterized().getType();
            if (((fieldType == Boolean.TYPE) || (fieldType == Boolean.class)) && (pd.getParameter().arity() == -1))
            {
              pd.addValue("true");
              m_requiredFields.remove(pd.getParameterized());
            }
            else
            {
              increment = processFixedArity(args, i, pd, fieldType);
            }
            if (pd.isHelp()) {
              m_helpWasSpecified = true;
            }
          }
        }
        else {
          throw new ParameterException("Unknown option: " + arg);
        }
      }
      else if (!Strings.isStringEmpty(arg))
      {
        if (m_commands.isEmpty())
        {
          List mp = getMainParameter(arg);
          String value = arg;
          Object convertedValue = value;
          if ((m_mainParameter.getGenericType() instanceof ParameterizedType))
          {
            ParameterizedType p = (ParameterizedType)m_mainParameter.getGenericType();
            Type cls = p.getActualTypeArguments()[0];
            if ((cls instanceof Class)) {
              convertedValue = convertValue(m_mainParameter, (Class)cls, value);
            }
          }
          ParameterDescription.validateParameter(m_mainParameterAnnotation.validateWith(), "Default", value);
          
          m_mainParameterDescription.setAssigned(true);
          mp.add(convertedValue);
        }
        else
        {
          if (jc == null) {
            throw new MissingCommandException("Expected a command, got " + arg);
          }
          m_parsedCommand = m_programName.m_name;
          m_parsedAlias = arg;
          
          jc.parse(subArray(args, i + 1));
          commandParsed = true;
        }
      }
      i += increment;
    }
    for (ParameterDescription parameterDescription : m_descriptions.values()) {
      if (parameterDescription.isAssigned()) {
        ((ParameterDescription)m_fields.get(parameterDescription.getParameterized())).setAssigned(true);
      }
    }
  }
  
  private class DefaultVariableArity
    implements IVariableArity
  {
    private DefaultVariableArity() {}
    
    public int processVariableArity(String optionName, String[] options)
    {
      int i = 0;
      while ((i < options.length) && (!JCommander.this.isOption(options, options[i]))) {
        i++;
      }
      return i;
    }
  }
  
  private final IVariableArity DEFAULT_VARIABLE_ARITY = new DefaultVariableArity(null);
  private int m_verbose = 0;
  
  private int processVariableArity(String[] args, int index, ParameterDescription pd)
  {
    Object arg = pd.getObject();
    IVariableArity va;
    IVariableArity va;
    if (!(arg instanceof IVariableArity)) {
      va = DEFAULT_VARIABLE_ARITY;
    } else {
      va = (IVariableArity)arg;
    }
    List<String> currentArgs = Lists.newArrayList();
    for (int j = index + 1; j < args.length; j++) {
      currentArgs.add(args[j]);
    }
    int arity = va.processVariableArity(pd.getParameter().names()[0], (String[])currentArgs.toArray(new String[0]));
    
    int result = processFixedArity(args, index, pd, List.class, arity);
    return result;
  }
  
  private int processFixedArity(String[] args, int index, ParameterDescription pd, Class<?> fieldType)
  {
    int arity = pd.getParameter().arity();
    int n = arity != -1 ? arity : 1;
    
    return processFixedArity(args, index, pd, fieldType, n);
  }
  
  private int processFixedArity(String[] args, int originalIndex, ParameterDescription pd, Class<?> fieldType, int arity)
  {
    int index = originalIndex;
    String arg = args[index];
    if ((arity == 0) && ((Boolean.class.isAssignableFrom(fieldType)) || (Boolean.TYPE.isAssignableFrom(fieldType))))
    {
      pd.addValue("true");
      m_requiredFields.remove(pd.getParameterized());
    }
    else if (index < args.length - 1)
    {
      int offset = "--".equals(args[(index + 1)]) ? 1 : 0;
      if (index + arity < args.length)
      {
        for (int j = 1; j <= arity; j++)
        {
          pd.addValue(trim(args[(index + j + offset)]));
          m_requiredFields.remove(pd.getParameterized());
        }
        index += arity + offset;
      }
      else
      {
        throw new ParameterException("Expected " + arity + " values after " + arg);
      }
    }
    else
    {
      throw new ParameterException("Expected a value after parameter " + arg);
    }
    return arity + 1;
  }
  
  private char[] readPassword(String description, boolean echoInput)
  {
    getConsole().print(description + ": ");
    return getConsole().readPassword(echoInput);
  }
  
  private String[] subArray(String[] args, int index)
  {
    int l = args.length - index;
    String[] result = new String[l];
    System.arraycopy(args, index, result, 0, l);
    
    return result;
  }
  
  private List<?> getMainParameter(String arg)
  {
    if (m_mainParameter == null) {
      throw new ParameterException("Was passed main parameter '" + arg + "' but no main parameter was defined");
    }
    List<?> result = (List)m_mainParameter.get(m_mainParameterObject);
    if (result == null)
    {
      result = Lists.newArrayList();
      if (!List.class.isAssignableFrom(m_mainParameter.getType())) {
        throw new ParameterException("Main parameter field " + m_mainParameter + " needs to be of type List, not " + m_mainParameter.getType());
      }
      m_mainParameter.set(m_mainParameterObject, result);
    }
    return result;
  }
  
  public String getMainParameterDescription()
  {
    if (m_descriptions == null) {
      createDescriptions();
    }
    return m_mainParameterAnnotation != null ? m_mainParameterAnnotation.description() : null;
  }
  
  public void setProgramName(String name)
  {
    setProgramName(name, new String[0]);
  }
  
  public void setProgramName(String name, String... aliases)
  {
    m_programName = new ProgramName(name, Arrays.asList(aliases));
  }
  
  public void usage(String commandName)
  {
    StringBuilder sb = new StringBuilder();
    usage(commandName, sb);
    getConsole().println(sb.toString());
  }
  
  public void usage(String commandName, StringBuilder out)
  {
    usage(commandName, out, "");
  }
  
  public void usage(String commandName, StringBuilder out, String indent)
  {
    String description = getCommandDescription(commandName);
    JCommander jc = findCommandByAlias(commandName);
    if (description != null)
    {
      out.append(indent).append(description);
      out.append("\n");
    }
    jc.usage(out, indent);
  }
  
  public String getCommandDescription(String commandName)
  {
    JCommander jc = findCommandByAlias(commandName);
    if (jc == null) {
      throw new ParameterException("Asking description for unknown command: " + commandName);
    }
    Object arg = jc.getObjects().get(0);
    Parameters p = (Parameters)arg.getClass().getAnnotation(Parameters.class);
    ResourceBundle bundle = null;
    String result = null;
    if (p != null)
    {
      result = p.commandDescription();
      String bundleName = p.resourceBundle();
      if (!"".equals(bundleName)) {
        bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault());
      } else {
        bundle = m_bundle;
      }
      if (bundle != null) {
        result = getI18nString(bundle, p.commandDescriptionKey(), p.commandDescription());
      }
    }
    return result;
  }
  
  private String getI18nString(ResourceBundle bundle, String key, String def)
  {
    String s = bundle != null ? bundle.getString(key) : null;
    return s != null ? s : def;
  }
  
  public void usage()
  {
    StringBuilder sb = new StringBuilder();
    usage(sb);
    getConsole().println(sb.toString());
  }
  
  public void usage(StringBuilder out)
  {
    usage(out, "");
  }
  
  public void usage(StringBuilder out, String indent)
  {
    if (m_descriptions == null) {
      createDescriptions();
    }
    boolean hasCommands = !m_commands.isEmpty();
    
    String programName = m_programName != null ? m_programName.getDisplayName() : "<main class>";
    out.append(indent).append("Usage: " + programName + " [options]");
    if (hasCommands) {
      out.append(indent).append(" [command] [command options]");
    }
    if (m_mainParameterDescription != null) {
      out.append(" " + m_mainParameterDescription.getDescription());
    }
    int longestName = 0;
    List<ParameterDescription> sorted = Lists.newArrayList();
    for (ParameterDescription pd : m_fields.values()) {
      if (!pd.getParameter().hidden())
      {
        sorted.add(pd);
        
        int length = pd.getNames().length() + 2;
        if (length > longestName) {
          longestName = length;
        }
      }
    }
    Collections.sort(sorted, getParameterDescriptionComparator());
    if (sorted.size() > 0) {
      out.append(indent).append("\n").append(indent).append("  Options:\n");
    }
    for (ParameterDescription pd : sorted)
    {
      int l = pd.getNames().length();
      int spaceCount = longestName - l;
      int start = out.length();
      WrappedParameter parameter = pd.getParameter();
      out.append(indent).append("  " + (parameter.required() ? "* " : "  ") + pd.getNames() + s(spaceCount));
      
      int indentCount = out.length() - start;
      wrapDescription(out, indentCount, pd.getDescription());
      Object def = pd.getDefault();
      if (pd.isDynamicParame