args) throws OptionsParsingException {
return parse(priority, sourceFunction, null, null, args);
}
/**
* Parses the args, and returns what it doesn't parse. May be called multiple
* times, and may be called recursively. Calls may contain intersecting sets
* of options; in that case, the arg seen last takes precedence.
*
* The method uses the invariant that if an option has neither an implicit
* dependent nor an expanded from value, then it must have been explicitly
* set.
*/
private List parse(
OptionPriority priority,
Function sourceFunction,
String implicitDependent,
String expandedFrom,
List args) throws OptionsParsingException {
List unparsedArgs = new ArrayList<>();
LinkedHashMap> implicitRequirements = new LinkedHashMap<>();
Iterator argsIterator = argsPreProcessor.preProcess(args).iterator();
while (argsIterator.hasNext()) {
String arg = argsIterator.next();
if (!arg.startsWith("-")) {
unparsedArgs.add(arg);
continue; // not an option arg
}
if (arg.equals("--")) { // "--" means all remaining args aren't options
Iterators.addAll(unparsedArgs, argsIterator);
break;
}
ParseOptionResult parseOptionResult = parseOption(arg, argsIterator);
Field field = parseOptionResult.field;
Option option = parseOptionResult.option;
String value = parseOptionResult.value;
final String originalName = option.name();
if (option.wrapperOption()) {
if (value.startsWith("-")) {
List unparsed = parse(
priority,
Functions.constant("Unwrapped from wrapper option --" + originalName),
null, // implicitDependent
null, // expandedFrom
ImmutableList.of(value));
if (!unparsed.isEmpty()) {
throw new OptionsParsingException(
"Unparsed options remain after unwrapping "
+ arg
+ ": "
+ Joiner.on(' ').join(unparsed));
}
// Don't process implicitRequirements or expansions for wrapper options. In particular,
// don't record this option in unparsedValues, so that only the wrapped option shows
// up in canonicalized options.
continue;
} else {
throw new OptionsParsingException("Invalid --" + originalName + " value format. "
+ "You may have meant --" + originalName + "=--" + value);
}
}
if (implicitDependent == null) {
// Log explicit options and expanded options in the order they are parsed (can be sorted
// later). Also remember whether they were expanded or not. This information is needed to
// correctly canonicalize flags.
UnparsedOptionValueDescription unparsedOptionValueDescription =
new UnparsedOptionValueDescription(
originalName,
field,
value,
priority,
sourceFunction.apply(originalName),
expandedFrom == null);
unparsedValues.add(unparsedOptionValueDescription);
if (option.allowMultiple()) {
canonicalizeValues.put(field, unparsedOptionValueDescription);
} else {
canonicalizeValues.replaceValues(field, ImmutableList.of(unparsedOptionValueDescription));
}
}
// Handle expansion options.
String[] expansion = optionsData.getEvaluatedExpansion(field);
if (expansion.length > 0) {
Function expansionSourceFunction =
Functions.constant(
"expanded from option --"
+ originalName
+ " from "
+ sourceFunction.apply(originalName));
maybeAddDeprecationWarning(field);
List unparsed = parse(priority, expansionSourceFunction, null, originalName,
ImmutableList.copyOf(expansion));
if (!unparsed.isEmpty()) {
// Throw an assertion, because this indicates an error in the code that specified the
// expansion for the current option.
throw new AssertionError(
"Unparsed options remain after parsing expansion of "
+ arg
+ ": "
+ Joiner.on(' ').join(unparsed));
}
} else {
Converter converter = optionsData.getConverter(field);
Object convertedValue;
try {
convertedValue = converter.convert(value);
} catch (OptionsParsingException e) {
// The converter doesn't know the option name, so we supply it here by
// re-throwing:
throw new OptionsParsingException("While parsing option " + arg
+ ": " + e.getMessage(), e);
}
// ...but allow duplicates of single-use options across separate calls to
// parse(); latest wins:
if (!option.allowMultiple()) {
setValue(field, originalName, convertedValue,
priority, sourceFunction.apply(originalName), implicitDependent, expandedFrom);
} else {
// But if it's a multiple-use option, then just accumulate the
// values, in the order in which they were seen.
// Note: The type of the list member is not known; Java introspection
// only makes it available in String form via the signature string
// for the field declaration.
addListValue(field, originalName, convertedValue, priority,
sourceFunction.apply(originalName), implicitDependent, expandedFrom);
}
}
// Collect any implicit requirements.
if (option.implicitRequirements().length > 0) {
implicitRequirements.put(option.name(), Arrays.asList(option.implicitRequirements()));
}
}
// Now parse any implicit requirements that were collected.
// TODO(bazel-team): this should happen when the option is encountered.
if (!implicitRequirements.isEmpty()) {
for (Map.Entry> entry : implicitRequirements.entrySet()) {
Function requirementSourceFunction =
Functions.constant(
"implicit requirement of option --"
+ entry.getKey()
+ " from "
+ sourceFunction.apply(entry.getKey()));
List unparsed = parse(priority, requirementSourceFunction, entry.getKey(), null,
entry.getValue());
if (!unparsed.isEmpty()) {
// Throw an assertion, because this indicates an error in the code that specified in the
// implicit requirements for the option(s).
throw new AssertionError("Unparsed options remain after parsing implicit options: "
+ Joiner.on(' ').join(unparsed));
}
}
}
return unparsedArgs;
}
private static final class ParseOptionResult {
final Field field;
final Option option;
final String value;
ParseOptionResult(Field field, Option option, String value) {
this.field = field;
this.option = option;
this.value = value;
}
}
private ParseOptionResult parseOption(String arg, Iterator nextArgs)
throws OptionsParsingException {
String value = null;
Field field;
boolean booleanValue = true;
if (arg.length() == 2) { // -l (may be nullary or unary)
field = optionsData.getFieldForAbbrev(arg.charAt(1));
booleanValue = true;
} else if (arg.length() == 3 && arg.charAt(2) == '-') { // -l- (boolean)
field = optionsData.getFieldForAbbrev(arg.charAt(1));
booleanValue = false;
} else if (allowSingleDashLongOptions // -long_option
|| arg.startsWith("--")) { // or --long_option
int equalsAt = arg.indexOf('=');
int nameStartsAt = arg.startsWith("--") ? 2 : 1;
String name =
equalsAt == -1 ? arg.substring(nameStartsAt) : arg.substring(nameStartsAt, equalsAt);
if (name.trim().isEmpty()) {
throw new OptionsParsingException("Invalid options syntax: " + arg, arg);
}
value = equalsAt == -1 ? null : arg.substring(equalsAt + 1);
field = optionsData.getFieldFromName(name);
// Look for a "no"-prefixed option name: "no".
if (field == null && name.startsWith("no")) {
// Give a nice error if someone is using the deprecated --no_ prefix.
// TODO(Bazel-team): Remove the --no_ check when sufficient time has passed for users of
// that feature to have stopped using it.
name = name.substring(2);
if (name.startsWith("_") && optionsData.getFieldFromName(name.substring(1)) != null) {
name = name.substring(1);
warnings.add("Option '" + name + "' is specified using the deprecated --no_ prefix. "
+ "Use --no without the underscore instead.");
}
field = optionsData.getFieldFromName(name);
booleanValue = false;
if (field != null) {
// TODO(bazel-team): Add tests for these cases.
if (!OptionsData.isBooleanField(field)) {
throw new OptionsParsingException(
"Illegal use of 'no' prefix on non-boolean option: " + arg, arg);
}
if (value != null) {
throw new OptionsParsingException(
"Unexpected value after boolean option: " + arg, arg);
}
// "no" signifies a boolean option w/ false value
value = "0";
}
}
} else {
throw new OptionsParsingException("Invalid options syntax: " + arg, arg);
}
Option option = field == null ? null : field.getAnnotation(Option.class);
if (option == null
|| option.optionUsageRestrictions() == OptionUsageRestrictions.INTERNAL) {
// This also covers internal options, which are treated as if they did not exist.
throw new OptionsParsingException("Unrecognized option: " + arg, arg);
}
if (value == null) {
// Special-case boolean to supply value based on presence of "no" prefix.
if (OptionsData.isBooleanField(field)) {
value = booleanValue ? "1" : "0";
} else if (field.getType().equals(Void.class) && !option.wrapperOption()) {
// This is expected, Void type options have no args (unless they're wrapper options).
} else if (nextArgs.hasNext()) {
value = nextArgs.next(); // "--flag value" form
} else {
throw new OptionsParsingException("Expected value after " + arg);
}
}
return new ParseOptionResult(field, option, value);
}
/**
* Gets the result of parsing the options.
*/
O getParsedOptions(Class optionsClass) {
// Create the instance:
O optionsInstance;
try {
Constructor constructor = optionsData.getConstructor(optionsClass);
if (constructor == null) {
return null;
}
optionsInstance = constructor.newInstance();
} catch (ReflectiveOperationException e) {
throw new IllegalStateException("Error while instantiating options class", e);
}
// Set the fields
for (Field field : optionsData.getFieldsForClass(optionsClass)) {
Object value;
OptionValueDescription entry = parsedValues.get(field);
if (entry == null) {
value = optionsData.getDefaultValue(field);
} else {
value = entry.getValue();
}
try {
field.set(optionsInstance, value);
} catch (IllegalAccessException e) {
throw new IllegalStateException(e);
}
}
return optionsInstance;
}
List getWarnings() {
return ImmutableList.copyOf(warnings);
}
static String getDefaultOptionString(Field optionField) {
Option annotation = optionField.getAnnotation(Option.class);
return annotation.defaultValue();
}
static boolean isSpecialNullDefault(String defaultValueString, Field optionField) {
return defaultValueString.equals("null") && !optionField.getType().isPrimitive();
}
}