in broker-core/src/main/java/org/apache/qpid/server/util/CommandLineParser.java [238:478]
public Properties parseCommandLine(String[] args) throws IllegalArgumentException
{
Properties options = new Properties();
// Used to keep count of the current 'free' argument.
int free = 1;
// Used to indicate that the most recently parsed option is expecting arguments.
boolean expectingArgs = false;
// The option that is expecting arguments from the next element of the command line.
String optionExpectingArgs = null;
// Used to indicate that the most recently parsed option is a duplicate and should be ignored.
boolean ignore = false;
// Create the regular expression matcher for the command line options.
StringBuilder regexp = new StringBuilder("^(");
int optionsAdded = 0;
for (Iterator<String> i = optionMap.keySet().iterator(); i.hasNext();)
{
String nextOption = i.next();
// Check that the option is not a free argument definition.
boolean notFree = false;
try
{
Integer.parseInt(nextOption);
}
catch (NumberFormatException e)
{
notFree = true;
}
// Add the option to the regular expression matcher if it is not a free argument definition.
if (notFree)
{
regexp.append(nextOption)
.append(i.hasNext() ? "|" : "");
optionsAdded++;
}
}
// There has to be more that one option in the regular expression or else the compiler complains that the close
// cannot be nullable if the '?' token is used to make the matched option string optional.
regexp.append(')')
.append(((optionsAdded > 0) ? "?" : ""))
.append("(.*)");
Pattern pattern = Pattern.compile(regexp.toString());
// Loop through all the command line arguments.
for (int i = 0; i < args.length; i++)
{
// Check if the next command line argument begins with a '-' character and is therefore the start of
// an option.
if (args[i].startsWith("-"))
{
// Extract the value of the option without the leading '-'.
String arg = args[i].substring(1);
// Match up to the longest matching option.
optionMatcher = pattern.matcher(arg);
optionMatcher.matches();
String matchedOption = optionMatcher.group(1);
// Match any argument directly appended onto the longest matching option.
String matchedArg = optionMatcher.group(2);
// Check that a known option was matched.
if ((matchedOption != null) && !"".equals(matchedOption))
{
// Get the command line option information for the matched option.
CommandLineOption optionInfo = optionMap.get(matchedOption);
// Check if this option is expecting arguments.
if (optionInfo.expectsArgs)
{
// The option is expecting arguments so swallow the next command line argument as an
// argument to this option.
expectingArgs = true;
optionExpectingArgs = matchedOption;
}
// Check if the option was matched on its own and is a flag in which case set that flag.
if ("".equals(matchedArg) && !optionInfo.expectsArgs)
{
options.put(matchedOption, "true");
}
// The option was matched as a substring with its argument appended to it or is a flag that is
// condensed together with other flags.
else if (!"".equals(matchedArg))
{
// Check if the option is a flag and therefore is allowed to be condensed together
// with other flags.
if (!optionInfo.expectsArgs)
{
// Set the first matched flag.
options.put(matchedOption, "true");
// Repeat the longest matching process on the remainder but ensure that the remainder
// consists only of flags as only flags may be condensed together in this fashion.
do
{
// Match the remainder against the options.
optionMatcher = pattern.matcher(matchedArg);
optionMatcher.matches();
matchedOption = optionMatcher.group(1);
matchedArg = optionMatcher.group(2);
// Check that an option was matched.
if (matchedOption != null)
{
// Get the command line option information for the next matched option.
optionInfo = optionMap.get(matchedOption);
// Ensure that the next option is a flag or raise an error if not.
if (optionInfo.expectsArgs == true)
{
parsingErrors.add("Option " + matchedOption + " cannot be combined with flags.\n");
}
options.put(matchedOption, "true");
}
// The remainder could not be matched against a flag it is either an unknown flag
// or an illegal argument to a flag.
else
{
parsingErrors.add("Illegal argument to a flag in the option " + arg + "\n");
break;
}
}
// Continue until the remainder of the argument has all been matched with flags.
while (!"".equals(matchedArg));
}
// The option is expecting an argument, so store the unmatched portion against it
// as its argument.
else
{
// Check the arguments format is correct against any specified format.
checkArgumentFormat(optionInfo, matchedArg);
// Store the argument against its option (regardless of its format).
options.put(matchedOption, matchedArg);
// The argument to this flag has already been supplied to it. Do not swallow the
// next command line argument as an argument to this flag.
expectingArgs = false;
}
}
}
else // No matching option was found.
{
// Add this to the list of parsing errors if errors on unkowns is being used.
if (errorsOnUnknowns)
{
parsingErrors.add("Option " + matchedOption + " is not a recognized option.\n");
}
}
}
// The command line argument did not being with a '-' so it is an argument to the previous flag or it
// is a free argument.
else
{
// Check if a previous flag is expecting to swallow this next argument as its argument.
if (expectingArgs)
{
// Get the option info for the option waiting for arguments.
CommandLineOption optionInfo = optionMap.get(optionExpectingArgs);
// Check the arguments format is correct against any specified format.
checkArgumentFormat(optionInfo, args[i]);
// Store the argument against its option (regardless of its format).
options.put(optionExpectingArgs, args[i]);
// Clear the expecting args flag now that the argument has been swallowed.
expectingArgs = false;
optionExpectingArgs = null;
}
// This command line option is not an argument to any option. Add it to the set of 'free' options.
else
{
// Get the option info for the free option, if there is any.
CommandLineOption optionInfo = optionMap.get(Integer.toString(free));
if (optionInfo != null)
{
// Check the arguments format is correct against any specified format.
checkArgumentFormat(optionInfo, args[i]);
}
// Add to the list of free options.
options.put(Integer.toString(free), args[i]);
// Move on to the next free argument.
free++;
}
}
}
// Scan through all the specified options to check that all mandatory options have been set and that all flags
// that were not set are set to false in the set of properties.
for (CommandLineOption optionInfo : optionMap.values())
{
// Check if this is a flag.
if (!optionInfo.expectsArgs)
{
// Check if the flag is not set in the properties and set it to false if so.
if (!options.containsKey(optionInfo.option))
{
options.put(optionInfo.option, "false");
}
}
// Check if this is a mandatory option and was not set.
else if (optionInfo.mandatory && !options.containsKey(optionInfo.option))
{
// Create an error for the missing option.
parsingErrors.add("Option -" + optionInfo.option + " is mandatory but not was not specified.\n");
}
}
// Check if there were any errors.
if (!parsingErrors.isEmpty())
{
// Throw an illegal argument exception to signify that there were parsing errors.
throw new IllegalArgumentException();
}
// Convert any name/value pairs in the free arguments into properties in the parsed options.
options = takeFreeArgsAsProperties(options, 1);
parsedProperties = options;
return options;
}