}
// Run the handler now!
- return Handler->addOccurance(ArgName, Value);
+ return Handler->addOccurrence(ArgName, Value);
}
static bool ProvidePositionalOption(Option *Handler, std::string &Arg) {
}
static bool RequiresValue(const Option *O) {
- return O->getNumOccurancesFlag() == cl::Required ||
- O->getNumOccurancesFlag() == cl::OneOrMore;
+ return O->getNumOccurrencesFlag() == cl::Required ||
+ O->getNumOccurrencesFlag() == cl::OneOrMore;
}
static bool EatsUnboundedNumberOfValues(const Option *O) {
- return O->getNumOccurancesFlag() == cl::ZeroOrMore ||
- O->getNumOccurancesFlag() == cl::OneOrMore;
+ return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
+ O->getNumOccurrencesFlag() == cl::OneOrMore;
}
void cl::ParseCommandLineOptions(int &argc, char **argv,
unsigned NumPositionalRequired = 0;
Option *ConsumeAfterOpt = 0;
if (!PositionalOpts.empty()) {
- if (PositionalOpts[0]->getNumOccurancesFlag() == cl::ConsumeAfter) {
+ if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) {
assert(PositionalOpts.size() > 1 &&
"Cannot specify cl::ConsumeAfter without a positional argument!");
ConsumeAfterOpt = PositionalOpts[0];
continue;
}
+ // Check to see if this option accepts a comma separated list of values. If
+ // it does, we have to split up the value into multiple values...
+ if (Handler->getMiscFlags() & CommaSeparated) {
+ std::string Val(Value);
+ std::string::size_type Pos = Val.find(',');
+
+ while (Pos != std::string::npos) {
+ // Process the portion before the comma...
+ ErrorParsing |= ProvideOption(Handler, ArgName,
+ std::string(Val.begin(),
+ Val.begin()+Pos).c_str(),
+ argc, argv, i);
+ // Erase the portion before the comma, AND the comma...
+ Val.erase(Val.begin(), Val.begin()+Pos+1);
+ Value += Pos+1; // Increment the original value pointer as well...
+
+ // Check for another comma...
+ Pos = Val.find(',');
+ }
+ }
ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
}
// do not give it values that others need. 'Done' controls whether the
// option even _WANTS_ any more.
//
- bool Done = PositionalOpts[i]->getNumOccurancesFlag() == cl::Required;
+ bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
while (NumVals-ValNo > NumPositionalRequired && !Done) {
- switch (PositionalOpts[i]->getNumOccurancesFlag()) {
+ switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
case cl::Optional:
Done = true; // Optional arguments want _at most_ one value
// FALL THROUGH
ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]);
break;
default:
- assert(0 && "Internal error, unexpected NumOccurances flag in "
+ assert(0 && "Internal error, unexpected NumOccurrences flag in "
"positional argument processing!");
}
}
// Loop over args and make sure all required args are specified!
for (std::map<std::string, Option*>::iterator I = Opts.begin(),
E = Opts.end(); I != E; ++I) {
- switch (I->second->getNumOccurancesFlag()) {
+ switch (I->second->getNumOccurrencesFlag()) {
case Required:
case OneOrMore:
- if (I->second->getNumOccurances() == 0) {
+ if (I->second->getNumOccurrences() == 0) {
I->second->error(" must be specified at least once!");
ErrorParsing = true;
}
return true;
}
-bool Option::addOccurance(const char *ArgName, const std::string &Value) {
- NumOccurances++; // Increment the number of times we have been seen
+bool Option::addOccurrence(const char *ArgName, const std::string &Value) {
+ NumOccurrences++; // Increment the number of times we have been seen
- switch (getNumOccurancesFlag()) {
+ switch (getNumOccurrencesFlag()) {
case Optional:
- if (NumOccurances > 1)
+ if (NumOccurrences > 1)
return error(": may only occur zero or one times!", ArgName);
break;
case Required:
- if (NumOccurances > 1)
+ if (NumOccurrences > 1)
return error(": must occur exactly one time!", ArgName);
// Fall through
case OneOrMore:
default: return error(": bad num occurances flag value!");
}
- return handleOccurance(ArgName, Value);
+ return handleOccurrence(ArgName, Value);
}
// addArgument - Tell the system that this Option subclass will handle all
AddArgument(ArgStr, this);
else if (getFormattingFlag() == Positional)
getPositionalOpts().push_back(this);
- else if (getNumOccurancesFlag() == ConsumeAfter) {
+ else if (getNumOccurrencesFlag() == ConsumeAfter) {
assert((getPositionalOpts().empty() ||
- getPositionalOpts().front()->getNumOccurancesFlag() != ConsumeAfter)
+ getPositionalOpts().front()->getNumOccurrencesFlag() != ConsumeAfter)
&& "Cannot specify more than one option with cl::ConsumeAfter "
"specified!");
getPositionalOpts().insert(getPositionalOpts().begin(), this);
std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this);
assert(I != getPositionalOpts().end() && "Arg not registered!");
getPositionalOpts().erase(I);
- } else if (getNumOccurancesFlag() == ConsumeAfter) {
+ } else if (getNumOccurrencesFlag() == ConsumeAfter) {
assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this &&
"Arg not registered correctly!");
getPositionalOpts().erase(getPositionalOpts().begin());
//
bool parser<int>::parse(Option &O, const char *ArgName,
const std::string &Arg, int &Value) {
- const char *ArgStart = Arg.c_str();
char *End;
- Value = (int)strtol(ArgStart, &End, 0);
+ Value = (int)strtol(Arg.c_str(), &End, 0);
if (*End != 0)
return O.error(": '" + Arg + "' value invalid for integer argument!");
return false;
}
+// parser<unsigned> implementation
+//
+bool parser<unsigned>::parse(Option &O, const char *ArgName,
+ const std::string &Arg, unsigned &Value) {
+ char *End;
+ long long int V = strtoll(Arg.c_str(), &End, 0);
+ Value = (unsigned)V;
+ if (*End != 0 || V < 0 || Value != V)
+ return O.error(": '" + Arg + "' value invalid for uint argument!");
+ return false;
+}
+
// parser<double>/parser<float> implementation
//
static bool parseDouble(Option &O, const std::string &Arg, double &Value) {
// Print out the positional options...
std::vector<Option*> &PosOpts = getPositionalOpts();
Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists...
- if (!PosOpts.empty() && PosOpts[0]->getNumOccurancesFlag() == ConsumeAfter)
+ if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter)
CAOpt = PosOpts[0];
for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i)
projects / oota-llvm.git / blobdiff