Handles the following tokens:
<pre>
--L
-L
--l
-l
</pre>

@param token the command line token to handle
@throws OptionParserException if option parsing fails
171547
private void handleLongOptionWithoutEqual(String token) throws OptionParserException {
        List<String> matchingOpts = getMatchingLongOptions(token);
        if (matchingOpts.isEmpty()) {
            handleUnknownToken(currentToken);
        } else if (matchingOpts.size() > 1 && !options.hasLongOption(token)) {
            throw new AmbiguousOptionException(token, matchingOpts);
        } else {
            String key = (options.hasLongOption(token) ? token : matchingOpts.get(0));
            handleOption(options.getOption(key));
        }
    }
1235589
private void initializeCommonOptions(OptionParser parser) {
    helpOpt = parser.acceptsAll(Arrays.asList("help", "h"), "Print this help message.");

    randomSeed = parser.accepts("randomSeed", "Seed to use for generating random numbers. "
        + "Program execution may still be nondeterministic, if multithreading is used.").
        withRequiredArg().ofType(Long.class).defaultsTo(0L);
    
    noPrintOptions = parser.accepts("noPrintOptions", "Don't print out the command-line options "
        + "passed in to this program or final runtime statistics.");

    if (opts.contains(CommonOptions.STOCHASTIC_GRADIENT)) {
      sgdIterations = parser.accepts("iterations",
          "Number of iterations (passes over the data) for stochastic gradient descent.").
          withRequiredArg().ofType(Long.class).defaultsTo(10L);
      sgdBatchSize = parser.accepts("batchSize",
          "Minibatch size, i.e., the number of examples processed per gradient computation. If unspecified, defaults to using the entire data set (gradient descent).")
          .withRequiredArg().ofType(Integer.class);
      sgdInitialStep = parser.accepts("initialStepSize",
          "Initial step size for stochastic gradient descent.")
          .withRequiredArg().ofType(Double.class).defaultsTo(1.0);
      sgdNoDecayStepSize = parser.accepts("noDecayStepSize",
          "Don't use a 1/sqrt(t) step size decay during stochastic gradient descent.");
      sgdNoReturnAveragedParameters = parser.accepts("noReturnAveragedParameters", 
          "Get the average of the parameter iterates of stochastic gradient descent.");
      sgdL2Regularization = parser.accepts("l2Regularization",
          "Regularization parameter for the L2 norm of the parameter vector.")
          .withRequiredArg().ofType(Double.class).defaultsTo(0.0);
      sgdRegularizationFrequency = parser.accepts("regularizationFrequency",
          "Fraction of iterations on which to apply regularization. Must be between 0 and 1")
          .withRequiredArg().ofType(Double.class).defaultsTo(1.0);
      sgdClipGradients = parser.accepts("clipGradients", "Clip gradients to a max l2 norm of the given value.")
          .withRequiredArg().ofType(Double.class).defaultsTo(Double.MAX_VALUE);
      sgdAdagrad = parser.accepts("adagrad", "Use the adagrad algorithm for stochastic gradient descent.");
    }

    if (opts.contains(CommonOptions.LBFGS)) {
      lbfgs = parser.accepts("lbfgs");
      lbfgsIterations = parser.accepts("lbfgsIterations",
          "Maximum number of iterations (passes over the data) for LBFGS.").
          withRequiredArg().ofType(Integer.class).defaultsTo(100);
      lbfgsHessianRank = parser.accepts("lbfgsHessianRank",
          "Rank (number of vectors) of LBFGS's inverse Hessian approximation.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(30);
      lbfgsL2Regularization = parser.accepts("lbfgsL2Regularization",
          "L2 regularization imposed by LBFGS")
          .withRequiredArg().ofType(Double.class).defaultsTo(0.0);

      // Providing either of these options triggers the use of minibatch LBFGS
      lbfgsMinibatchIterations = parser.accepts("lbfgsMinibatchIterations",
          "If specified, run LBFGS on minibatches of the data with the specified number of iterations per minibatch.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(-1);
      lbfgsMinibatchSize = parser.accepts("lbfgsMinibatchSize",
          "If specified, run LBFGS on minibatches of the data with the specified number of examples per minibatch.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(-1);

      lbfgsAdaptiveMinibatches = parser.accepts("lbfgsAdaptiveMinibatches",
          "If given, LBFGS is run on minibatches of exponentially increasing size.");
    }

    if (opts.contains(CommonOptions.STOCHASTIC_GRADIENT) || opts.contains(CommonOptions.LBFGS)) {
      logInterval = parser.accepts("logInterval",
          "Number of training iterations between logging outputs.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(1);
      
      logParametersInterval = parser.accepts("logParametersInterval",
          "Number of training iterations between serializing parameters to disk during training. "
          + "If unspecified, model parameters are not serialized to disk during training.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(-1);
      logParametersDir = parser.accepts("logParametersDir", "Directory where serialized model "
          + "parameters are stored. Must be specified if logParametersInterval is specified.")
          .withRequiredArg().ofType(String.class);

      logBrief = parser.accepts("logBrief", "Hides training output.");
    }

    if (opts.contains(CommonOptions.MAP_REDUCE)) {
      mrMaxThreads = parser.accepts("maxThreads",
          "Maximum number of threads to use during parallel execution.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(Runtime.getRuntime().availableProcessors());
      mrMaxBatchesPerThread = parser.accepts("maxBatchesPerThread",
          "Number of batches of items to create per thread.")
          .withRequiredArg().ofType(Integer.class).defaultsTo(20);
    }

    if (opts.contains(CommonOptions.FUNCTIONAL_GRADIENT_ASCENT)) {
      fgaIterations = parser.accepts("fgaIterations",
          "Number of iterations of functional gradient ascent to perform.").withRequiredArg()
          .ofType(Integer.class).defaultsTo(10);
      fgaBatchSize = parser.accepts("fgaBatchSize",
          "Number of examples to process before each functional gradient update. If not provided, use the entire data set.")
          .withRequiredArg().ofType(Integer.class);
      fgaInitialStep = parser.accepts("fgaInitialStepSize",
          "Initial step size for functional gradient ascent.")
          .withRequiredArg().ofType(Double.class).defaultsTo(1.0);
      fgaNoDecayStepSize = parser.accepts("fgaNoDecayStepSize",
          "Don't use a 1/sqrt(t) step size decay during functional gradient ascent.");
    }

    if (opts.contains(CommonOptions.REGRESSION_TREE)) {
      rtreeMaxDepth = parser.accepts("rtreeMaxDepth", "Maximum depth of trained regression trees")
          .withRequiredArg().ofType(Integer.class).required();
    }
  }
837066
private void handleToken(String token) throws ParseException
    {
        currentToken = token;

        if (skipParsing)
        {
            cmd.addArg(token);
        }
        else if ("--".equals(token))
        {
            skipParsing = true;
        }
        else if (currentOption != null && currentOption.acceptsArg() && isArgument(token))
        {
            currentOption.addValueForProcessing(Util.stripLeadingAndTrailingQuotes(token));
        }
        else if (token.startsWith("--"))
        {
            handleLongOption(token);
        }
        else if (token.startsWith("-") && !"-".equals(token))
        {
            handleShortAndLongOption(token);
        }
        else
        {
            handleUnknownToken(token);
        }

        if (currentOption != null && !currentOption.acceptsArg())
        {
            currentOption = null;
        }
    }
690373
public void parseArgsNoExit(String[] args) throws ParseException {
        // Parse command line.
        CommandLine cmd = null;
        CommandLineParser parser = new PosixParser();
        cmd = parser.parse(options, args);

        // Special handling of --flagfile.
        if (cmd.hasOption(flagfileOpt.getLongOpt())) {
            String value = cmd.getOptionValue(flagfileOpt.getLongOpt());
            String[] ffArgs = readFlagFile(value);
            parseArgs(ffArgs);
        }
        
        // Process each flag mapped to a field.
        fieldValueMap = new HashMap<>();
        try {
            for (Option apacheOpt : optionFieldMap.keySet()) {
                Field field = optionFieldMap.get(apacheOpt);
                if (cmd.hasOption(apacheOpt.getLongOpt())) {
                    String value = apacheOpt.hasArg() ? cmd.getOptionValue(apacheOpt.getLongOpt()) : "true";
                    if (Modifier.isStatic(field.getModifiers())) {
                        // For static fields, set the value directly to the field.
                        setStaticField(field, value);
                    } else {
                        // For non-static fields, cache the value for later use by getInstanceFromParsedArgs(). 
                        fieldValueMap.put(field, value);
                    }
                }
            }
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
321547
@Override
    protected boolean areNextTokensCreateTableOptions( final DdlTokenStream tokens ) throws ParsingException {
        // current token can't be a terminator or the next n-tokens can't be a statement
        return (tokens.hasNext() && !isTerminator(tokens) && (tokens.computeNextStatementStartKeywordCount() == 0));
    }
258630
public boolean skip(ParserToken token) {
      if (token == null) {
         return false;
      }
      if (isPrefix(token)) {
         if (prefixHandlers.containsKey(token.getType())) {
            return prefixHandlers.get(token.getType()) instanceof PrefixSkipHandler;
         } else {
            return prefixSkipHandler != null;
         }
      }
      return false;
   }
1231816
public final void mOPTION() throws RecognitionException {
        try {
            int _type = OPTION;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // com/dyuproject/protostuff/parser/ProtoLexer.g:107:5: ( 'option' )
            // com/dyuproject/protostuff/parser/ProtoLexer.g:107:9: 'option'
            {
            match("option"); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
378113
final public void Choice() throws ParseException {
    Or();
    label_6:
    while (true) {
      if (jj_2_5(3)) {
        ;
      } else {
        break label_6;
      }
      jj_consume_token(QUESTIONMARK);
      Choice();
      jj_consume_token(COLON);
                                                         AstChoice jjtn001 = new AstChoice(JJTCHOICE);
                                                         boolean jjtc001 = true;
                                                         jjtree.openNodeScope(jjtn001);
      try {
        Choice();
      } catch (Throwable jjte001) {
                                                         if (jjtc001) {
                                                           jjtree.clearNodeScope(jjtn001);
                                                           jjtc001 = false;
                                                         } else {
                                                           jjtree.popNode();
                                                         }
                                                         if (jjte001 instanceof RuntimeException) {
                                                           {if (true) throw (RuntimeException)jjte001;}
                                                         }
                                                         if (jjte001 instanceof ParseException) {
                                                           {if (true) throw (ParseException)jjte001;}
                                                         }
                                                         {if (true) throw (Error)jjte001;}
      } finally {
                                                         if (jjtc001) {
                                                           jjtree.closeNodeScope(jjtn001,  3);
                                                         }
      }
    }
  }
550651
private void handleLongOption(String token) throws ParseException
    {
        if (token.indexOf('=') == -1)
        {
            handleLongOptionWithoutEqual(token);
        }
        else
        {
            handleLongOptionWithEqual(token);
        }
    }
612338
public static void acceptsNodeMultiple(OptionParser parser) {
        parser.acceptsAll(Arrays.asList(OPT_N, OPT_NODE), "node id list")
              .withRequiredArg()
              .describedAs("node-id-list")
              .withValuesSeparatedBy(',')
              .ofType(Integer.class);
    }
1304158
public static CommandLine parse(Options options, String... args) throws Exception {
        return CommandLineParser.parse(options, args);
    }
516898
private boolean isLongOption(String token)
    {
        if (!token.startsWith("-") || token.length() == 1)
        {
            return false;
        }

        int pos = token.indexOf("=");
        String t = pos == -1 ? token : token.substring(0, pos);

        if (!options.getMatchingOptions(t).isEmpty())
        {
            // long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
            return true;
        }
        else if (getLongPrefix(token) != null && !token.startsWith("--"))
        {
            // -LV
            return true;
        }

        return false;
    }
989747
void parseOption(String option) {
    if (option.isEmpty()) {
      return;
    }

    @SuppressWarnings("StringSplitter")
    String[] keyAndValue = option.split(SPLIT_KEY_VALUE);
    requireArgument(keyAndValue.length <= 2,
        "key-value pair %s with more than one equals sign", option);

    String key = keyAndValue[0].trim();
    String value = (keyAndValue.length == 1) ? null : keyAndValue[1].trim();

    configure(key, value);
  }
458115
public final void ruleAbstractToken() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXtext.g:433:2: ( ( ( rule__AbstractToken__Alternatives ) ) )
            // InternalXtext.g:434:2: ( ( rule__AbstractToken__Alternatives ) )
            {
            // InternalXtext.g:434:2: ( ( rule__AbstractToken__Alternatives ) )
            // InternalXtext.g:435:3: ( rule__AbstractToken__Alternatives )
            {
             before(grammarAccess.getAbstractTokenAccess().getAlternatives()); 
            // InternalXtext.g:436:3: ( rule__AbstractToken__Alternatives )
            // InternalXtext.g:436:4: rule__AbstractToken__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AbstractToken__Alternatives();

            state._fsp--;


            }

             after(grammarAccess.getAbstractTokenAccess().getAlternatives()); 

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
634918
public void parseString(String xml) throws ParserException {

        try {
            nanoElement.parseString(xml);
        } catch (XMLParseException e) {
            throw new ParserException(e.getMessage());
        }
    }
787085
public void substitute( String token, int value )
    {
        String valueStr = Integer.toString( value );
        _tokenValuesMap.put( token, valueStr );
    }
451547
public static void acceptsFile(OptionParser parser) {
        parser.acceptsAll(Arrays.asList(OPT_F, OPT_FILE), "file path for input/output")
              .withRequiredArg()
              .describedAs("file-path")
              .ofType(String.class);
    }