//===----------------------------------------------------------------------===//
#include "llvm/Option/Option.h"
-
#include "llvm/ADT/Twine.h"
#include "llvm/Option/Arg.h"
#include "llvm/Option/ArgList.h"
-#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
-
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
Option::Option(const OptTable::Info *info, const OptTable *owner)
: Info(info), Owner(owner) {
- // Multi-level aliases are not supported, and alias options cannot
- // have groups. This just simplifies option tracking, it is not an
- // inherent limitation.
- assert((!Info || !getAlias().isValid() || (!getAlias().getAlias().isValid() &&
- !getGroup().isValid())) &&
- "Multi-level aliases and aliases with groups are unsupported.");
-}
+ // Multi-level aliases are not supported. This just simplifies option
+ // tracking, it is not an inherent limitation.
+ assert((!Info || !getAlias().isValid() || !getAlias().getAlias().isValid()) &&
+ "Multi-level aliases are not supported.");
-Option::~Option() {
+ if (Info && getAliasArgs()) {
+ assert(getAlias().isValid() && "Only alias options can have alias args.");
+ assert(getKind() == FlagClass && "Only Flag aliases can have alias args.");
+ assert(getAlias().getKind() != FlagClass &&
+ "Cannot provide alias args to a flag option.");
+ }
}
-void Option::dump() const {
- llvm::errs() << "<";
+void Option::print(raw_ostream &O) const {
+ O << "<";
switch (getKind()) {
-#define P(N) case N: llvm::errs() << #N; break
+#define P(N) case N: O << #N; break
P(GroupClass);
P(InputClass);
P(UnknownClass);
P(MultiArgClass);
P(JoinedOrSeparateClass);
P(JoinedAndSeparateClass);
+ P(RemainingArgsClass);
#undef P
}
- llvm::errs() << " Prefixes:[";
- for (const char * const *Pre = Info->Prefixes; *Pre != 0; ++Pre) {
- llvm::errs() << '"' << *Pre << (*(Pre + 1) == 0 ? "\"" : "\", ");
+ if (Info->Prefixes) {
+ O << " Prefixes:[";
+ for (const char *const *Pre = Info->Prefixes; *Pre != nullptr; ++Pre) {
+ O << '"' << *Pre << (*(Pre + 1) == nullptr ? "\"" : "\", ");
+ }
+ O << ']';
}
- llvm::errs() << ']';
- llvm::errs() << " Name:\"" << getName() << '"';
+ O << " Name:\"" << getName() << '"';
const Option Group = getGroup();
if (Group.isValid()) {
- llvm::errs() << " Group:";
- Group.dump();
+ O << " Group:";
+ Group.print(O);
}
const Option Alias = getAlias();
if (Alias.isValid()) {
- llvm::errs() << " Alias:";
- Alias.dump();
+ O << " Alias:";
+ Alias.print(O);
}
if (getKind() == MultiArgClass)
- llvm::errs() << " NumArgs:" << getNumArgs();
+ O << " NumArgs:" << getNumArgs();
- llvm::errs() << ">\n";
+ O << ">\n";
}
+void Option::dump() const { print(dbgs()); }
+
bool Option::matches(OptSpecifier Opt) const {
// Aliases are never considered in matching, look through them.
const Option Alias = getAlias();
}
switch (getKind()) {
- case FlagClass:
+ case FlagClass: {
if (ArgSize != strlen(Args.getArgString(Index)))
- return 0;
+ return nullptr;
+
+ Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
+ if (getAliasArgs()) {
+ const char *Val = getAliasArgs();
+ while (*Val != '\0') {
+ A->getValues().push_back(Val);
+
+ // Move past the '\0' to the next argument.
+ Val += strlen(Val) + 1;
+ }
+ }
- return new Arg(UnaliasedOption, Spelling, Index++);
+ if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
+ // A Flag alias for a Joined option must provide an argument.
+ A->getValues().push_back("");
+
+ return A;
+ }
case JoinedClass: {
const char *Value = Args.getArgString(Index) + ArgSize;
return new Arg(UnaliasedOption, Spelling, Index++, Value);
// Matches iff this is an exact match.
// FIXME: Avoid strlen.
if (ArgSize != strlen(Args.getArgString(Index)))
- return 0;
+ return nullptr;
Index += 2;
- if (Index > Args.getNumInputArgStrings())
- return 0;
+ if (Index > Args.getNumInputArgStrings() ||
+ Args.getArgString(Index - 1) == nullptr)
+ return nullptr;
return new Arg(UnaliasedOption, Spelling,
Index - 2, Args.getArgString(Index - 1));
// Matches iff this is an exact match.
// FIXME: Avoid strlen.
if (ArgSize != strlen(Args.getArgString(Index)))
- return 0;
+ return nullptr;
Index += 1 + getNumArgs();
if (Index > Args.getNumInputArgStrings())
- return 0;
+ return nullptr;
Arg *A = new Arg(UnaliasedOption, Spelling, Index - 1 - getNumArgs(),
Args.getArgString(Index - getNumArgs()));
// Otherwise it must be separate.
Index += 2;
- if (Index > Args.getNumInputArgStrings())
- return 0;
+ if (Index > Args.getNumInputArgStrings() ||
+ Args.getArgString(Index - 1) == nullptr)
+ return nullptr;
return new Arg(UnaliasedOption, Spelling,
Index - 2, Args.getArgString(Index - 1));
case JoinedAndSeparateClass:
// Always matches.
Index += 2;
- if (Index > Args.getNumInputArgStrings())
- return 0;
+ if (Index > Args.getNumInputArgStrings() ||
+ Args.getArgString(Index - 1) == nullptr)
+ return nullptr;
return new Arg(UnaliasedOption, Spelling, Index - 2,
Args.getArgString(Index - 2) + ArgSize,
Args.getArgString(Index - 1));
+ case RemainingArgsClass: {
+ // Matches iff this is an exact match.
+ // FIXME: Avoid strlen.
+ if (ArgSize != strlen(Args.getArgString(Index)))
+ return nullptr;
+ Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
+ while (Index < Args.getNumInputArgStrings() &&
+ Args.getArgString(Index) != nullptr)
+ A->getValues().push_back(Args.getArgString(Index++));
+ return A;
+ }
default:
llvm_unreachable("Invalid option kind!");
}