    001/*
    002  Licensed to the Apache Software Foundation (ASF) under one or more
    003  contributor license agreements.  See the NOTICE file distributed with
    004  this work for additional information regarding copyright ownership.
    005  The ASF licenses this file to You under the Apache License, Version 2.0
    006  (the "License"); you may not use this file except in compliance with
    007  the License.  You may obtain a copy of the License at
    008
    009      https://www.apache.org/licenses/LICENSE-2.0
    010
    011  Unless required by applicable law or agreed to in writing, software
    012  distributed under the License is distributed on an "AS IS" BASIS,
    013  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    014  See the License for the specific language governing permissions and
    015  limitations under the License.
    016 */
    017
    018package org.apache.commons.cli;
    019
    020import java.util.ArrayList;
    021import java.util.Enumeration;
    022import java.util.List;
    023import java.util.Objects;
    024import java.util.Properties;
    025import java.util.function.Consumer;
    026import java.util.function.Supplier;
    027
    028/**
    029 * Default parser.
    030 *
    031 * @since 1.3
    032 */
    033public class DefaultParser implements CommandLineParser {
    034
    035    /**
    036     * A nested builder class to create {@code DefaultParser} instances
    037     * using descriptive methods.
    038     *
    039     * Example usage:
    040     * <pre>
    041     * DefaultParser parser = Option.builder()
    042     *     .setAllowPartialMatching(false)
    043     *     .setStripLeadingAndTrailingQuotes(false)
    044     *     .build();
    045     * </pre>
    046     *
    047     * @since 1.5.0
    048     */
    049    public static final class Builder implements Supplier<DefaultParser> {
    050
    051        /** Flag indicating if partial matching of long options is supported. */
    052        private boolean allowPartialMatching = true;
    053
    054        /**
    055         * The deprecated option handler.
    056         * <p>
    057         * If you want to serialize this field, use a serialization proxy.
    058         * </p>
    059         */
    060        private Consumer<Option> deprecatedHandler = CommandLine.Builder.DEPRECATED_HANDLER;
    061
    062        /** Flag indicating if balanced leading and trailing double quotes should be stripped from option arguments. */
    063        private Boolean stripLeadingAndTrailingQuotes;
    064
    065        /**
    066         * Constructs a new {@code Builder} for a {@code DefaultParser} instance.
    067         *
    068         * Both allowPartialMatching and stripLeadingAndTrailingQuotes are true by default,
    069         * mimicking the argument-less constructor.
    070         */
    071        private Builder() {
    072        }
    073
    074        /**
    075         * Builds an DefaultParser with the values declared by this {@link Builder}.
    076         *
    077         * @return the new {@link DefaultParser}.
    078         * @since 1.5.0
    079         * @deprecated Use {@link #get()}.
    080         */
    081        @Deprecated
    082        public DefaultParser build() {
    083            return get();
    084        }
    085
    086        /**
    087         * Builds an DefaultParser with the values declared by this {@link Builder}.
    088         *
    089         * @return the new {@link DefaultParser}.
    090         * @since 1.10.0
    091         */
    092        @Override
    093        public DefaultParser get() {
    094            return new DefaultParser(allowPartialMatching, stripLeadingAndTrailingQuotes, deprecatedHandler);
    095        }
    096
    097        /**
    098         * Sets if partial matching of long options is supported.
    099         *
    100         * By "partial matching" we mean that given the following code:
    101         *
    102         * <pre>
    103         * {
    104         *     &#64;code
    105         *     final Options options = new Options();
    106         *     options.addOption(new Option("d", "debug", false, "Turn on debug."));
    107         *     options.addOption(new Option("e", "extract", false, "Turn on extract."));
    108         *     options.addOption(new Option("o", "option", true, "Turn on option with argument."));
    109         * }
    110         * </pre>
    111         *
    112         * If "partial matching" is turned on, {@code -de} only matches the {@code "debug"} option. However, with
    113         * "partial matching" disabled, {@code -de} would enable both {@code debug} as well as {@code extract}
    114         *
    115         * @param allowPartialMatching whether to allow partial matching of long options.
    116         * @return {@code this} instance..
    117         * @since 1.5.0
    118         */
    119        public Builder setAllowPartialMatching(final boolean allowPartialMatching) {
    120            this.allowPartialMatching = allowPartialMatching;
    121            return this;
    122        }
    123
    124        /**
    125         * Sets the deprecated option handler.
    126         *
    127         * @param deprecatedHandler the deprecated option handler.
    128         * @return {@code this} instance.
    129         * @since 1.7.0
    130         */
    131        public Builder setDeprecatedHandler(final Consumer<Option> deprecatedHandler) {
    132            this.deprecatedHandler = deprecatedHandler;
    133            return this;
    134        }
    135
    136        /**
    137         * Sets if balanced leading and trailing double quotes should be stripped from option arguments.
    138         *
    139         * If "stripping of balanced leading and trailing double quotes from option arguments" is true,
    140         * the outermost balanced double quotes of option arguments values will be removed.
    141         * For example, {@code -o '"x"'} getValue() will return {@code x}, instead of {@code "x"}
    142         *
    143         * If "stripping of balanced leading and trailing double quotes from option arguments" is null,
    144         * then quotes will be stripped from option values separated by space from the option, but
    145         * kept in other cases, which is the historic behavior.
    146         *
    147         * @param stripLeadingAndTrailingQuotes whether balanced leading and trailing double quotes should be stripped from option arguments.
    148         * @return {@code this} instance.
    149         * @since 1.5.0
    150         */
    151        public Builder setStripLeadingAndTrailingQuotes(final Boolean stripLeadingAndTrailingQuotes) {
    152            this.stripLeadingAndTrailingQuotes = stripLeadingAndTrailingQuotes;
    153            return this;
    154        }
    155    }
    156
    157    /**
    158     * Enum representing possible actions that may be done when "non option" is discovered during parsing.
    159     *
    160     * @since 1.10.0
    161     */
    162    public enum NonOptionAction {
    163        /**
    164         * Parsing continues and current token is ignored.
    165         */
    166        IGNORE,
    167        /**
    168         * Parsing continues and current token is added to command line arguments.
    169         */
    170        SKIP,
    171        /**
    172         * Parsing will stop and remaining tokens are added to command line arguments.
    173         * Equivalent of {@code stopAtNonOption = true}.
    174         */
    175        STOP,
    176        /**
    177         * Parsing will abort and exception is thrown.
    178         * Equivalent of {@code stopAtNonOption = false}.
    179         */
    180        THROW;
    181    }
    182
    183    /**
    184     * Creates a new {@link Builder} to create an {@link DefaultParser} using descriptive
    185     * methods.
    186     *
    187     * @return a new {@link Builder} instance
    188     * @since 1.5.0
    189     */
    190    public static Builder builder() {
    191        return new Builder();
    192    }
    193
    194    static int indexOfEqual(final String token) {
    195        return token.indexOf(Char.EQUAL);
    196    }
    197
    198    /** The command-line instance. */
    199    protected CommandLine cmd;
    200
    201    /** The current options. */
    202    protected Options options;
    203
    204    /**
    205     * Flag indicating how unrecognized tokens are handled. {@code true} to stop the parsing and add the remaining
    206     * tokens to the args list. {@code false} to throw an exception.
    207     *
    208     * @deprecated Use {@link #nonOptionAction} instead. This field is unused, and left for binary compatibility reasons.
    209     */
    210    @Deprecated
    211    protected boolean stopAtNonOption;
    212
    213    /**
    214     * Action to happen when "non option" token is discovered.
    215     *
    216     * @since 1.10.0
    217     */
    218    protected NonOptionAction nonOptionAction;
    219
    220    /** The token currently processed. */
    221    protected String currentToken;
    222
    223    /** The last option parsed. */
    224    protected Option currentOption;
    225
    226    /** Flag indicating if tokens should no longer be analyzed and simply added as arguments of the command line. */
    227    protected boolean skipParsing;
    228
    229    /** The required options and groups expected to be found when parsing the command line. */
    230    // This can contain either a String (addOption) or an OptionGroup (addOptionGroup)
    231    // TODO this seems wrong
    232    protected List expectedOpts;
    233
    234    /** Flag indicating if partial matching of long options is supported. */
    235    private final boolean allowPartialMatching;
    236
    237    /** Flag indicating if balanced leading and trailing double quotes should be stripped from option arguments.
    238     * null represents the historic arbitrary behavior */
    239    private final Boolean stripLeadingAndTrailingQuotes;
    240
    241    /**
    242     * The deprecated option handler.
    243     * <p>
    244     * If you want to serialize this field, use a serialization proxy.
    245     * </p>
    246     */
    247    private final Consumer<Option> deprecatedHandler;
    248
    249    /**
    250     * Creates a new DefaultParser instance with partial matching enabled.
    251     *
    252     * By "partial matching" we mean that given the following code:
    253     *
    254     * <pre>
    255     * {
    256     *     &#64;code
    257     *     final Options options = new Options();
    258     *     options.addOption(new Option("d", "debug", false, "Turn on debug."));
    259     *     options.addOption(new Option("e", "extract", false, "Turn on extract."));
    260     *     options.addOption(new Option("o", "option", true, "Turn on option with argument."));
    261     * }
    262     * </pre>
    263     *
    264     * with "partial matching" turned on, {@code -de} only matches the {@code "debug"} option. However, with
    265     * "partial matching" disabled, {@code -de} would enable both {@code debug} as well as {@code extract}
    266     * options.
    267     */
    268    public DefaultParser() {
    269        this.allowPartialMatching = true;
    270        this.stripLeadingAndTrailingQuotes = null;
    271        this.deprecatedHandler = CommandLine.Builder.DEPRECATED_HANDLER;
    272    }
    273
    274    /**
    275     * Create a new DefaultParser instance with the specified partial matching policy.
    276     *
    277     * By "partial matching" we mean that given the following code:
    278     *
    279     * <pre>
    280     * {
    281     *     &#64;code
    282     *     final Options options = new Options();
    283     *     options.addOption(new Option("d", "debug", false, "Turn on debug."));
    284     *     options.addOption(new Option("e", "extract", false, "Turn on extract."));
    285     *     options.addOption(new Option("o", "option", true, "Turn on option with argument."));
    286     * }
    287     * </pre>
    288     *
    289     * with "partial matching" turned on, {@code -de} only matches the {@code "debug"} option. However, with
    290     * "partial matching" disabled, {@code -de} would enable both {@code debug} as well as {@code extract}
    291     * options.
    292     *
    293     * @param allowPartialMatching if partial matching of long options shall be enabled
    294     */
    295    public DefaultParser(final boolean allowPartialMatching) {
    296        this.allowPartialMatching = allowPartialMatching;
    297        this.stripLeadingAndTrailingQuotes = null;
    298        this.deprecatedHandler = CommandLine.Builder.DEPRECATED_HANDLER;
    299    }
    300
    301    /**
    302     * Creates a new DefaultParser instance with the specified partial matching and quote
    303     * stripping policy.
    304     *
    305     * @param allowPartialMatching if partial matching of long options shall be enabled
    306     * @param stripLeadingAndTrailingQuotes if balanced outer double quoutes should be stripped
    307     */
    308    private DefaultParser(final boolean allowPartialMatching, final Boolean stripLeadingAndTrailingQuotes, final Consumer<Option> deprecatedHandler) {
    309        this.allowPartialMatching = allowPartialMatching;
    310        this.stripLeadingAndTrailingQuotes = stripLeadingAndTrailingQuotes;
    311        this.deprecatedHandler = deprecatedHandler;
    312    }
    313
    314    /**
    315     * Adds token to command line {@link CommandLine#addArg(String)}.
    316     *
    317     * @param token the unrecognized option/argument.
    318     * @since 1.10.0
    319     */
    320    protected void addArg(final String token) {
    321        cmd.addArg(token);
    322    }
    323
    324    /**
    325     * Throws a {@link MissingArgumentException} if the current option didn't receive the number of arguments expected.
    326     */
    327    private void checkRequiredArgs() throws ParseException {
    328        if (currentOption != null && currentOption.requiresArg()) {
    329            if (isJavaProperty(currentOption.getKey()) && currentOption.getValuesList().size() == 1) {
    330                return;
    331            }
    332            throw new MissingArgumentException(currentOption);
    333        }
    334    }
    335
    336    /**
    337     * Throws a {@link MissingOptionException} if all of the required options are not present.
    338     *
    339     * @throws MissingOptionException if any of the required Options are not present.
    340     */
    341    protected void checkRequiredOptions() throws MissingOptionException {
    342        // if there are required options that have not been processed
    343        if (!expectedOpts.isEmpty()) {
    344            throw new MissingOptionException(expectedOpts);
    345        }
    346    }
    347
    348    /**
    349     * Searches for a prefix that is the long name of an option (-Xmx512m).
    350     *
    351     * @param token
    352     */
    353    private String getLongPrefix(final String token) {
    354        final String t = Util.stripLeadingHyphens(token);
    355        int i;
    356        String opt = null;
    357        for (i = t.length() - 2; i > 1; i--) {
    358            final String prefix = t.substring(0, i);
    359            if (options.hasLongOption(prefix)) {
    360                opt = prefix;
    361                break;
    362            }
    363        }
    364        return opt;
    365    }
    366
    367    /**
    368     * Gets a list of matching option strings for the given token, depending on the selected partial matching policy.
    369     *
    370     * @param token the token (may contain leading dashes).
    371     * @return the list of matching option strings or an empty list if no matching option could be found.
    372     */
    373    private List<String> getMatchingLongOptions(final String token) {
    374        if (allowPartialMatching) {
    375            return options.getMatchingOptions(token);
    376        }
    377        final List<String> matches = new ArrayList<>(1);
    378        if (options.hasLongOption(token)) {
    379            matches.add(options.getOption(token).getLongOpt());
    380        }
    381        return matches;
    382    }
    383
    384    /**
    385     * Breaks {@code token} into its constituent parts using the following algorithm.
    386     *
    387     * <ul>
    388     * <li>ignore the first character ("<strong>-</strong>")</li>
    389     * <li>for each remaining character check if an {@link Option} exists with that id.</li>
    390     * <li>if an {@link Option} does exist then add that character prepended with "<strong>-</strong>" to the list of processed
    391     * tokens.</li>
    392     * <li>if the {@link Option} can have an argument value and there are remaining characters in the token then add the
    393     * remaining characters as a token to the list of processed tokens.</li>
    394     * <li>if an {@link Option} does <strong>NOT</strong> exist <strong>AND</strong> {@code stopAtNonOption} <strong>IS</strong> set then add the
    395     * special token "<strong>--</strong>" followed by the remaining characters and also the remaining tokens directly to the
    396     * processed tokens list.</li>
    397     * <li>if an {@link Option} does <strong>NOT</strong> exist <strong>AND</strong> {@code stopAtNonOption} <strong>IS NOT</strong> set then add
    398     * that character prepended with "<strong>-</strong>".</li>
    399     * </ul>
    400     *
    401     * @param token The current token to be <strong>burst</strong> at the first non-Option encountered.
    402     * @throws ParseException if there are any problems encountered while parsing the command line token.
    403     */
    404    protected void handleConcatenatedOptions(final String token) throws ParseException {
    405        for (int i = 1; i < token.length(); i++) {
    406            final String ch = String.valueOf(token.charAt(i));
    407            if (!options.hasOption(ch)) {
    408                handleUnknownToken(nonOptionAction == NonOptionAction.STOP && i > 1 ? token.substring(i) : token);
    409                break;
    410            }
    411            handleOption(options.getOption(ch));
    412            if (currentOption != null && token.length() != i + 1) {
    413                // add the trail as an argument of the option
    414                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(i + 1)));
    415                break;
    416            }
    417        }
    418    }
    419
    420    /**
    421     * Handles the following tokens:
    422     * <pre>
    423     * --L --L=V --L V --l
    424     * </pre>
    425     *
    426     * @param token the command line token to handle.
    427     */
    428    private void handleLongOption(final String token) throws ParseException {
    429        if (indexOfEqual(token) == -1) {
    430            handleLongOptionWithoutEqual(token);
    431        } else {
    432            handleLongOptionWithEqual(token);
    433        }
    434    }
    435
    436    /**
    437     * Handles the following tokens:
    438     * <pre>
    439     * --L=V -L=V --l=V -l=V
    440     * </pre>
    441     *
    442     * @param token the command line token to handle.
    443     */
    444    private void handleLongOptionWithEqual(final String token) throws ParseException {
    445        final int pos = indexOfEqual(token);
    446        final String value = token.substring(pos + 1);
    447        final String opt = token.substring(0, pos);
    448        final List<String> matchingOpts = getMatchingLongOptions(opt);
    449        if (matchingOpts.isEmpty()) {
    450            handleUnknownToken(currentToken);
    451        } else if (matchingOpts.size() > 1 && !options.hasLongOption(opt)) {
    452            throw new AmbiguousOptionException(opt, matchingOpts);
    453        } else {
    454            final String key = options.hasLongOption(opt) ? opt : matchingOpts.get(0);
    455            final Option option = options.getOption(key);
    456            if (option.acceptsArg()) {
    457                handleOption(option);
    458                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(value));
    459                currentOption = null;
    460            } else {
    461                handleUnknownToken(currentToken);
    462            }
    463        }
    464    }
    465
    466    /**
    467     * Handles the following tokens:
    468     *
    469     * <pre>
    470     * --L -L --l -l
    471     * </pre>
    472     *
    473     * @param token the command line token to handle.
    474     */
    475    private void handleLongOptionWithoutEqual(final String token) throws ParseException {
    476        final List<String> matchingOpts = getMatchingLongOptions(token);
    477        if (matchingOpts.isEmpty()) {
    478            handleUnknownToken(currentToken);
    479        } else if (matchingOpts.size() > 1 && !options.hasLongOption(token)) {
    480            throw new AmbiguousOptionException(token, matchingOpts);
    481        } else {
    482            final String key = options.hasLongOption(token) ? token : matchingOpts.get(0);
    483            handleOption(options.getOption(key));
    484        }
    485    }
    486
    487    private void handleOption(final Option option) throws ParseException {
    488        // check the previous option before handling the next one
    489        checkRequiredArgs();
    490        final Option copy = (Option) option.clone();
    491        updateRequiredOptions(copy);
    492        cmd.addOption(copy);
    493        currentOption = copy.hasArg() ? copy : null;
    494    }
    495
    496    /**
    497     * Sets the values of Options using the values in {@code properties}.
    498     *
    499     * @param properties The value properties to be processed.
    500     */
    501    private void handleProperties(final Properties properties) throws ParseException {
    502        if (properties == null) {
    503            return;
    504        }
    505        for (final Enumeration<?> e = properties.propertyNames(); e.hasMoreElements();) {
    506            final String option = e.nextElement().toString();
    507            final Option opt = options.getOption(option);
    508            if (opt == null) {
    509                throw new UnrecognizedOptionException("Default option wasn't defined", option);
    510            }
    511            // if the option is part of a group, check if another option of the group has been selected
    512            final OptionGroup optionGroup = options.getOptionGroup(opt);
    513            final boolean selected = optionGroup != null && optionGroup.isSelected();
    514            if (!cmd.hasOption(option) && !selected) {
    515                // get the value from the properties
    516                final String value = properties.getProperty(option);
    517
    518                if (opt.hasArg()) {
    519                    if (Util.isEmpty(opt.getValues())) {
    520                        opt.processValue(stripLeadingAndTrailingQuotesDefaultOff(value));
    521                    }
    522                } else if (!("yes".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value) || "1".equalsIgnoreCase(value))) {
    523                    // if the value is not yes, true or 1 then don't add the option to the CommandLine
    524                    continue;
    525                }
    526                handleOption(opt);
    527                currentOption = null;
    528            }
    529        }
    530    }
    531
    532    /**
    533     * Handles the following tokens:
    534     * <pre>
    535     * -S -SV -S V -S=V -S1S2 -S1S2 V -SV1=V2
    536     *
    537     * -L -LV -L V -L=V -l
    538     * </pre>
    539     *
    540     * @param hyphenToken the command line token to handle.
    541     */
    542    private void handleShortAndLongOption(final String hyphenToken) throws ParseException {
    543        final String token = Util.stripLeadingHyphens(hyphenToken);
    544        final int pos = indexOfEqual(token);
    545        if (token.length() == 1) {
    546            // -S
    547            if (options.hasShortOption(token)) {
    548                handleOption(options.getOption(token));
    549            } else {
    550                handleUnknownToken(hyphenToken);
    551            }
    552        } else if (pos == -1) {
    553            // no equal sign found (-xxx)
    554            if (options.hasShortOption(token)) {
    555                handleOption(options.getOption(token));
    556            } else if (!getMatchingLongOptions(token).isEmpty()) {
    557                // -L or -l
    558                handleLongOptionWithoutEqual(hyphenToken);
    559            } else {
    560                // look for a long prefix (-Xmx512m)
    561                final String opt = getLongPrefix(token);
    562
    563                if (opt != null && options.getOption(opt).acceptsArg()) {
    564                    handleOption(options.getOption(opt));
    565                    currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(opt.length())));
    566                    currentOption = null;
    567                } else if (isJavaProperty(token)) {
    568                    // -SV1 (-Dflag)
    569                    handleOption(options.getOption(token.substring(0, 1)));
    570                    currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOff(token.substring(1)));
    571                    currentOption = null;
    572                } else {
    573                    // -S1S2S3 or -S1S2V
    574                    handleConcatenatedOptions(hyphenToken);
    575                }
    576            }
    577        } else {
    578            // equal sign found (-xxx=yyy)
    579            final String opt = token.substring(0, pos);
    580            final String value = token.substring(pos + 1);
    581
    582            if (opt.length() == 1) {
    583                // -S=V
    584                final Option option = options.getOption(opt);
    585                if (option != null && option.acceptsArg()) {
    586                    handleOption(option);
    587                    currentOption.processValue(value);
    588                    currentOption = null;
    589                } else {
    590                    handleUnknownToken(hyphenToken);
    591                }
    592            } else if (isJavaProperty(opt)) {
    593                // -SV1=V2 (-Dkey=value)
    594                handleOption(options.getOption(opt.substring(0, 1)));
    595                currentOption.processValue(opt.substring(1));
    596                currentOption.processValue(value);
    597                currentOption = null;
    598            } else {
    599                // -L=V or -l=V
    600                handleLongOptionWithEqual(hyphenToken);
    601            }
    602        }
    603    }
    604
    605    /**
    606     * Handles any command line token.
    607     *
    608     * @param token the command line token to handle.
    609     * @throws ParseException
    610     */
    611    private void handleToken(final String token) throws ParseException {
    612        if (token != null) {
    613            currentToken = token;
    614            if (skipParsing) {
    615                addArg(token);
    616            } else if ("--".equals(token)) {
    617                skipParsing = true;
    618            } else if (currentOption != null && currentOption.acceptsArg() && isArgument(token)) {
    619                currentOption.processValue(stripLeadingAndTrailingQuotesDefaultOn(token));
    620            } else if (token.startsWith("--")) {
    621                handleLongOption(token);
    622            } else if (token.startsWith("-") && !"-".equals(token)) {
    623                handleShortAndLongOption(token);
    624            } else {
    625                handleUnknownToken(token);
    626            }
    627            if (currentOption != null && !currentOption.acceptsArg()) {
    628                currentOption = null;
    629            }
    630        }
    631    }
    632
    633    /**
    634     * Handles an unknown token. If the token starts with a dash an UnrecognizedOptionException is thrown. Otherwise the
    635     * token is added to the arguments of the command line. If the stopAtNonOption flag is set, this stops the parsing and
    636     * the remaining tokens are added as-is in the arguments of the command line.
    637     *
    638     * @param token the command line token to handle.
    639     * @throws ParseException if parsing should fail.
    640     * @since 1.10.0
    641     */
    642    protected void handleUnknownToken(final String token) throws ParseException {
    643        if (token.startsWith("-") && token.length() > 1 && nonOptionAction == NonOptionAction.THROW) {
    644            throw new UnrecognizedOptionException("Unrecognized option: " + token, token);
    645        }
    646        if (!token.startsWith("-") || token.equals("-") || token.length() > 1 && nonOptionAction != NonOptionAction.IGNORE) {
    647            addArg(token);
    648        }
    649        if (nonOptionAction == NonOptionAction.STOP) {
    650            skipParsing = true;
    651        }
    652    }
    653
    654    /**
    655     * Tests if the token is a valid argument.
    656     *
    657     * @param token
    658     */
    659    private boolean isArgument(final String token) {
    660        return !isOption(token) || isNegativeNumber(token);
    661    }
    662
    663    /**
    664     * Tests if the specified token is a Java-like property (-Dkey=value).
    665     */
    666    private boolean isJavaProperty(final String token) {
    667        final String opt = token.isEmpty() ? null : token.substring(0, 1);
    668        final Option option = options.getOption(opt);
    669        return option != null && (option.getArgs() >= 2 || option.getArgs() == Option.UNLIMITED_VALUES);
    670    }
    671
    672    /**
    673     * Tests if the token looks like a long option.
    674     *
    675     * @param token
    676     */
    677    private boolean isLongOption(final String token) {
    678        if (token == null || !token.startsWith("-") || token.length() == 1) {
    679            return false;
    680        }
    681        final int pos = indexOfEqual(token);
    682        final String t = pos == -1 ? token : token.substring(0, pos);
    683        if (!getMatchingLongOptions(t).isEmpty()) {
    684            // long or partial long options (--L, -L, --L=V, -L=V, --l, --l=V)
    685            return true;
    686        }
    687        if (getLongPrefix(token) != null && !token.startsWith("--")) {
    688            // -LV
    689            return true;
    690        }
    691        return false;
    692    }
    693
    694    /**
    695     * Tests if the token is a negative number.
    696     *
    697     * @param token
    698     */
    699    private boolean isNegativeNumber(final String token) {
    700        try {
    701            Double.parseDouble(token);
    702            return true;
    703        } catch (final NumberFormatException e) {
    704            return false;
    705        }
    706    }
    707
    708    /**
    709     * Tests if the token looks like an option.
    710     *
    711     * @param token
    712     */
    713    private boolean isOption(final String token) {
    714        return isLongOption(token) || isShortOption(token);
    715    }
    716
    717    /**
    718     * Tests if the token looks like a short option.
    719     *
    720     * @param token
    721     */
    722    private boolean isShortOption(final String token) {
    723        // short options (-S, -SV, -S=V, -SV1=V2, -S1S2)
    724        if (token == null || !token.startsWith("-") || token.length() == 1) {
    725            return false;
    726        }
    727        // remove leading "-" and "=value"
    728        final int pos = indexOfEqual(token);
    729        final String optName = pos == -1 ? token.substring(1) : token.substring(1, pos);
    730        if (options.hasShortOption(optName)) {
    731            return true;
    732        }
    733        // check for several concatenated short options
    734        return !optName.isEmpty() && options.hasShortOption(String.valueOf(optName.charAt(0)));
    735    }
    736
    737    /**
    738     * Parses the arguments according to the specified options and properties.
    739     *
    740     * @param options the specified Options
    741     * @param properties command line option name-value pairs
    742     * @param nonOptionAction see {@link NonOptionAction}.
    743     * @param arguments the command line arguments
    744     *
    745     * @return the list of atomic option and value tokens.
    746     * @throws ParseException if there are any problems encountered while parsing the command line tokens.
    747     * @since 1.10.0
    748     */
    749    public CommandLine parse(final Options options, final Properties properties, final NonOptionAction nonOptionAction, final String... arguments)
    750            throws ParseException {
    751        this.options = Objects.requireNonNull(options, "options");
    752        this.nonOptionAction = nonOptionAction;
    753        skipParsing = false;
    754        currentOption = null;
    755        expectedOpts = new ArrayList<>(options.getRequiredOptions());
    756        // clear the data from the groups
    757        for (final OptionGroup optionGroup : options.getOptionGroups()) {
    758            optionGroup.setSelected(null);
    759        }
    760        cmd = CommandLine.builder().setDeprecatedHandler(deprecatedHandler).get();
    761        if (arguments != null) {
    762            for (final String argument : arguments) {
    763                handleToken(argument);
    764            }
    765        }
    766        // check the arguments of the last option
    767        checkRequiredArgs();
    768        // add the default options
    769        handleProperties(properties);
    770        checkRequiredOptions();
    771        return cmd;
    772    }
    773
    774    @Override
    775    public CommandLine parse(final Options options, final String[] arguments) throws ParseException {
    776        return parse(options, arguments, null);
    777    }
    778
    779    /**
    780     * @see #parse(Options, Properties, NonOptionAction, String[])
    781     */
    782    @Override
    783    public CommandLine parse(final Options options, final String[] arguments, final boolean stopAtNonOption) throws ParseException {
    784        return parse(options, arguments, null, stopAtNonOption);
    785    }
    786
    787    /**
    788     * Parses the arguments according to the specified options and properties.
    789     *
    790     * @param options the specified Options.
    791     * @param arguments the command line arguments.
    792     * @param properties command line option name-value pairs.
    793     * @return the list of atomic option and value tokens.
    794     * @throws ParseException if there are any problems encountered while parsing the command line tokens.
    795     */
    796    public CommandLine parse(final Options options, final String[] arguments, final Properties properties) throws ParseException {
    797        return parse(options, arguments, properties, false);
    798    }
    799
    800    /**
    801     * Parses the arguments according to the specified options and properties.
    802     *
    803     * @param options the specified Options.
    804     * @param arguments the command line arguments.
    805     * @param properties command line option name-value pairs.
    806     * @param stopAtNonOption if {@code true} an unrecognized argument stops the parsing and the remaining arguments
    807     *        are added to the {@link CommandLine}s args list. If {@code false} an unrecognized argument triggers a
    808     *        ParseException.
    809     * @return the list of atomic option and value tokens.
    810     * @throws ParseException if there are any problems encountered while parsing the command line tokens.
    811     * @see #parse(Options, Properties, NonOptionAction, String[])
    812     */
    813    public CommandLine parse(final Options options, final String[] arguments, final Properties properties, final boolean stopAtNonOption)
    814        throws ParseException {
    815        return parse(options, properties, stopAtNonOption ? NonOptionAction.STOP : NonOptionAction.THROW, arguments);
    816    }
    817
    818    /**
    819     * Strips balanced leading and trailing quotes if the stripLeadingAndTrailingQuotes is set
    820     * If stripLeadingAndTrailingQuotes is null, then do not strip
    821     *
    822     * @param token a string.
    823     * @return token with the quotes stripped (if set).
    824     */
    825    private String stripLeadingAndTrailingQuotesDefaultOff(final String token) {
    826        if (stripLeadingAndTrailingQuotes != null && stripLeadingAndTrailingQuotes) {
    827            return Util.stripLeadingAndTrailingQuotes(token);
    828        }
    829        return token;
    830    }
    831
    832    /**
    833     * Strips balanced leading and trailing quotes if the stripLeadingAndTrailingQuotes is set
    834     * If stripLeadingAndTrailingQuotes is null, then do not strip
    835     *
    836     * @param token a string.
    837     * @return token with the quotes stripped (if set).
    838     */
    839    private String stripLeadingAndTrailingQuotesDefaultOn(final String token) {
    840        if (stripLeadingAndTrailingQuotes == null || stripLeadingAndTrailingQuotes) {
    841            return Util.stripLeadingAndTrailingQuotes(token);
    842        }
    843        return token;
    844    }
    845
    846    /**
    847     * Removes the option or its group from the list of expected elements.
    848     *
    849     * @param option
    850     */
    851    private void updateRequiredOptions(final Option option) throws AlreadySelectedException {
    852        if (option.isRequired()) {
    853            expectedOpts.remove(option.getKey());
    854        }
    855        // if the option is in an OptionGroup make that option the selected option of the group
    856        if (options.getOptionGroup(option) != null) {
    857            final OptionGroup optionGroup = options.getOptionGroup(option);
    858            if (optionGroup.isRequired()) {
    859                expectedOpts.remove(optionGroup);
    860            }
    861            optionGroup.setSelected(option);
    862        }
    863    }
    864}