Line data Source code
1 : //===-- CommandLine.cpp - Command line parser implementation --------------===//
2 : //
3 : // The LLVM Compiler Infrastructure
4 : //
5 : // This file is distributed under the University of Illinois Open Source
6 : // License. See LICENSE.TXT for details.
7 : //
8 : //===----------------------------------------------------------------------===//
9 : //
10 : // This class implements a command line argument processor that is useful when
11 : // creating a tool. It provides a simple, minimalistic interface that is easily
12 : // extensible and supports nonlocal (library) command line options.
13 : //
14 : // Note that rather than trying to figure out what this code does, you could try
15 : // reading the library documentation located in docs/CommandLine.html
16 : //
17 : //===----------------------------------------------------------------------===//
18 :
19 : #include "llvm/Support/CommandLine.h"
20 : #include "llvm-c/Support.h"
21 : #include "llvm/ADT/ArrayRef.h"
22 : #include "llvm/ADT/Optional.h"
23 : #include "llvm/ADT/STLExtras.h"
24 : #include "llvm/ADT/SmallPtrSet.h"
25 : #include "llvm/ADT/SmallString.h"
26 : #include "llvm/ADT/StringExtras.h"
27 : #include "llvm/ADT/StringMap.h"
28 : #include "llvm/ADT/Triple.h"
29 : #include "llvm/ADT/Twine.h"
30 : #include "llvm/Config/config.h"
31 : #include "llvm/Support/ConvertUTF.h"
32 : #include "llvm/Support/Debug.h"
33 : #include "llvm/Support/ErrorHandling.h"
34 : #include "llvm/Support/FileSystem.h"
35 : #include "llvm/Support/Host.h"
36 : #include "llvm/Support/ManagedStatic.h"
37 : #include "llvm/Support/MemoryBuffer.h"
38 : #include "llvm/Support/Path.h"
39 : #include "llvm/Support/Process.h"
40 : #include "llvm/Support/StringSaver.h"
41 : #include "llvm/Support/raw_ostream.h"
42 : #include <cstdlib>
43 : #include <map>
44 : using namespace llvm;
45 : using namespace cl;
46 :
47 : #define DEBUG_TYPE "commandline"
48 :
49 : //===----------------------------------------------------------------------===//
50 : // Template instantiations and anchors.
51 : //
52 : namespace llvm {
53 : namespace cl {
54 : template class basic_parser<bool>;
55 : template class basic_parser<boolOrDefault>;
56 : template class basic_parser<int>;
57 : template class basic_parser<unsigned>;
58 : template class basic_parser<unsigned long long>;
59 : template class basic_parser<double>;
60 : template class basic_parser<float>;
61 : template class basic_parser<std::string>;
62 : template class basic_parser<char>;
63 :
64 : template class opt<unsigned>;
65 : template class opt<int>;
66 : template class opt<std::string>;
67 : template class opt<char>;
68 : template class opt<bool>;
69 : }
70 : } // end namespace llvm::cl
71 :
72 : // Pin the vtables to this file.
73 0 : void GenericOptionValue::anchor() {}
74 0 : void OptionValue<boolOrDefault>::anchor() {}
75 0 : void OptionValue<std::string>::anchor() {}
76 0 : void Option::anchor() {}
77 0 : void basic_parser_impl::anchor() {}
78 0 : void parser<bool>::anchor() {}
79 0 : void parser<boolOrDefault>::anchor() {}
80 0 : void parser<int>::anchor() {}
81 0 : void parser<unsigned>::anchor() {}
82 0 : void parser<unsigned long long>::anchor() {}
83 0 : void parser<double>::anchor() {}
84 0 : void parser<float>::anchor() {}
85 0 : void parser<std::string>::anchor() {}
86 0 : void parser<char>::anchor() {}
87 :
88 : //===----------------------------------------------------------------------===//
89 :
90 : namespace {
91 :
92 : class CommandLineParser {
93 : public:
94 : // Globals for name and overview of program. Program name is not a string to
95 : // avoid static ctor/dtor issues.
96 : std::string ProgramName;
97 : StringRef ProgramOverview;
98 :
99 : // This collects additional help to be printed.
100 : std::vector<StringRef> MoreHelp;
101 :
102 : // This collects the different option categories that have been registered.
103 : SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
104 :
105 : // This collects the different subcommands that have been registered.
106 : SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;
107 :
108 181221 : CommandLineParser() : ActiveSubCommand(nullptr) {
109 181221 : registerSubCommand(&*TopLevelSubCommand);
110 181221 : registerSubCommand(&*AllSubCommands);
111 181221 : }
112 :
113 : void ResetAllOptionOccurrences();
114 :
115 : bool ParseCommandLineOptions(int argc, const char *const *argv,
116 : StringRef Overview, raw_ostream *Errs = nullptr);
117 :
118 71527809 : void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) {
119 71527809 : if (Opt.hasArgStr())
120 : return;
121 5519149 : if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
122 0 : errs() << ProgramName << ": CommandLine Error: Option '" << Name
123 0 : << "' registered more than once!\n";
124 0 : report_fatal_error("inconsistency in registered CommandLine options");
125 : }
126 :
127 : // If we're adding this to all sub-commands, add it to the ones that have
128 : // already been registered.
129 5519149 : if (SC == &*AllSubCommands) {
130 0 : for (const auto &Sub : RegisteredSubCommands) {
131 0 : if (SC == Sub)
132 : continue;
133 0 : addLiteralOption(Opt, Sub, Name);
134 : }
135 : }
136 : }
137 :
138 71527809 : void addLiteralOption(Option &Opt, StringRef Name) {
139 71527809 : if (Opt.Subs.empty())
140 71521157 : addLiteralOption(Opt, &*TopLevelSubCommand, Name);
141 : else {
142 13304 : for (auto SC : Opt.Subs)
143 6652 : addLiteralOption(Opt, SC, Name);
144 : }
145 71527809 : }
146 :
147 155490069 : void addOption(Option *O, SubCommand *SC) {
148 : bool HadErrors = false;
149 310980138 : if (O->hasArgStr()) {
150 : // Add argument to the argument map!
151 155123485 : if (!SC->OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {
152 2 : errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
153 1 : << "' registered more than once!\n";
154 : HadErrors = true;
155 : }
156 : }
157 :
158 : // Remember information about positional options.
159 310980138 : if (O->getFormattingFlag() == cl::Positional)
160 118150 : SC->PositionalOpts.push_back(O);
161 155371919 : else if (O->getMiscFlags() & cl::Sink) // Remember sink options
162 0 : SC->SinkOpts.push_back(O);
163 155371919 : else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
164 225 : if (SC->ConsumeAfterOpt) {
165 0 : O->error("Cannot specify more than one option with cl::ConsumeAfter!");
166 : HadErrors = true;
167 : }
168 225 : SC->ConsumeAfterOpt = O;
169 : }
170 :
171 : // Fail hard if there were errors. These are strictly unrecoverable and
172 : // indicate serious issues such as conflicting option names or an
173 : // incorrectly
174 : // linked LLVM distribution.
175 155490069 : if (HadErrors)
176 1 : report_fatal_error("inconsistency in registered CommandLine options");
177 :
178 : // If we're adding this to all sub-commands, add it to the ones that have
179 : // already been registered.
180 155490068 : if (SC == &*AllSubCommands) {
181 3271971 : for (const auto &Sub : RegisteredSubCommands) {
182 2181379 : if (SC == Sub)
183 : continue;
184 1090787 : addOption(O, Sub);
185 : }
186 : }
187 155490068 : }
188 :
189 154387091 : void addOption(Option *O) {
190 154387091 : if (O->Subs.empty()) {
191 153269152 : addOption(O, &*TopLevelSubCommand);
192 : } else {
193 2235877 : for (auto SC : O->Subs)
194 1117939 : addOption(O, SC);
195 : }
196 154387090 : }
197 :
198 0 : void removeOption(Option *O, SubCommand *SC) {
199 : SmallVector<StringRef, 16> OptionNames;
200 0 : O->getExtraOptionNames(OptionNames);
201 0 : if (O->hasArgStr())
202 0 : OptionNames.push_back(O->ArgStr);
203 :
204 : SubCommand &Sub = *SC;
205 0 : for (auto Name : OptionNames)
206 0 : Sub.OptionsMap.erase(Name);
207 :
208 0 : if (O->getFormattingFlag() == cl::Positional)
209 0 : for (auto Opt = Sub.PositionalOpts.begin();
210 0 : Opt != Sub.PositionalOpts.end(); ++Opt) {
211 0 : if (*Opt == O) {
212 0 : Sub.PositionalOpts.erase(Opt);
213 0 : break;
214 : }
215 : }
216 0 : else if (O->getMiscFlags() & cl::Sink)
217 0 : for (auto Opt = Sub.SinkOpts.begin(); Opt != Sub.SinkOpts.end(); ++Opt) {
218 0 : if (*Opt == O) {
219 0 : Sub.SinkOpts.erase(Opt);
220 0 : break;
221 : }
222 : }
223 0 : else if (O == Sub.ConsumeAfterOpt)
224 0 : Sub.ConsumeAfterOpt = nullptr;
225 0 : }
226 :
227 52 : void removeOption(Option *O) {
228 52 : if (O->Subs.empty())
229 35 : removeOption(O, &*TopLevelSubCommand);
230 : else {
231 17 : if (O->isInAllSubCommands()) {
232 19 : for (auto SC : RegisteredSubCommands)
233 15 : removeOption(O, SC);
234 : } else {
235 26 : for (auto SC : O->Subs)
236 13 : removeOption(O, SC);
237 : }
238 : }
239 52 : }
240 :
241 : bool hasOptions(const SubCommand &Sub) const {
242 : return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() ||
243 : nullptr != Sub.ConsumeAfterOpt);
244 : }
245 :
246 : bool hasOptions() const {
247 : for (const auto &S : RegisteredSubCommands) {
248 : if (hasOptions(*S))
249 : return true;
250 : }
251 : return false;
252 : }
253 :
254 0 : SubCommand *getActiveSubCommand() { return ActiveSubCommand; }
255 :
256 1 : void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) {
257 : SubCommand &Sub = *SC;
258 1 : if (!Sub.OptionsMap.insert(std::make_pair(NewName, O)).second) {
259 0 : errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr
260 0 : << "' registered more than once!\n";
261 0 : report_fatal_error("inconsistency in registered CommandLine options");
262 : }
263 1 : Sub.OptionsMap.erase(O->ArgStr);
264 1 : }
265 :
266 1 : void updateArgStr(Option *O, StringRef NewName) {
267 1 : if (O->Subs.empty())
268 1 : updateArgStr(O, NewName, &*TopLevelSubCommand);
269 : else {
270 0 : for (auto SC : O->Subs)
271 0 : updateArgStr(O, NewName, SC);
272 : }
273 1 : }
274 :
275 : void printOptionValues();
276 :
277 : void registerCategory(OptionCategory *cat) {
278 : assert(count_if(RegisteredOptionCategories,
279 : [cat](const OptionCategory *Category) {
280 : return cat->getName() == Category->getName();
281 : }) == 0 &&
282 : "Duplicate option categories");
283 :
284 546259 : RegisteredOptionCategories.insert(cat);
285 : }
286 :
287 364490 : void registerSubCommand(SubCommand *sub) {
288 : assert(count_if(RegisteredSubCommands,
289 : [sub](const SubCommand *Sub) {
290 : return (!sub->getName().empty()) &&
291 : (Sub->getName() == sub->getName());
292 : }) == 0 &&
293 : "Duplicate subcommands");
294 364490 : RegisteredSubCommands.insert(sub);
295 :
296 : // For all options that have been registered for all subcommands, add the
297 : // option to this subcommand now.
298 364490 : if (sub != &*AllSubCommands) {
299 378711 : for (auto &E : AllSubCommands->OptionsMap) {
300 12191 : Option *O = E.second;
301 12191 : if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) ||
302 : O->hasArgStr())
303 12191 : addOption(O, sub);
304 : else
305 0 : addLiteralOption(*O, sub, E.first());
306 : }
307 : }
308 364490 : }
309 :
310 : void unregisterSubCommand(SubCommand *sub) {
311 : RegisteredSubCommands.erase(sub);
312 : }
313 :
314 : iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
315 75 : getRegisteredSubcommands() {
316 : return make_range(RegisteredSubCommands.begin(),
317 75 : RegisteredSubCommands.end());
318 : }
319 :
320 9 : void reset() {
321 9 : ActiveSubCommand = nullptr;
322 : ProgramName.clear();
323 9 : ProgramOverview = StringRef();
324 :
325 : MoreHelp.clear();
326 9 : RegisteredOptionCategories.clear();
327 :
328 9 : ResetAllOptionOccurrences();
329 9 : RegisteredSubCommands.clear();
330 :
331 9 : TopLevelSubCommand->reset();
332 9 : AllSubCommands->reset();
333 9 : registerSubCommand(&*TopLevelSubCommand);
334 9 : registerSubCommand(&*AllSubCommands);
335 9 : }
336 :
337 : private:
338 : SubCommand *ActiveSubCommand;
339 :
340 : Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value);
341 : SubCommand *LookupSubCommand(StringRef Name);
342 : };
343 :
344 : } // namespace
345 :
346 : static ManagedStatic<CommandLineParser> GlobalParser;
347 :
348 71527809 : void cl::AddLiteralOption(Option &O, StringRef Name) {
349 71527809 : GlobalParser->addLiteralOption(O, Name);
350 71527809 : }
351 :
352 2428 : extrahelp::extrahelp(StringRef Help) : morehelp(Help) {
353 2428 : GlobalParser->MoreHelp.push_back(Help);
354 2428 : }
355 :
356 154387091 : void Option::addArgument() {
357 154387091 : GlobalParser->addOption(this);
358 154387090 : FullyInitialized = true;
359 154387090 : }
360 :
361 52 : void Option::removeArgument() { GlobalParser->removeOption(this); }
362 :
363 154021191 : void Option::setArgStr(StringRef S) {
364 154021191 : if (FullyInitialized)
365 1 : GlobalParser->updateArgStr(this, S);
366 : assert((S.empty() || S[0] != '-') && "Option can't start with '-");
367 154021191 : ArgStr = S;
368 154021191 : }
369 :
370 : // Initialise the general option category.
371 : OptionCategory llvm::cl::GeneralCategory("General options");
372 :
373 546259 : void OptionCategory::registerCategory() {
374 : GlobalParser->registerCategory(this);
375 546259 : }
376 :
377 : // A special subcommand representing no subcommand
378 : ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand;
379 :
380 : // A special subcommand that can be used to put an option into all subcommands.
381 : ManagedStatic<SubCommand> llvm::cl::AllSubCommands;
382 :
383 2030 : void SubCommand::registerSubCommand() {
384 2030 : GlobalParser->registerSubCommand(this);
385 2030 : }
386 :
387 49 : void SubCommand::unregisterSubCommand() {
388 : GlobalParser->unregisterSubCommand(this);
389 49 : }
390 :
391 18 : void SubCommand::reset() {
392 : PositionalOpts.clear();
393 : SinkOpts.clear();
394 18 : OptionsMap.clear();
395 :
396 18 : ConsumeAfterOpt = nullptr;
397 18 : }
398 :
399 1517 : SubCommand::operator bool() const {
400 1517 : return (GlobalParser->getActiveSubCommand() == this);
401 : }
402 :
403 : //===----------------------------------------------------------------------===//
404 : // Basic, shared command line option processing machinery.
405 : //
406 :
407 : /// LookupOption - Lookup the option specified by the specified option on the
408 : /// command line. If there is a value specified (after an equal sign) return
409 : /// that as well. This assumes that leading dashes have already been stripped.
410 0 : Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg,
411 : StringRef &Value) {
412 : // Reject all dashes.
413 0 : if (Arg.empty())
414 0 : return nullptr;
415 : assert(&Sub != &*AllSubCommands);
416 :
417 0 : size_t EqualPos = Arg.find('=');
418 :
419 : // If we have an equals sign, remember the value.
420 0 : if (EqualPos == StringRef::npos) {
421 : // Look up the option.
422 0 : auto I = Sub.OptionsMap.find(Arg);
423 0 : if (I == Sub.OptionsMap.end())
424 0 : return nullptr;
425 :
426 0 : return I != Sub.OptionsMap.end() ? I->second : nullptr;
427 : }
428 :
429 : // If the argument before the = is a valid option name, we match. If not,
430 : // return Arg unmolested.
431 0 : auto I = Sub.OptionsMap.find(Arg.substr(0, EqualPos));
432 0 : if (I == Sub.OptionsMap.end())
433 0 : return nullptr;
434 :
435 0 : Value = Arg.substr(EqualPos + 1);
436 0 : Arg = Arg.substr(0, EqualPos);
437 0 : return I->second;
438 : }
439 :
440 47708 : SubCommand *CommandLineParser::LookupSubCommand(StringRef Name) {
441 47708 : if (Name.empty())
442 0 : return &*TopLevelSubCommand;
443 143731 : for (auto S : RegisteredSubCommands) {
444 96273 : if (S == &*AllSubCommands)
445 : continue;
446 48674 : if (S->getName().empty())
447 : continue;
448 :
449 : if (StringRef(S->getName()) == StringRef(Name))
450 250 : return S;
451 : }
452 47458 : return &*TopLevelSubCommand;
453 : }
454 :
455 : /// LookupNearestOption - Lookup the closest match to the option specified by
456 : /// the specified option on the command line. If there is a value specified
457 : /// (after an equal sign) return that as well. This assumes that leading dashes
458 : /// have already been stripped.
459 14 : static Option *LookupNearestOption(StringRef Arg,
460 : const StringMap<Option *> &OptionsMap,
461 : std::string &NearestString) {
462 : // Reject all dashes.
463 14 : if (Arg.empty())
464 : return nullptr;
465 :
466 : // Split on any equal sign.
467 14 : std::pair<StringRef, StringRef> SplitArg = Arg.split('=');
468 : StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present.
469 : StringRef &RHS = SplitArg.second;
470 :
471 : // Find the closest match.
472 : Option *Best = nullptr;
473 : unsigned BestDistance = 0;
474 14 : for (StringMap<Option *>::const_iterator it = OptionsMap.begin(),
475 : ie = OptionsMap.end();
476 11683 : it != ie; ++it) {
477 11669 : Option *O = it->second;
478 : SmallVector<StringRef, 16> OptionNames;
479 11669 : O->getExtraOptionNames(OptionNames);
480 11669 : if (O->hasArgStr())
481 10765 : OptionNames.push_back(O->ArgStr);
482 :
483 : bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed;
484 12613 : StringRef Flag = PermitValue ? LHS : Arg;
485 395786 : for (auto Name : OptionNames) {
486 384117 : unsigned Distance = StringRef(Name).edit_distance(
487 : Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance);
488 384117 : if (!Best || Distance < BestDistance) {
489 : Best = O;
490 : BestDistance = Distance;
491 57 : if (RHS.empty() || !PermitValue)
492 100 : NearestString = Name;
493 : else
494 14 : NearestString = (Twine(Name) + "=" + RHS).str();
495 : }
496 : }
497 : }
498 :
499 : return Best;
500 : }
501 :
502 : /// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence()
503 : /// that does special handling of cl::CommaSeparated options.
504 277726 : static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos,
505 : StringRef ArgName, StringRef Value,
506 : bool MultiArg = false) {
507 : // Check to see if this option accepts a comma separated list of values. If
508 : // it does, we have to split up the value into multiple values.
509 277726 : if (Handler->getMiscFlags() & CommaSeparated) {
510 14242 : StringRef Val(Value);
511 14242 : StringRef::size_type Pos = Val.find(',');
512 :
513 17584 : while (Pos != StringRef::npos) {
514 : // Process the portion before the comma.
515 18268 : if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg))
516 0 : return true;
517 : // Erase the portion before the comma, AND the comma.
518 18268 : Val = Val.substr(Pos + 1);
519 : // Check for another comma.
520 9134 : Pos = Val.find(',');
521 : }
522 :
523 14242 : Value = Val;
524 : }
525 :
526 277726 : return Handler->addOccurrence(pos, ArgName, Value, MultiArg);
527 : }
528 :
529 : /// ProvideOption - For Value, this differentiates between an empty value ("")
530 : /// and a null value (StringRef()). The later is accepted for arguments that
531 : /// don't allow a value (-foo) the former is rejected (-foo=).
532 277726 : static inline bool ProvideOption(Option *Handler, StringRef ArgName,
533 : StringRef Value, int argc,
534 : const char *const *argv, int &i) {
535 : // Is this a multi-argument option?
536 277726 : unsigned NumAdditionalVals = Handler->getNumAdditionalVals();
537 :
538 : // Enforce value requirements
539 277726 : switch (Handler->getValueExpectedFlag()) {
540 : case ValueRequired:
541 211983 : if (!Value.data()) { // No value specified?
542 25119 : if (i + 1 >= argc)
543 0 : return Handler->error("requires a value!");
544 : // Steal the next argument, like for '-o filename'
545 : assert(argv && "null check");
546 50238 : Value = StringRef(argv[++i]);
547 : }
548 : break;
549 13028 : case ValueDisallowed:
550 13028 : if (NumAdditionalVals > 0)
551 0 : return Handler->error("multi-valued option specified"
552 0 : " with ValueDisallowed modifier!");
553 :
554 13028 : if (Value.data())
555 0 : return Handler->error("does not allow a value! '" + Twine(Value) +
556 0 : "' specified.");
557 : break;
558 : case ValueOptional:
559 : break;
560 : }
561 :
562 : // If this isn't a multi-arg option, just run the handler.
563 277726 : if (NumAdditionalVals == 0)
564 277726 : return CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value);
565 :
566 : // If it is, run the handle several times.
567 : bool MultiArg = false;
568 :
569 0 : if (Value.data()) {
570 0 : if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
571 : return true;
572 0 : --NumAdditionalVals;
573 : MultiArg = true;
574 : }
575 :
576 0 : while (NumAdditionalVals > 0) {
577 0 : if (i + 1 >= argc)
578 0 : return Handler->error("not enough values!");
579 : assert(argv && "null check");
580 0 : Value = StringRef(argv[++i]);
581 :
582 0 : if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
583 : return true;
584 : MultiArg = true;
585 0 : --NumAdditionalVals;
586 : }
587 : return false;
588 : }
589 :
590 : static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
591 82628 : int Dummy = i;
592 6 : return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy);
593 : }
594 :
595 : // Option predicates...
596 9 : static inline bool isGrouping(const Option *O) {
597 9 : return O->getFormattingFlag() == cl::Grouping;
598 : }
599 2463 : static inline bool isPrefixedOrGrouping(const Option *O) {
600 2463 : return isGrouping(O) || O->getFormattingFlag() == cl::Prefix;
601 : }
602 :
603 : // getOptionPred - Check to see if there are any options that satisfy the
604 : // specified predicate with names that are the prefixes in Name. This is
605 : // checked by progressively stripping characters off of the name, checking to
606 : // see if there options that satisfy the predicate. If we find one, return it,
607 : // otherwise return null.
608 : //
609 2485 : static Option *getOptionPred(StringRef Name, size_t &Length,
610 : bool (*Pred)(const Option *),
611 : const StringMap<Option *> &OptionsMap) {
612 :
613 2485 : StringMap<Option *>::const_iterator OMI = OptionsMap.find(Name);
614 :
615 : // Loop while we haven't found an option and Name still has at least two
616 : // characters in it (so that the next iteration will not be the empty
617 : // string.
618 11508 : while (OMI == OptionsMap.end() && Name.size() > 1) {
619 3269 : Name = Name.substr(0, Name.size() - 1); // Chop off the last character.
620 3269 : OMI = OptionsMap.find(Name);
621 : }
622 :
623 2485 : if (OMI != OptionsMap.end() && Pred(OMI->second)) {
624 2471 : Length = Name.size();
625 2471 : return OMI->second; // Found one!
626 : }
627 : return nullptr; // No option found!
628 : }
629 :
630 : /// HandlePrefixedOrGroupedOption - The specified argument string (which started
631 : /// with at least one '-') does not fully match an available option. Check to
632 : /// see if this is a prefix or grouped option. If so, split arg into output an
633 : /// Arg/Value pair and return the Option to parse it with.
634 : static Option *
635 2476 : HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value,
636 : bool &ErrorParsing,
637 : const StringMap<Option *> &OptionsMap) {
638 2476 : if (Arg.size() == 1)
639 : return nullptr;
640 :
641 : // Do the lookup!
642 2476 : size_t Length = 0;
643 2476 : Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap);
644 2476 : if (!PGOpt)
645 : return nullptr;
646 :
647 : // If the option is a prefixed option, then the value is simply the
648 : // rest of the name... so fall through to later processing, by
649 : // setting up the argument name flags and value fields.
650 2462 : if (PGOpt->getFormattingFlag() == cl::Prefix) {
651 4912 : Value = Arg.substr(Length);
652 2456 : Arg = Arg.substr(0, Length);
653 : assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);
654 2456 : return PGOpt;
655 : }
656 :
657 : // This must be a grouped option... handle them now. Grouping options can't
658 : // have values.
659 : assert(isGrouping(PGOpt) && "Broken getOptionPred!");
660 :
661 : do {
662 : // Move current arg name out of Arg into OneArgName.
663 9 : StringRef OneArgName = Arg.substr(0, Length);
664 9 : Arg = Arg.substr(Length);
665 :
666 : // Because ValueRequired is an invalid flag for grouped arguments,
667 : // we don't need to pass argc/argv in.
668 : assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired &&
669 : "Option can not be cl::Grouping AND cl::ValueRequired!");
670 9 : int Dummy = 0;
671 9 : ErrorParsing |=
672 9 : ProvideOption(PGOpt, OneArgName, StringRef(), 0, nullptr, Dummy);
673 :
674 : // Get the next grouping option.
675 9 : PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap);
676 9 : } while (PGOpt && Length != Arg.size());
677 :
678 : // Return the last option with Arg cut down to just the last one.
679 : return PGOpt;
680 : }
681 :
682 : static bool RequiresValue(const Option *O) {
683 231032 : return O->getNumOccurrencesFlag() == cl::Required ||
684 : O->getNumOccurrencesFlag() == cl::OneOrMore;
685 : }
686 :
687 : static bool EatsUnboundedNumberOfValues(const Option *O) {
688 115635 : return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
689 : O->getNumOccurrencesFlag() == cl::OneOrMore;
690 : }
691 :
692 : static bool isWhitespace(char C) {
693 3607363 : return C == ' ' || C == '\t' || C == '\r' || C == '\n';
694 : }
695 :
696 : static bool isWhitespaceOrNull(char C) {
697 4665 : return isWhitespace(C) || C == '\0';
698 : }
699 :
700 3302208 : static bool isQuote(char C) { return C == '\"' || C == '\''; }
701 :
702 81 : void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver,
703 : SmallVectorImpl<const char *> &NewArgv,
704 : bool MarkEOLs) {
705 : SmallString<128> Token;
706 3302307 : for (size_t I = 0, E = Src.size(); I != E; ++I) {
707 : // Consume runs of whitespace.
708 3302228 : if (Token.empty()) {
709 900215 : while (I != E && isWhitespace(Src[I])) {
710 : // Mark the end of lines in response files
711 19 : if (MarkEOLs && Src[I] == '\n')
712 0 : NewArgv.push_back(nullptr);
713 19 : ++I;
714 : }
715 900196 : if (I == E)
716 : break;
717 : }
718 :
719 3302226 : char C = Src[I];
720 :
721 : // Backslash escapes the next character.
722 3302226 : if (I + 1 < E && C == '\\') {
723 : ++I; // Skip the escape.
724 18 : Token.push_back(Src[I]);
725 1500226 : continue;
726 : }
727 :
728 : // Consume a quoted string.
729 3302208 : if (isQuote(C)) {
730 : ++I;
731 2401207 : while (I != E && Src[I] != C) {
732 : // Backslash escapes the next character.
733 1801134 : if (Src[I] == '\\' && I + 1 != E)
734 : ++I;
735 1801134 : Token.push_back(Src[I]);
736 1801134 : ++I;
737 : }
738 600073 : if (I == E)
739 : break;
740 : continue;
741 : }
742 :
743 : // End the token if this is whitespace.
744 : if (isWhitespace(C)) {
745 900135 : if (!Token.empty())
746 1800270 : NewArgv.push_back(Saver.save(StringRef(Token)).data());
747 : Token.clear();
748 900135 : continue;
749 : }
750 :
751 : // This is a normal character. Append it.
752 1802000 : Token.push_back(C);
753 : }
754 :
755 : // Append the last token after hitting EOF with no whitespace.
756 81 : if (!Token.empty())
757 118 : NewArgv.push_back(Saver.save(StringRef(Token)).data());
758 : // Mark the end of response files
759 81 : if (MarkEOLs)
760 0 : NewArgv.push_back(nullptr);
761 81 : }
762 :
763 : /// Backslashes are interpreted in a rather complicated way in the Windows-style
764 : /// command line, because backslashes are used both to separate path and to
765 : /// escape double quote. This method consumes runs of backslashes as well as the
766 : /// following double quote if it's escaped.
767 : ///
768 : /// * If an even number of backslashes is followed by a double quote, one
769 : /// backslash is output for every pair of backslashes, and the last double
770 : /// quote remains unconsumed. The double quote will later be interpreted as
771 : /// the start or end of a quoted string in the main loop outside of this
772 : /// function.
773 : ///
774 : /// * If an odd number of backslashes is followed by a double quote, one
775 : /// backslash is output for every pair of backslashes, and a double quote is
776 : /// output for the last pair of backslash-double quote. The double quote is
777 : /// consumed in this case.
778 : ///
779 : /// * Otherwise, backslashes are interpreted literally.
780 21 : static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) {
781 : size_t E = Src.size();
782 : int BackslashCount = 0;
783 : // Skip the backslashes.
784 : do {
785 25 : ++I;
786 25 : ++BackslashCount;
787 25 : } while (I != E && Src[I] == '\\');
788 :
789 21 : bool FollowedByDoubleQuote = (I != E && Src[I] == '"');
790 : if (FollowedByDoubleQuote) {
791 6 : Token.append(BackslashCount / 2, '\\');
792 6 : if (BackslashCount % 2 == 0)
793 : return I - 1;
794 5 : Token.push_back('"');
795 5 : return I;
796 : }
797 15 : Token.append(BackslashCount, '\\');
798 15 : return I - 1;
799 : }
800 :
801 169 : void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver,
802 : SmallVectorImpl<const char *> &NewArgv,
803 : bool MarkEOLs) {
804 : SmallString<128> Token;
805 :
806 : // This is a small state machine to consume characters until it reaches the
807 : // end of the source string.
808 : enum { INIT, UNQUOTED, QUOTED } State = INIT;
809 5720 : for (size_t I = 0, E = Src.size(); I != E; ++I) {
810 5551 : char C = Src[I];
811 :
812 : // INIT state indicates that the current input index is at the start of
813 : // the string or between tokens.
814 5551 : if (State == INIT) {
815 : if (isWhitespaceOrNull(C)) {
816 : // Mark the end of lines in response files
817 6 : if (MarkEOLs && C == '\n')
818 0 : NewArgv.push_back(nullptr);
819 4876 : continue;
820 : }
821 275 : if (C == '"') {
822 : State = QUOTED;
823 : continue;
824 : }
825 271 : if (C == '\\') {
826 1 : I = parseBackslash(Src, I, Token);
827 : State = UNQUOTED;
828 1 : continue;
829 : }
830 270 : Token.push_back(C);
831 : State = UNQUOTED;
832 270 : continue;
833 : }
834 :
835 : // UNQUOTED state means that it's reading a token not quoted by double
836 : // quotes.
837 5270 : if (State == UNQUOTED) {
838 : // Whitespace means the end of the token.
839 : if (isWhitespaceOrNull(C)) {
840 380 : NewArgv.push_back(Saver.save(StringRef(Token)).data());
841 : Token.clear();
842 : State = INIT;
843 : // Mark the end of lines in response files
844 190 : if (MarkEOLs && C == '\n')
845 2 : NewArgv.push_back(nullptr);
846 190 : continue;
847 : }
848 4309 : if (C == '"') {
849 : State = QUOTED;
850 : continue;
851 : }
852 4218 : if (C == '\\') {
853 19 : I = parseBackslash(Src, I, Token);
854 19 : continue;
855 : }
856 4199 : Token.push_back(C);
857 4199 : continue;
858 : }
859 :
860 : // QUOTED state means that it's reading a token quoted by double quotes.
861 771 : if (State == QUOTED) {
862 771 : if (C == '"') {
863 : State = UNQUOTED;
864 : continue;
865 : }
866 676 : if (C == '\\') {
867 1 : I = parseBackslash(Src, I, Token);
868 1 : continue;
869 : }
870 675 : Token.push_back(C);
871 : }
872 : }
873 : // Append the last token after hitting EOF with no whitespace.
874 169 : if (!Token.empty())
875 170 : NewArgv.push_back(Saver.save(StringRef(Token)).data());
876 : // Mark the end of response files
877 169 : if (MarkEOLs)
878 2 : NewArgv.push_back(nullptr);
879 169 : }
880 :
881 49 : void cl::tokenizeConfigFile(StringRef Source, StringSaver &Saver,
882 : SmallVectorImpl<const char *> &NewArgv,
883 : bool MarkEOLs) {
884 186 : for (const char *Cur = Source.begin(); Cur != Source.end();) {
885 : SmallString<128> Line;
886 : // Check for comment line.
887 137 : if (isWhitespace(*Cur)) {
888 170 : while (Cur != Source.end() && isWhitespace(*Cur))
889 105 : ++Cur;
890 65 : continue;
891 : }
892 72 : if (*Cur == '#') {
893 340 : while (Cur != Source.end() && *Cur != '\n')
894 326 : ++Cur;
895 14 : continue;
896 : }
897 : // Find end of the current line.
898 : const char *Start = Cur;
899 765 : for (const char *End = Source.end(); Cur != End; ++Cur) {
900 754 : if (*Cur == '\\') {
901 12 : if (Cur + 1 != End) {
902 : ++Cur;
903 10 : if (*Cur == '\n' ||
904 4 : (*Cur == '\r' && (Cur + 1 != End) && Cur[1] == '\n')) {
905 : Line.append(Start, Cur - 1);
906 9 : if (*Cur == '\r')
907 4 : ++Cur;
908 9 : Start = Cur + 1;
909 : }
910 : }
911 742 : } else if (*Cur == '\n')
912 : break;
913 : }
914 : // Tokenize line.
915 : Line.append(Start, Cur);
916 116 : cl::TokenizeGNUCommandLine(Line, Saver, NewArgv, MarkEOLs);
917 : }
918 49 : }
919 :
920 : // It is called byte order marker but the UTF-8 BOM is actually not affected
921 : // by the host system's endianness.
922 : static bool hasUTF8ByteOrderMark(ArrayRef<char> S) {
923 66 : return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
924 : }
925 :
926 68 : static bool ExpandResponseFile(StringRef FName, StringSaver &Saver,
927 : TokenizerCallback Tokenizer,
928 : SmallVectorImpl<const char *> &NewArgv,
929 : bool MarkEOLs, bool RelativeNames) {
930 : ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
931 68 : MemoryBuffer::getFile(FName);
932 68 : if (!MemBufOrErr)
933 : return false;
934 : MemoryBuffer &MemBuf = *MemBufOrErr.get();
935 67 : StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
936 :
937 : // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing.
938 : ArrayRef<char> BufRef(MemBuf.getBufferStart(), MemBuf.getBufferEnd());
939 : std::string UTF8Buf;
940 67 : if (hasUTF16ByteOrderMark(BufRef)) {
941 1 : if (!convertUTF16ToUTF8String(BufRef, UTF8Buf))
942 : return false;
943 1 : Str = StringRef(UTF8Buf);
944 : }
945 : // If we see UTF-8 BOM sequence at the beginning of a file, we shall remove
946 : // these bytes before parsing.
947 : // Reference: http://en.wikipedia.org/wiki/UTF-8#Byte_order_mark
948 : else if (hasUTF8ByteOrderMark(BufRef))
949 1 : Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);
950 :
951 : // Tokenize the contents into NewArgv.
952 67 : Tokenizer(Str, Saver, NewArgv, MarkEOLs);
953 :
954 : // If names of nested response files should be resolved relative to including
955 : // file, replace the included response file names with their full paths
956 : // obtained by required resolution.
957 67 : if (RelativeNames)
958 107 : for (unsigned I = 0; I < NewArgv.size(); ++I)
959 67 : if (NewArgv[I]) {
960 : StringRef Arg = NewArgv[I];
961 67 : if (Arg.front() == '@') {
962 7 : StringRef FileName = Arg.drop_front();
963 7 : if (llvm::sys::path::is_relative(FileName)) {
964 : SmallString<128> ResponseFile;
965 7 : ResponseFile.append(1, '@');
966 7 : if (llvm::sys::path::is_relative(FName)) {
967 : SmallString<128> curr_dir;
968 0 : llvm::sys::fs::current_path(curr_dir);
969 : ResponseFile.append(curr_dir.str());
970 : }
971 7 : llvm::sys::path::append(
972 14 : ResponseFile, llvm::sys::path::parent_path(FName), FileName);
973 7 : NewArgv[I] = Saver.save(ResponseFile.c_str()).data();
974 : }
975 : }
976 : }
977 :
978 : return true;
979 : }
980 :
981 : /// Expand response files on a command line recursively using the given
982 : /// StringSaver and tokenization strategy.
983 189410 : bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
984 : SmallVectorImpl<const char *> &Argv,
985 : bool MarkEOLs, bool RelativeNames) {
986 : unsigned RspFiles = 0;
987 : bool AllExpanded = true;
988 :
989 : // Don't cache Argv.size() because it can change.
990 2986850 : for (unsigned I = 0; I != Argv.size();) {
991 2797440 : const char *Arg = Argv[I];
992 : // Check if it is an EOL marker
993 2797440 : if (Arg == nullptr) {
994 4 : ++I;
995 2797405 : continue;
996 : }
997 2797436 : if (Arg[0] != '@') {
998 2797400 : ++I;
999 2797400 : continue;
1000 : }
1001 :
1002 : // If we have too many response files, leave some unexpanded. This avoids
1003 : // crashing on self-referential response files.
1004 36 : if (RspFiles++ > 20)
1005 0 : return false;
1006 :
1007 : // Replace this response file argument with the tokenization of its
1008 : // contents. Nested response files are expanded in subsequent iterations.
1009 : SmallVector<const char *, 0> ExpandedArgv;
1010 72 : if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv,
1011 : MarkEOLs, RelativeNames)) {
1012 : // We couldn't read this file, so we leave it in the argument stream and
1013 : // move on.
1014 : AllExpanded = false;
1015 1 : ++I;
1016 : continue;
1017 : }
1018 35 : Argv.erase(Argv.begin() + I);
1019 35 : Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end());
1020 : }
1021 : return AllExpanded;
1022 : }
1023 :
1024 32 : bool cl::readConfigFile(StringRef CfgFile, StringSaver &Saver,
1025 : SmallVectorImpl<const char *> &Argv) {
1026 32 : if (!ExpandResponseFile(CfgFile, Saver, cl::tokenizeConfigFile, Argv,
1027 : /*MarkEOLs*/ false, /*RelativeNames*/ true))
1028 : return false;
1029 32 : return ExpandResponseFiles(Saver, cl::tokenizeConfigFile, Argv,
1030 32 : /*MarkEOLs*/ false, /*RelativeNames*/ true);
1031 : }
1032 :
1033 : /// ParseEnvironmentOptions - An alternative entry point to the
1034 : /// CommandLine library, which allows you to read the program's name
1035 : /// from the caller (as PROGNAME) and its command-line arguments from
1036 : /// an environment variable (whose name is given in ENVVAR).
1037 : ///
1038 2 : void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
1039 : const char *Overview) {
1040 : // Check args.
1041 : assert(progName && "Program name not specified");
1042 : assert(envVar && "Environment variable name missing");
1043 :
1044 : // Get the environment variable they want us to parse options out of.
1045 2 : llvm::Optional<std::string> envValue = sys::Process::GetEnv(StringRef(envVar));
1046 2 : if (!envValue)
1047 : return;
1048 :
1049 : // Get program's "name", which we wouldn't know without the caller
1050 : // telling us.
1051 : SmallVector<const char *, 20> newArgv;
1052 2 : BumpPtrAllocator A;
1053 : StringSaver Saver(A);
1054 2 : newArgv.push_back(Saver.save(progName).data());
1055 :
1056 : // Parse the value of the environment variable into a "command line"
1057 : // and hand it off to ParseCommandLineOptions().
1058 2 : TokenizeGNUCommandLine(*envValue, Saver, newArgv);
1059 2 : int newArgc = static_cast<int>(newArgv.size());
1060 2 : ParseCommandLineOptions(newArgc, &newArgv[0], StringRef(Overview));
1061 : }
1062 :
1063 137763 : bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
1064 : StringRef Overview, raw_ostream *Errs) {
1065 137763 : return GlobalParser->ParseCommandLineOptions(argc, argv, Overview,
1066 137743 : Errs);
1067 : }
1068 :
1069 669 : void CommandLineParser::ResetAllOptionOccurrences() {
1070 : // So that we can parse different command lines multiple times in succession
1071 : // we reset all option values to look like they have never been seen before.
1072 2066 : for (auto SC : RegisteredSubCommands) {
1073 835646 : for (auto &O : SC->OptionsMap)
1074 832852 : O.second->reset();
1075 : }
1076 669 : }
1077 :
1078 137763 : bool CommandLineParser::ParseCommandLineOptions(int argc,
1079 : const char *const *argv,
1080 : StringRef Overview,
1081 : raw_ostream *Errs) {
1082 : assert(hasOptions() && "No options specified!");
1083 :
1084 : // Expand response files.
1085 137763 : SmallVector<const char *, 20> newArgv(argv, argv + argc);
1086 137743 : BumpPtrAllocator A;
1087 : StringSaver Saver(A);
1088 275526 : ExpandResponseFiles(Saver,
1089 413289 : Triple(sys::getProcessTriple()).isOSWindows() ?
1090 : cl::TokenizeWindowsCommandLine : cl::TokenizeGNUCommandLine,
1091 : newArgv);
1092 : argv = &newArgv[0];
1093 137763 : argc = static_cast<int>(newArgv.size());
1094 :
1095 : // Copy the program name into ProgName, making sure not to overflow it.
1096 413289 : ProgramName = sys::path::filename(StringRef(argv[0]));
1097 :
1098 137763 : ProgramOverview = Overview;
1099 : bool IgnoreErrors = Errs;
1100 137763 : if (!Errs)
1101 137080 : Errs = &errs();
1102 137763 : bool ErrorParsing = false;
1103 :
1104 : // Check out the positional arguments to collect information about them.
1105 : unsigned NumPositionalRequired = 0;
1106 :
1107 : // Determine whether or not there are an unlimited number of positionals
1108 : bool HasUnlimitedPositionals = false;
1109 :
1110 : int FirstArg = 1;
1111 137763 : SubCommand *ChosenSubCommand = &*TopLevelSubCommand;
1112 137763 : if (argc >= 2 && argv[FirstArg][0] != '-') {
1113 : // If the first argument specifies a valid subcommand, start processing
1114 : // options from the second argument.
1115 47708 : ChosenSubCommand = LookupSubCommand(StringRef(argv[FirstArg]));
1116 47708 : if (ChosenSubCommand != &*TopLevelSubCommand)
1117 : FirstArg = 2;
1118 : }
1119 137763 : GlobalParser->ActiveSubCommand = ChosenSubCommand;
1120 :
1121 : assert(ChosenSubCommand);
1122 : auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
1123 : auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
1124 : auto &SinkOpts = ChosenSubCommand->SinkOpts;
1125 137763 : auto &OptionsMap = ChosenSubCommand->OptionsMap;
1126 :
1127 : if (ConsumeAfterOpt) {
1128 : assert(PositionalOpts.size() > 0 &&
1129 : "Cannot specify cl::ConsumeAfter without a positional argument!");
1130 : }
1131 137763 : if (!PositionalOpts.empty()) {
1132 :
1133 : // Calculate how many positional values are _required_.
1134 : bool UnboundedFound = false;
1135 230704 : for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
1136 115635 : Option *Opt = PositionalOpts[i];
1137 : if (RequiresValue(Opt))
1138 62463 : ++NumPositionalRequired;
1139 53172 : else if (ConsumeAfterOpt) {
1140 : // ConsumeAfter cannot be combined with "optional" positional options
1141 : // unless there is only one positional argument...
1142 217 : if (PositionalOpts.size() > 1) {
1143 0 : if (!IgnoreErrors)
1144 0 : Opt->error("error - this positional option will never be matched, "
1145 : "because it does not Require a value, and a "
1146 0 : "cl::ConsumeAfter option is active!");
1147 0 : ErrorParsing = true;
1148 : }
1149 52955 : } else if (UnboundedFound && !Opt->hasArgStr()) {
1150 : // This option does not "require" a value... Make sure this option is
1151 : // not specified after an option that eats all extra arguments, or this
1152 : // one will never get any!
1153 : //
1154 0 : if (!IgnoreErrors)
1155 0 : Opt->error("error - option can never match, because "
1156 : "another positional argument will match an "
1157 : "unbounded number of values, and this option"
1158 0 : " does not require a value!");
1159 0 : *Errs << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr
1160 0 : << "' is all messed up!\n";
1161 0 : *Errs << PositionalOpts.size();
1162 0 : ErrorParsing = true;
1163 : }
1164 115635 : UnboundedFound |= EatsUnboundedNumberOfValues(Opt);
1165 : }
1166 115069 : HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
1167 : }
1168 :
1169 : // PositionalVals - A vector of "positional" arguments we accumulate into
1170 : // the process at the end.
1171 : //
1172 : SmallVector<std::pair<StringRef, unsigned>, 4> PositionalVals;
1173 :
1174 : // If the program has named positional arguments, and the name has been run
1175 : // across, keep track of which positional argument was named. Otherwise put
1176 : // the positional args into the PositionalVals list...
1177 : Option *ActivePositionalArg = nullptr;
1178 :
1179 : // Loop over all of the arguments... processing them.
1180 : bool DashDashFound = false; // Have we read '--'?
1181 415198 : for (int i = FirstArg; i < argc; ++i) {
1182 : Option *Handler = nullptr;
1183 : Option *NearestHandler = nullptr;
1184 : std::string NearestHandlerString;
1185 277670 : StringRef Value;
1186 : StringRef ArgName = "";
1187 :
1188 : // Check to see if this is a positional argument. This argument is
1189 : // considered to be positional if it doesn't start with '-', if it is "-"
1190 : // itself, or if we have seen "--" already.
1191 : //
1192 277670 : if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
1193 : // Positional argument!
1194 82559 : if (ActivePositionalArg) {
1195 4 : ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i);
1196 4 : continue; // We are done!
1197 : }
1198 :
1199 82555 : if (!PositionalOpts.empty()) {
1200 82555 : PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));
1201 :
1202 : // All of the positional arguments have been fulfulled, give the rest to
1203 : // the consume after option... if it's specified...
1204 : //
1205 82555 : if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {
1206 289 : for (++i; i < argc; ++i)
1207 134 : PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));
1208 : break; // Handle outside of the argument processing loop...
1209 : }
1210 :
1211 : // Delay processing positional arguments until the end...
1212 : continue;
1213 : }
1214 195111 : } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
1215 : !DashDashFound) {
1216 : DashDashFound = true; // This is the mythical "--"?
1217 : continue; // Don't try to process it as an argument itself.
1218 195111 : } else if (ActivePositionalArg &&
1219 : (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) {
1220 : // If there is a positional argument eating options, check to see if this
1221 : // option is another positional argument. If so, treat it as an argument,
1222 : // otherwise feed it to the eating positional.
1223 4 : ArgName = StringRef(argv[i] + 1);
1224 : // Eat leading dashes.
1225 2 : while (!ArgName.empty() && ArgName[0] == '-')
1226 0 : ArgName = ArgName.substr(1);
1227 :
1228 2 : Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
1229 2 : if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
1230 2 : ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i);
1231 2 : continue; // We are done!
1232 : }
1233 :
1234 : } else { // We start with a '-', must be an argument.
1235 390218 : ArgName = StringRef(argv[i] + 1);
1236 : // Eat leading dashes.
1237 222895 : while (!ArgName.empty() && ArgName[0] == '-')
1238 27786 : ArgName = ArgName.substr(1);
1239 :
1240 195109 : Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
1241 :
1242 : // Check to see if this "option" is really a prefixed or grouped argument.
1243 195109 : if (!Handler)
1244 2476 : Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing,
1245 : OptionsMap);
1246 :
1247 : // Otherwise, look for the closest available option to report to the user
1248 : // in the upcoming error.
1249 195109 : if (!Handler && SinkOpts.empty())
1250 : NearestHandler =
1251 14 : LookupNearestOption(ArgName, OptionsMap, NearestHandlerString);
1252 : }
1253 :
1254 195109 : if (!Handler) {
1255 14 : if (SinkOpts.empty()) {
1256 14 : *Errs << ProgramName << ": Unknown command line argument '" << argv[i]
1257 14 : << "'. Try: '" << argv[0] << " -help'\n";
1258 :
1259 14 : if (NearestHandler) {
1260 : // If we know a near match, report it as well.
1261 14 : *Errs << ProgramName << ": Did you mean '-" << NearestHandlerString
1262 14 : << "'?\n";
1263 : }
1264 :
1265 14 : ErrorParsing = true;
1266 : } else {
1267 0 : for (SmallVectorImpl<Option *>::iterator I = SinkOpts.begin(),
1268 : E = SinkOpts.end();
1269 0 : I != E; ++I)
1270 0 : (*I)->addOccurrence(i, "", StringRef(argv[i]));
1271 : }
1272 14 : continue;
1273 : }
1274 :
1275 : // If this is a named positional argument, just remember that it is the
1276 : // active one...
1277 195095 : if (Handler->getFormattingFlag() == cl::Positional) {
1278 6 : if ((Handler->getMiscFlags() & PositionalEatsArgs) && !Value.empty()) {
1279 2 : Handler->error("This argument does not take a value.\n"
1280 : "\tInstead, it consumes any positional arguments until "
1281 : "the next recognized option.", *Errs);
1282 2 : ErrorParsing = true;
1283 : }
1284 : ActivePositionalArg = Handler;
1285 : }
1286 : else
1287 195089 : ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
1288 : }
1289 :
1290 : // Check and handle positional arguments now...
1291 137750 : if (NumPositionalRequired > PositionalVals.size()) {
1292 : *Errs << ProgramName
1293 0 : << ": Not enough positional command line arguments specified!\n"
1294 0 : << "Must specify at least " << NumPositionalRequired
1295 0 : << " positional argument" << (NumPositionalRequired > 1 ? "s" : "")
1296 0 : << ": See: " << argv[0] << " -help\n";
1297 :
1298 0 : ErrorParsing = true;
1299 137750 : } else if (!HasUnlimitedPositionals &&
1300 128543 : PositionalVals.size() > PositionalOpts.size()) {
1301 0 : *Errs << ProgramName << ": Too many positional arguments specified!\n"
1302 0 : << "Can specify at most " << PositionalOpts.size()
1303 0 : << " positional arguments: See: " << argv[0] << " -help\n";
1304 0 : ErrorParsing = true;
1305 :
1306 137750 : } else if (!ConsumeAfterOpt) {
1307 : // Positional args have already been handled if ConsumeAfter is specified.
1308 : unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());
1309 252922 : for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
1310 115397 : if (RequiresValue(PositionalOpts[i])) {
1311 124906 : ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
1312 124906 : PositionalVals[ValNo].second);
1313 62453 : ValNo++;
1314 62453 : --NumPositionalRequired; // We fulfilled our duty...
1315 : }
1316 :
1317 : // If we _can_ give this option more arguments, do so now, as long as we
1318 : // do not give it values that others need. 'Done' controls whether the
1319 : // option even _WANTS_ any more.
1320 : //
1321 230794 : bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
1322 135277 : while (NumVals - ValNo > NumPositionalRequired && !Done) {
1323 39760 : switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
1324 12349 : case cl::Optional:
1325 : Done = true; // Optional arguments want _at most_ one value
1326 : LLVM_FALLTHROUGH;
1327 19880 : case cl::ZeroOrMore: // Zero or more will take all they can get...
1328 : case cl::OneOrMore: // One or more will take all they can get...
1329 39760 : ProvidePositionalOption(PositionalOpts[i],
1330 : PositionalVals[ValNo].first,
1331 39760 : PositionalVals[ValNo].second);
1332 19880 : ValNo++;
1333 : break;
1334 0 : default:
1335 0 : llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
1336 : "positional argument processing!");
1337 : }
1338 : }
1339 : }
1340 : } else {
1341 : assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
1342 : unsigned ValNo = 0;
1343 225 : for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j)
1344 0 : if (RequiresValue(PositionalOpts[j])) {
1345 0 : ErrorParsing |= ProvidePositionalOption(PositionalOpts[j],
1346 : PositionalVals[ValNo].first,
1347 0 : PositionalVals[ValNo].second);
1348 0 : ValNo++;
1349 : }
1350 :
1351 : // Handle the case where there is just one positional option, and it's
1352 : // optional. In this case, we want to give JUST THE FIRST option to the
1353 : // positional option and keep the rest for the consume after. The above
1354 : // loop would have assigned no values to positional options in this case.
1355 : //
1356 225 : if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) {
1357 222 : ErrorParsing |= ProvidePositionalOption(PositionalOpts[0],
1358 : PositionalVals[ValNo].first,
1359 222 : PositionalVals[ValNo].second);
1360 : ValNo++;
1361 : }
1362 :
1363 : // Handle over all of the rest of the arguments to the
1364 : // cl::ConsumeAfter command line option...
1365 292 : for (; ValNo != PositionalVals.size(); ++ValNo)
1366 67 : ErrorParsing |=
1367 67 : ProvidePositionalOption(ConsumeAfterOpt, PositionalVals[ValNo].first,
1368 67 : PositionalVals[ValNo].second);
1369 : }
1370 :
1371 : // Loop over args and make sure all required args are specified!
1372 107481168 : for (const auto &Opt : OptionsMap) {
1373 214411336 : switch (Opt.second->getNumOccurrencesFlag()) {
1374 956 : case Required:
1375 : case OneOrMore:
1376 956 : if (Opt.second->getNumOccurrences() == 0) {
1377 4 : Opt.second->error("must be specified at least once!");
1378 4 : ErrorParsing = true;
1379 : }
1380 : LLVM_FALLTHROUGH;
1381 : default:
1382 : break;
1383 : }
1384 : }
1385 :
1386 : // Now that we know if -debug is specified, we can use it.
1387 : // Note that if ReadResponseFiles == true, this must be done before the
1388 : // memory allocated for the expanded command line is free()d below.
1389 : LLVM_DEBUG(dbgs() << "Args: ";
1390 : for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' ';
1391 : dbgs() << '\n';);
1392 :
1393 : // Free all of the memory allocated to the map. Command line options may only
1394 : // be processed once!
1395 : MoreHelp.clear();
1396 :
1397 : // If we had an error processing our arguments, don't let the program execute
1398 137750 : if (ErrorParsing) {
1399 18 : if (!IgnoreErrors)
1400 7 : exit(1);
1401 : return false;
1402 : }
1403 : return true;
1404 : }
1405 :
1406 : //===----------------------------------------------------------------------===//
1407 : // Option Base class implementation
1408 : //
1409 :
1410 7 : bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) {
1411 7 : if (!ArgName.data())
1412 7 : ArgName = ArgStr;
1413 7 : if (ArgName.empty())
1414 0 : Errs << HelpStr; // Be nice for positional arguments
1415 : else
1416 7 : Errs << GlobalParser->ProgramName << ": for the -" << ArgName;
1417 :
1418 14 : Errs << " option: " << Message << "\n";
1419 7 : return true;
1420 : }
1421 :
1422 286860 : bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value,
1423 : bool MultiArg) {
1424 286860 : if (!MultiArg)
1425 286860 : NumOccurrences++; // Increment the number of times we have been seen
1426 :
1427 286860 : switch (getNumOccurrencesFlag()) {
1428 118531 : case Optional:
1429 118531 : if (NumOccurrences > 1)
1430 0 : return error("may only occur zero or one times!", ArgName);
1431 : break;
1432 62064 : case Required:
1433 62064 : if (NumOccurrences > 1)
1434 0 : return error("must occur exactly one time!", ArgName);
1435 : LLVM_FALLTHROUGH;
1436 : case OneOrMore:
1437 : case ZeroOrMore:
1438 : case ConsumeAfter:
1439 : break;
1440 : }
1441 :
1442 286860 : return handleOccurrence(pos, ArgName, Value);
1443 : }
1444 :
1445 : // getValueStr - Get the value description string, using "DefaultMsg" if nothing
1446 : // has been specified yet.
1447 : //
1448 : static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
1449 1701 : if (O.ValueStr.empty())
1450 : return DefaultMsg;
1451 84 : return O.ValueStr;
1452 : }
1453 :
1454 : //===----------------------------------------------------------------------===//
1455 : // cl::alias class implementation
1456 : //
1457 :
1458 : // Return the width of the option tag for printing...
1459 6 : size_t alias::getOptionWidth() const { return ArgStr.size() + 6; }
1460 :
1461 1778 : void Option::printHelpStr(StringRef HelpStr, size_t Indent,
1462 : size_t FirstLineIndentedBy) {
1463 1778 : std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
1464 1778 : outs().indent(Indent - FirstLineIndentedBy) << " - " << Split.first << "\n";
1465 1962 : while (!Split.second.empty()) {
1466 184 : Split = Split.second.split('\n');
1467 184 : outs().indent(Indent) << Split.first << "\n";
1468 : }
1469 1778 : }
1470 :
1471 : // Print out the option for the alias.
1472 3 : void alias::printOptionInfo(size_t GlobalWidth) const {
1473 3 : outs() << " -" << ArgStr;
1474 3 : printHelpStr(HelpStr, GlobalWidth, ArgStr.size() + 6);
1475 3 : }
1476 :
1477 : //===----------------------------------------------------------------------===//
1478 : // Parser Implementation code...
1479 : //
1480 :
1481 : // basic_parser implementation
1482 : //
1483 :
1484 : // Return the width of the option tag for printing...
1485 3397 : size_t basic_parser_impl::getOptionWidth(const Option &O) const {
1486 : size_t Len = O.ArgStr.size();
1487 3397 : auto ValName = getValueName();
1488 3397 : if (!ValName.empty()) {
1489 : size_t FormattingLen = 3;
1490 1169 : if (O.getMiscFlags() & PositionalEatsArgs)
1491 : FormattingLen = 6;
1492 1169 : Len += getValueStr(O, ValName).size() + FormattingLen;
1493 : }
1494 :
1495 3397 : return Len + 6;
1496 : }
1497 :
1498 : // printOptionInfo - Print out information about this option. The
1499 : // to-be-maintained width is specified.
1500 : //
1501 1646 : void basic_parser_impl::printOptionInfo(const Option &O,
1502 : size_t GlobalWidth) const {
1503 1646 : outs() << " -" << O.ArgStr;
1504 :
1505 1646 : auto ValName = getValueName();
1506 1646 : if (!ValName.empty()) {
1507 532 : if (O.getMiscFlags() & PositionalEatsArgs) {
1508 0 : outs() << " <" << getValueStr(O, ValName) << ">...";
1509 : } else {
1510 1064 : outs() << "=<" << getValueStr(O, ValName) << '>';
1511 : }
1512 : }
1513 :
1514 1646 : Option::printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
1515 1646 : }
1516 :
1517 0 : void basic_parser_impl::printOptionName(const Option &O,
1518 : size_t GlobalWidth) const {
1519 0 : outs() << " -" << O.ArgStr;
1520 0 : outs().indent(GlobalWidth - O.ArgStr.size());
1521 0 : }
1522 :
1523 : // parser<bool> implementation
1524 : //
1525 46367 : bool parser<bool>::parse(Option &O, StringRef ArgName, StringRef Arg,
1526 : bool &Value) {
1527 : if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1528 : Arg == "1") {
1529 44616 : Value = true;
1530 44616 : return false;
1531 : }
1532 :
1533 : if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1534 1751 : Value = false;
1535 1751 : return false;
1536 : }
1537 0 : return O.error("'" + Arg +
1538 0 : "' is invalid value for boolean argument! Try 0 or 1");
1539 : }
1540 :
1541 : // parser<boolOrDefault> implementation
1542 : //
1543 5840 : bool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, StringRef Arg,
1544 : boolOrDefault &Value) {
1545 : if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1546 : Arg == "1") {
1547 5538 : Value = BOU_TRUE;
1548 5538 : return false;
1549 : }
1550 : if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1551 302 : Value = BOU_FALSE;
1552 302 : return false;
1553 : }
1554 :
1555 0 : return O.error("'" + Arg +
1556 0 : "' is invalid value for boolean argument! Try 0 or 1");
1557 : }
1558 :
1559 : // parser<int> implementation
1560 : //
1561 1005 : bool parser<int>::parse(Option &O, StringRef ArgName, StringRef Arg,
1562 : int &Value) {
1563 1005 : if (Arg.getAsInteger(0, Value))
1564 0 : return O.error("'" + Arg + "' value invalid for integer argument!");
1565 : return false;
1566 : }
1567 :
1568 : // parser<unsigned> implementation
1569 : //
1570 1336 : bool parser<unsigned>::parse(Option &O, StringRef ArgName, StringRef Arg,
1571 : unsigned &Value) {
1572 :
1573 1336 : if (Arg.getAsInteger(0, Value))
1574 0 : return O.error("'" + Arg + "' value invalid for uint argument!");
1575 : return false;
1576 : }
1577 :
1578 : // parser<unsigned long long> implementation
1579 : //
1580 181 : bool parser<unsigned long long>::parse(Option &O, StringRef ArgName,
1581 : StringRef Arg,
1582 : unsigned long long &Value) {
1583 :
1584 180 : if (Arg.getAsInteger(0, Value))
1585 1 : return O.error("'" + Arg + "' value invalid for uint argument!");
1586 : return false;
1587 : }
1588 :
1589 : // parser<double>/parser<float> implementation
1590 : //
1591 15 : static bool parseDouble(Option &O, StringRef Arg, double &Value) {
1592 15 : if (to_float(Arg, Value))
1593 : return false;
1594 0 : return O.error("'" + Arg + "' value invalid for floating point argument!");
1595 : }
1596 :
1597 0 : bool parser<double>::parse(Option &O, StringRef ArgName, StringRef Arg,
1598 : double &Val) {
1599 0 : return parseDouble(O, Arg, Val);
1600 : }
1601 :
1602 15 : bool parser<float>::parse(Option &O, StringRef ArgName, StringRef Arg,
1603 : float &Val) {
1604 : double dVal;
1605 15 : if (parseDouble(O, Arg, dVal))
1606 : return true;
1607 15 : Val = (float)dVal;
1608 15 : return false;
1609 : }
1610 :
1611 : // generic_parser_base implementation
1612 : //
1613 :
1614 : // findOption - Return the option number corresponding to the specified
1615 : // argument string. If the option is not found, getNumOptions() is returned.
1616 : //
1617 54302512 : unsigned generic_parser_base::findOption(StringRef Name) {
1618 54302512 : unsigned e = getNumOptions();
1619 :
1620 8730947841 : for (unsigned i = 0; i != e; ++i) {
1621 8678126484 : if (getOption(i) == Name)
1622 1481155 : return i;
1623 : }
1624 : return e;
1625 : }
1626 :
1627 : // Return the width of the option tag for printing...
1628 73 : size_t generic_parser_base::getOptionWidth(const Option &O) const {
1629 73 : if (O.hasArgStr()) {
1630 71 : size_t Size = O.ArgStr.size() + 6;
1631 1040 : for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
1632 997 : Size = std::max(Size, getOption(i).size() + 8);
1633 71 : return Size;
1634 : } else {
1635 2 : size_t BaseSize = 0;
1636 7 : for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
1637 10 : BaseSize = std::max(BaseSize, getOption(i).size() + 8);
1638 2 : return BaseSize;
1639 : }
1640 : }
1641 :
1642 : // printOptionInfo - Print out information about this option. The
1643 : // to-be-maintained width is specified.
1644 : //
1645 73 : void generic_parser_base::printOptionInfo(const Option &O,
1646 : size_t GlobalWidth) const {
1647 73 : if (O.hasArgStr()) {
1648 71 : outs() << " -" << O.ArgStr;
1649 71 : Option::printHelpStr(O.HelpStr, GlobalWidth, O.ArgStr.size() + 6);
1650 :
1651 1040 : for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
1652 969 : size_t NumSpaces = GlobalWidth - getOption(i).size() - 8;
1653 969 : outs() << " =" << getOption(i);
1654 969 : outs().indent(NumSpaces) << " - " << getDescription(i) << '\n';
1655 : }
1656 : } else {
1657 2 : if (!O.HelpStr.empty())
1658 2 : outs() << " " << O.HelpStr << '\n';
1659 7 : for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
1660 5 : auto Option = getOption(i);
1661 5 : outs() << " -" << Option;
1662 5 : Option::printHelpStr(getDescription(i), GlobalWidth, Option.size() + 8);
1663 : }
1664 : }
1665 73 : }
1666 :
1667 : static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff
1668 :
1669 : // printGenericOptionDiff - Print the value of this option and it's default.
1670 : //
1671 : // "Generic" options have each value mapped to a name.
1672 0 : void generic_parser_base::printGenericOptionDiff(
1673 : const Option &O, const GenericOptionValue &Value,
1674 : const GenericOptionValue &Default, size_t GlobalWidth) const {
1675 0 : outs() << " -" << O.ArgStr;
1676 0 : outs().indent(GlobalWidth - O.ArgStr.size());
1677 :
1678 0 : unsigned NumOpts = getNumOptions();
1679 0 : for (unsigned i = 0; i != NumOpts; ++i) {
1680 0 : if (Value.compare(getOptionValue(i)))
1681 : continue;
1682 :
1683 0 : outs() << "= " << getOption(i);
1684 0 : size_t L = getOption(i).size();
1685 0 : size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0;
1686 0 : outs().indent(NumSpaces) << " (default: ";
1687 0 : for (unsigned j = 0; j != NumOpts; ++j) {
1688 0 : if (Default.compare(getOptionValue(j)))
1689 : continue;
1690 0 : outs() << getOption(j);
1691 0 : break;
1692 : }
1693 0 : outs() << ")\n";
1694 0 : return;
1695 : }
1696 0 : outs() << "= *unknown option value*\n";
1697 : }
1698 :
1699 : // printOptionDiff - Specializations for printing basic value types.
1700 : //
1701 : #define PRINT_OPT_DIFF(T) \
1702 : void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \
1703 : size_t GlobalWidth) const { \
1704 : printOptionName(O, GlobalWidth); \
1705 : std::string Str; \
1706 : { \
1707 : raw_string_ostream SS(Str); \
1708 : SS << V; \
1709 : } \
1710 : outs() << "= " << Str; \
1711 : size_t NumSpaces = \
1712 : MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \
1713 : outs().indent(NumSpaces) << " (default: "; \
1714 : if (D.hasValue()) \
1715 : outs() << D.getValue(); \
1716 : else \
1717 : outs() << "*no default*"; \
1718 : outs() << ")\n"; \
1719 : }
1720 :
1721 0 : PRINT_OPT_DIFF(bool)
1722 0 : PRINT_OPT_DIFF(boolOrDefault)
1723 0 : PRINT_OPT_DIFF(int)
1724 0 : PRINT_OPT_DIFF(unsigned)
1725 0 : PRINT_OPT_DIFF(unsigned long long)
1726 0 : PRINT_OPT_DIFF(double)
1727 0 : PRINT_OPT_DIFF(float)
1728 0 : PRINT_OPT_DIFF(char)
1729 :
1730 0 : void parser<std::string>::printOptionDiff(const Option &O, StringRef V,
1731 : const OptionValue<std::string> &D,
1732 : size_t GlobalWidth) const {
1733 0 : printOptionName(O, GlobalWidth);
1734 0 : outs() << "= " << V;
1735 0 : size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;
1736 0 : outs().indent(NumSpaces) << " (default: ";
1737 0 : if (D.hasValue())
1738 0 : outs() << D.getValue();
1739 : else
1740 0 : outs() << "*no default*";
1741 0 : outs() << ")\n";
1742 0 : }
1743 :
1744 : // Print a placeholder for options that don't yet support printOptionDiff().
1745 0 : void basic_parser_impl::printOptionNoValue(const Option &O,
1746 : size_t GlobalWidth) const {
1747 0 : printOptionName(O, GlobalWidth);
1748 0 : outs() << "= *cannot print option value*\n";
1749 0 : }
1750 :
1751 : //===----------------------------------------------------------------------===//
1752 : // -help and -help-hidden option implementation
1753 : //
1754 :
1755 13938 : static int OptNameCompare(const std::pair<const char *, Option *> *LHS,
1756 : const std::pair<const char *, Option *> *RHS) {
1757 13938 : return strcmp(LHS->first, RHS->first);
1758 : }
1759 :
1760 12 : static int SubNameCompare(const std::pair<const char *, SubCommand *> *LHS,
1761 : const std::pair<const char *, SubCommand *> *RHS) {
1762 12 : return strcmp(LHS->first, RHS->first);
1763 : }
1764 :
1765 : // Copy Options into a vector so we can sort them as we like.
1766 11 : static void sortOpts(StringMap<Option *> &OptMap,
1767 : SmallVectorImpl<std::pair<const char *, Option *>> &Opts,
1768 : bool ShowHidden) {
1769 : SmallPtrSet<Option *, 32> OptionSet; // Duplicate option detection.
1770 :
1771 11 : for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end();
1772 14011 : I != E; ++I) {
1773 : // Ignore really-hidden options.
1774 28000 : if (I->second->getOptionHiddenFlag() == ReallyHidden)
1775 : continue;
1776 :
1777 : // Unless showhidden is set, ignore hidden flags.
1778 6417 : if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)
1779 : continue;
1780 :
1781 : // If we've already seen this option, don't add it to the list again.
1782 1778 : if (!OptionSet.insert(I->second).second)
1783 : continue;
1784 :
1785 3550 : Opts.push_back(
1786 1775 : std::pair<const char *, Option *>(I->getKey().data(), I->second));
1787 : }
1788 :
1789 : // Sort the options list alphabetically.
1790 : array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare);
1791 11 : }
1792 :
1793 : static void
1794 11 : sortSubCommands(const SmallPtrSetImpl<SubCommand *> &SubMap,
1795 : SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) {
1796 40 : for (const auto &S : SubMap) {
1797 29 : if (S->getName().empty())
1798 : continue;
1799 7 : Subs.push_back(std::make_pair(S->getName().data(), S));
1800 : }
1801 : array_pod_sort(Subs.begin(), Subs.end(), SubNameCompare);
1802 11 : }
1803 :
1804 : namespace {
1805 :
1806 : class HelpPrinter {
1807 : protected:
1808 : const bool ShowHidden;
1809 : typedef SmallVector<std::pair<const char *, Option *>, 128>
1810 : StrOptionPairVector;
1811 : typedef SmallVector<std::pair<const char *, SubCommand *>, 128>
1812 : StrSubCommandPairVector;
1813 : // Print the options. Opts is assumed to be alphabetically sorted.
1814 0 : virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
1815 0 : for (size_t i = 0, e = Opts.size(); i != e; ++i)
1816 0 : Opts[i].second->printOptionInfo(MaxArgLen);
1817 0 : }
1818 :
1819 0 : void printSubCommands(StrSubCommandPairVector &Subs, size_t MaxSubLen) {
1820 0 : for (const auto &S : Subs) {
1821 0 : outs() << " " << S.first;
1822 0 : if (!S.second->getDescription().empty()) {
1823 0 : outs().indent(MaxSubLen - strlen(S.first));
1824 0 : outs() << " - " << S.second->getDescription();
1825 : }
1826 0 : outs() << "\n";
1827 : }
1828 0 : }
1829 :
1830 : public:
1831 : explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
1832 362444 : virtual ~HelpPrinter() {}
1833 :
1834 : // Invoke the printer.
1835 : void operator=(bool Value) {
1836 0 : if (!Value)
1837 : return;
1838 0 : printHelp();
1839 :
1840 : // Halt the program since help information was printed
1841 8 : exit(0);
1842 : }
1843 :
1844 11 : void printHelp() {
1845 11 : SubCommand *Sub = GlobalParser->getActiveSubCommand();
1846 11 : auto &OptionsMap = Sub->OptionsMap;
1847 : auto &PositionalOpts = Sub->PositionalOpts;
1848 : auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;
1849 :
1850 : StrOptionPairVector Opts;
1851 11 : sortOpts(OptionsMap, Opts, ShowHidden);
1852 :
1853 : StrSubCommandPairVector Subs;
1854 11 : sortSubCommands(GlobalParser->RegisteredSubCommands, Subs);
1855 :
1856 11 : if (!GlobalParser->ProgramOverview.empty())
1857 18 : outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";
1858 :
1859 11 : if (Sub == &*TopLevelSubCommand) {
1860 11 : outs() << "USAGE: " << GlobalParser->ProgramName;
1861 11 : if (Subs.size() > 2)
1862 1 : outs() << " [subcommand]";
1863 11 : outs() << " [options]";
1864 : } else {
1865 0 : if (!Sub->getDescription().empty()) {
1866 0 : outs() << "SUBCOMMAND '" << Sub->getName()
1867 0 : << "': " << Sub->getDescription() << "\n\n";
1868 : }
1869 0 : outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()
1870 0 : << " [options]";
1871 : }
1872 :
1873 21 : for (auto Opt : PositionalOpts) {
1874 10 : if (Opt->hasArgStr())
1875 1 : outs() << " --" << Opt->ArgStr;
1876 10 : outs() << " " << Opt->HelpStr;
1877 : }
1878 :
1879 : // Print the consume after option info if it exists...
1880 11 : if (ConsumeAfterOpt)
1881 0 : outs() << " " << ConsumeAfterOpt->HelpStr;
1882 :
1883 11 : if (Sub == &*TopLevelSubCommand && !Subs.empty()) {
1884 : // Compute the maximum subcommand length...
1885 1 : size_t MaxSubLen = 0;
1886 8 : for (size_t i = 0, e = Subs.size(); i != e; ++i)
1887 10 : MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first));
1888 :
1889 1 : outs() << "\n\n";
1890 1 : outs() << "SUBCOMMANDS:\n\n";
1891 1 : printSubCommands(Subs, MaxSubLen);
1892 1 : outs() << "\n";
1893 1 : outs() << " Type \"" << GlobalParser->ProgramName
1894 : << " <subcommand> -help\" to get more help on a specific "
1895 1 : "subcommand";
1896 : }
1897 :
1898 11 : outs() << "\n\n";
1899 :
1900 : // Compute the maximum argument length...
1901 11 : size_t MaxArgLen = 0;
1902 1786 : for (size_t i = 0, e = Opts.size(); i != e; ++i)
1903 1843 : MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
1904 :
1905 11 : outs() << "OPTIONS:\n";
1906 11 : printOptions(Opts, MaxArgLen);
1907 :
1908 : // Print any extra help the user has declared.
1909 14 : for (auto I : GlobalParser->MoreHelp)
1910 3 : outs() << I;
1911 : GlobalParser->MoreHelp.clear();
1912 11 : }
1913 : };
1914 :
1915 : class CategorizedHelpPrinter : public HelpPrinter {
1916 : public:
1917 : explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
1918 :
1919 : // Helper function for printOptions().
1920 : // It shall return a negative value if A's name should be lexicographically
1921 : // ordered before B's name. It returns a value greater than zero if B's name
1922 : // should be ordered before A's name, and it returns 0 otherwise.
1923 47 : static int OptionCategoryCompare(OptionCategory *const *A,
1924 : OptionCategory *const *B) {
1925 47 : return (*A)->getName().compare((*B)->getName());
1926 : }
1927 :
1928 : // Make sure we inherit our base class's operator=()
1929 : using HelpPrinter::operator=;
1930 :
1931 : protected:
1932 11 : void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override {
1933 : std::vector<OptionCategory *> SortedCategories;
1934 : std::map<OptionCategory *, std::vector<Option *>> CategorizedOptions;
1935 :
1936 : // Collect registered option categories into vector in preparation for
1937 : // sorting.
1938 11 : for (auto I = GlobalParser->RegisteredOptionCategories.begin(),
1939 11 : E = GlobalParser->RegisteredOptionCategories.end();
1940 52 : I != E; ++I) {
1941 41 : SortedCategories.push_back(*I);
1942 : }
1943 :
1944 : // Sort the different option categories alphabetically.
1945 : assert(SortedCategories.size() > 0 && "No option categories registered!");
1946 : array_pod_sort(SortedCategories.begin(), SortedCategories.end(),
1947 : OptionCategoryCompare);
1948 :
1949 : // Create map to empty vectors.
1950 : for (std::vector<OptionCategory *>::const_iterator
1951 : I = SortedCategories.begin(),
1952 : E = SortedCategories.end();
1953 52 : I != E; ++I)
1954 82 : CategorizedOptions[*I] = std::vector<Option *>();
1955 :
1956 : // Walk through pre-sorted options and assign into categories.
1957 : // Because the options are already alphabetically sorted the
1958 : // options within categories will also be alphabetically sorted.
1959 1786 : for (size_t I = 0, E = Opts.size(); I != E; ++I) {
1960 1775 : Option *Opt = Opts[I].second;
1961 : assert(CategorizedOptions.count(Opt->Category) > 0 &&
1962 : "Option has an unregistered category");
1963 1775 : CategorizedOptions[Opt->Category].push_back(Opt);
1964 : }
1965 :
1966 : // Now do printing.
1967 : for (std::vector<OptionCategory *>::const_iterator
1968 : Category = SortedCategories.begin(),
1969 : E = SortedCategories.end();
1970 52 : Category != E; ++Category) {
1971 : // Hide empty categories for -help, but show for -help-hidden.
1972 41 : const auto &CategoryOptions = CategorizedOptions[*Category];
1973 : bool IsEmptyCategory = CategoryOptions.empty();
1974 41 : if (!ShowHidden && IsEmptyCategory)
1975 : continue;
1976 :
1977 : // Print category information.
1978 32 : outs() << "\n";
1979 32 : outs() << (*Category)->getName() << ":\n";
1980 :
1981 : // Check if description is set.
1982 32 : if (!(*Category)->getDescription().empty())
1983 2 : outs() << (*Category)->getDescription() << "\n\n";
1984 : else
1985 30 : outs() << "\n";
1986 :
1987 : // When using -help-hidden explicitly state if the category has no
1988 : // options associated with it.
1989 32 : if (IsEmptyCategory) {
1990 0 : outs() << " This option category has no options.\n";
1991 0 : continue;
1992 : }
1993 : // Loop over the options in the category and print.
1994 1807 : for (const Option *Opt : CategoryOptions)
1995 1775 : Opt->printOptionInfo(MaxArgLen);
1996 : }
1997 11 : }
1998 : };
1999 :
2000 : // This wraps the Uncategorizing and Categorizing printers and decides
2001 : // at run time which should be invoked.
2002 : class HelpPrinterWrapper {
2003 : private:
2004 : HelpPrinter &UncategorizedPrinter;
2005 : CategorizedHelpPrinter &CategorizedPrinter;
2006 :
2007 : public:
2008 : explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
2009 : CategorizedHelpPrinter &CategorizedPrinter)
2010 : : UncategorizedPrinter(UncategorizedPrinter),
2011 : CategorizedPrinter(CategorizedPrinter) {}
2012 :
2013 : // Invoke the printer.
2014 : void operator=(bool Value);
2015 : };
2016 :
2017 : } // End anonymous namespace
2018 :
2019 : // Declare the four HelpPrinter instances that are used to print out help, or
2020 : // help-hidden as an uncategorized list or in categories.
2021 : static HelpPrinter UncategorizedNormalPrinter(false);
2022 : static HelpPrinter UncategorizedHiddenPrinter(true);
2023 : static CategorizedHelpPrinter CategorizedNormalPrinter(false);
2024 : static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
2025 :
2026 : // Declare HelpPrinter wrappers that will decide whether or not to invoke
2027 : // a categorizing help printer
2028 : static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
2029 : CategorizedNormalPrinter);
2030 : static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
2031 : CategorizedHiddenPrinter);
2032 :
2033 : // Define a category for generic options that all tools should have.
2034 : static cl::OptionCategory GenericCategory("Generic Options");
2035 :
2036 : // Define uncategorized help printers.
2037 : // -help-list is hidden by default because if Option categories are being used
2038 : // then -help behaves the same as -help-list.
2039 : static cl::opt<HelpPrinter, true, parser<bool>> HLOp(
2040 : "help-list",
2041 : cl::desc("Display list of available options (-help-list-hidden for more)"),
2042 : cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed,
2043 : cl::cat(GenericCategory), cl::sub(*AllSubCommands));
2044 :
2045 : static cl::opt<HelpPrinter, true, parser<bool>>
2046 : HLHOp("help-list-hidden", cl::desc("Display list of all available options"),
2047 : cl::location(UncategorizedHiddenPrinter), cl::Hidden,
2048 : cl::ValueDisallowed, cl::cat(GenericCategory),
2049 : cl::sub(*AllSubCommands));
2050 :
2051 : // Define uncategorized/categorized help printers. These printers change their
2052 : // behaviour at runtime depending on whether one or more Option categories have
2053 : // been declared.
2054 : static cl::opt<HelpPrinterWrapper, true, parser<bool>>
2055 : HOp("help", cl::desc("Display available options (-help-hidden for more)"),
2056 : cl::location(WrappedNormalPrinter), cl::ValueDisallowed,
2057 : cl::cat(GenericCategory), cl::sub(*AllSubCommands));
2058 :
2059 : static cl::opt<HelpPrinterWrapper, true, parser<bool>>
2060 : HHOp("help-hidden", cl::desc("Display all available options"),
2061 : cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed,
2062 : cl::cat(GenericCategory), cl::sub(*AllSubCommands));
2063 :
2064 : static cl::opt<bool> PrintOptions(
2065 : "print-options",
2066 : cl::desc("Print non-default options after command line parsing"),
2067 : cl::Hidden, cl::init(false), cl::cat(GenericCategory),
2068 : cl::sub(*AllSubCommands));
2069 :
2070 : static cl::opt<bool> PrintAllOptions(
2071 : "print-all-options",
2072 : cl::desc("Print all option values after command line parsing"), cl::Hidden,
2073 : cl::init(false), cl::cat(GenericCategory), cl::sub(*AllSubCommands));
2074 :
2075 8 : void HelpPrinterWrapper::operator=(bool Value) {
2076 8 : if (!Value)
2077 : return;
2078 :
2079 : // Decide which printer to invoke. If more than one option category is
2080 : // registered then it is useful to show the categorized help instead of
2081 : // uncategorized help.
2082 16 : if (GlobalParser->RegisteredOptionCategories.size() > 1) {
2083 : // unhide -help-list option so user can have uncategorized output if they
2084 : // want it.
2085 : HLOp.setHiddenFlag(NotHidden);
2086 :
2087 8 : CategorizedPrinter = true; // Invoke categorized printer
2088 : } else
2089 0 : UncategorizedPrinter = true; // Invoke uncategorized printer
2090 : }
2091 :
2092 : // Print the value of each option.
2093 47086 : void cl::PrintOptionValues() { GlobalParser->printOptionValues(); }
2094 :
2095 0 : void CommandLineParser::printOptionValues() {
2096 0 : if (!PrintOptions && !PrintAllOptions)
2097 0 : return;
2098 :
2099 : SmallVector<std::pair<const char *, Option *>, 128> Opts;
2100 0 : sortOpts(ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true);
2101 :
2102 : // Compute the maximum argument length...
2103 0 : size_t MaxArgLen = 0;
2104 0 : for (size_t i = 0, e = Opts.size(); i != e; ++i)
2105 0 : MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
2106 :
2107 0 : for (size_t i = 0, e = Opts.size(); i != e; ++i)
2108 0 : Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions);
2109 : }
2110 :
2111 : static VersionPrinterTy OverrideVersionPrinter = nullptr;
2112 :
2113 : static std::vector<VersionPrinterTy> *ExtraVersionPrinters = nullptr;
2114 :
2115 : namespace {
2116 : class VersionPrinter {
2117 : public:
2118 0 : void print() {
2119 0 : raw_ostream &OS = outs();
2120 : #ifdef PACKAGE_VENDOR
2121 : OS << PACKAGE_VENDOR << " ";
2122 : #else
2123 0 : OS << "LLVM (http://llvm.org/):\n ";
2124 : #endif
2125 0 : OS << PACKAGE_NAME << " version " << PACKAGE_VERSION;
2126 : #ifdef LLVM_VERSION_INFO
2127 : OS << " " << LLVM_VERSION_INFO;
2128 : #endif
2129 0 : OS << "\n ";
2130 : #ifdef LLVM_DEBIAN_INFO
2131 : OS << LLVM_DEBIAN_INFO;
2132 : #endif
2133 0 : OS << "\n ";
2134 : #ifndef __OPTIMIZE__
2135 : OS << "DEBUG build";
2136 : #else
2137 0 : OS << "Optimized build";
2138 : #endif
2139 : #ifndef NDEBUG
2140 : OS << " with assertions";
2141 : #endif
2142 : #if LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
2143 0 : std::string CPU = sys::getHostCPUName();
2144 0 : if (CPU == "generic")
2145 : CPU = "(unknown)";
2146 0 : OS << ".\n"
2147 0 : << " Default target: " << sys::getDefaultTargetTriple() << '\n'
2148 0 : << " Host CPU: " << CPU;
2149 : #endif
2150 : OS << '\n';
2151 0 : }
2152 4 : void operator=(bool OptionWasSpecified) {
2153 4 : if (!OptionWasSpecified)
2154 0 : return;
2155 :
2156 4 : if (OverrideVersionPrinter != nullptr) {
2157 0 : OverrideVersionPrinter(outs());
2158 0 : exit(0);
2159 : }
2160 4 : print();
2161 :
2162 : // Iterate over any registered extra printers and call them to add further
2163 : // information.
2164 4 : if (ExtraVersionPrinters != nullptr) {
2165 0 : outs() << '\n';
2166 0 : for (auto I : *ExtraVersionPrinters)
2167 0 : I(outs());
2168 : }
2169 :
2170 4 : exit(0);
2171 : }
2172 : };
2173 : } // End anonymous namespace
2174 :
2175 : // Define the --version option that prints out the LLVM version for the tool
2176 : static VersionPrinter VersionPrinterInstance;
2177 :
2178 : static cl::opt<VersionPrinter, true, parser<bool>>
2179 : VersOp("version", cl::desc("Display the version of this program"),
2180 : cl::location(VersionPrinterInstance), cl::ValueDisallowed,
2181 : cl::cat(GenericCategory));
2182 :
2183 : // Utility function for printing the help message.
2184 3 : void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
2185 3 : if (!Hidden && !Categorized)
2186 0 : UncategorizedNormalPrinter.printHelp();
2187 3 : else if (!Hidden && Categorized)
2188 3 : CategorizedNormalPrinter.printHelp();
2189 0 : else if (Hidden && !Categorized)
2190 0 : UncategorizedHiddenPrinter.printHelp();
2191 : else
2192 0 : CategorizedHiddenPrinter.printHelp();
2193 3 : }
2194 :
2195 : /// Utility function for printing version number.
2196 5 : void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
2197 :
2198 328 : void cl::SetVersionPrinter(VersionPrinterTy func) { OverrideVersionPrinter = func; }
2199 :
2200 35437 : void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
2201 35437 : if (!ExtraVersionPrinters)
2202 35437 : ExtraVersionPrinters = new std::vector<VersionPrinterTy>;
2203 :
2204 35437 : ExtraVersionPrinters->push_back(func);
2205 35437 : }
2206 :
2207 4 : StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
2208 : auto &Subs = GlobalParser->RegisteredSubCommands;
2209 : (void)Subs;
2210 : assert(is_contained(Subs, &Sub));
2211 4 : return Sub.OptionsMap;
2212 : }
2213 :
2214 : iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
2215 75 : cl::getRegisteredSubcommands() {
2216 75 : return GlobalParser->getRegisteredSubcommands();
2217 : }
2218 :
2219 974 : void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
2220 1227534 : for (auto &I : Sub.OptionsMap) {
2221 1225586 : if (I.second->Category != &Category &&
2222 : I.second->Category != &GenericCategory)
2223 : I.second->setHiddenFlag(cl::ReallyHidden);
2224 : }
2225 974 : }
2226 :
2227 1321 : void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
2228 : SubCommand &Sub) {
2229 : auto CategoriesBegin = Categories.begin();
2230 1321 : auto CategoriesEnd = Categories.end();
2231 1703251 : for (auto &I : Sub.OptionsMap) {
2232 1700609 : if (std::find(CategoriesBegin, CategoriesEnd, I.second->Category) ==
2233 1700609 : CategoriesEnd &&
2234 1649529 : I.second->Category != &GenericCategory)
2235 : I.second->setHiddenFlag(cl::ReallyHidden);
2236 : }
2237 1321 : }
2238 :
2239 9 : void cl::ResetCommandLineParser() { GlobalParser->reset(); }
2240 660 : void cl::ResetAllOptionOccurrences() {
2241 660 : GlobalParser->ResetAllOptionOccurrences();
2242 660 : }
2243 :
2244 0 : void LLVMParseCommandLineOptions(int argc, const char *const *argv,
2245 : const char *Overview) {
2246 0 : llvm::cl::ParseCommandLineOptions(argc, argv, StringRef(Overview),
2247 0 : &llvm::nulls());
2248 0 : }
|
