1 //===-- CommandLine.cpp - Command line parser implementation --------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
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.
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
17 //===----------------------------------------------------------------------===//
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"
47 #define DEBUG_TYPE "commandline"
49 //===----------------------------------------------------------------------===//
50 // Template instantiations and anchors.
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>;
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>;
70 } // end namespace llvm::cl
72 // Pin the vtables to this file.
73 void GenericOptionValue::anchor() {}
74 void OptionValue
<boolOrDefault
>::anchor() {}
75 void OptionValue
<std::string
>::anchor() {}
76 void Option::anchor() {}
77 void basic_parser_impl::anchor() {}
78 void parser
<bool>::anchor() {}
79 void parser
<boolOrDefault
>::anchor() {}
80 void parser
<int>::anchor() {}
81 void parser
<unsigned>::anchor() {}
82 void parser
<unsigned long long>::anchor() {}
83 void parser
<double>::anchor() {}
84 void parser
<float>::anchor() {}
85 void parser
<std::string
>::anchor() {}
86 void parser
<char>::anchor() {}
88 //===----------------------------------------------------------------------===//
92 class CommandLineParser
{
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
;
99 // This collects additional help to be printed.
100 std::vector
<StringRef
> MoreHelp
;
102 // This collects the different option categories that have been registered.
103 SmallPtrSet
<OptionCategory
*, 16> RegisteredOptionCategories
;
105 // This collects the different subcommands that have been registered.
106 SmallPtrSet
<SubCommand
*, 4> RegisteredSubCommands
;
108 CommandLineParser() : ActiveSubCommand(nullptr) {
109 registerSubCommand(&*TopLevelSubCommand
);
110 registerSubCommand(&*AllSubCommands
);
113 void ResetAllOptionOccurrences();
115 bool ParseCommandLineOptions(int argc
, const char *const *argv
,
116 StringRef Overview
, raw_ostream
*Errs
= nullptr);
118 void addLiteralOption(Option
&Opt
, SubCommand
*SC
, StringRef Name
) {
121 if (!SC
->OptionsMap
.insert(std::make_pair(Name
, &Opt
)).second
) {
122 errs() << ProgramName
<< ": CommandLine Error: Option '" << Name
123 << "' registered more than once!\n";
124 report_fatal_error("inconsistency in registered CommandLine options");
127 // If we're adding this to all sub-commands, add it to the ones that have
128 // already been registered.
129 if (SC
== &*AllSubCommands
) {
130 for (const auto &Sub
: RegisteredSubCommands
) {
133 addLiteralOption(Opt
, Sub
, Name
);
138 void addLiteralOption(Option
&Opt
, StringRef Name
) {
139 if (Opt
.Subs
.empty())
140 addLiteralOption(Opt
, &*TopLevelSubCommand
, Name
);
142 for (auto SC
: Opt
.Subs
)
143 addLiteralOption(Opt
, SC
, Name
);
147 void addOption(Option
*O
, SubCommand
*SC
) {
148 bool HadErrors
= false;
149 if (O
->hasArgStr()) {
150 // Add argument to the argument map!
151 if (!SC
->OptionsMap
.insert(std::make_pair(O
->ArgStr
, O
)).second
) {
152 errs() << ProgramName
<< ": CommandLine Error: Option '" << O
->ArgStr
153 << "' registered more than once!\n";
158 // Remember information about positional options.
159 if (O
->getFormattingFlag() == cl::Positional
)
160 SC
->PositionalOpts
.push_back(O
);
161 else if (O
->getMiscFlags() & cl::Sink
) // Remember sink options
162 SC
->SinkOpts
.push_back(O
);
163 else if (O
->getNumOccurrencesFlag() == cl::ConsumeAfter
) {
164 if (SC
->ConsumeAfterOpt
) {
165 O
->error("Cannot specify more than one option with cl::ConsumeAfter!");
168 SC
->ConsumeAfterOpt
= O
;
171 // Fail hard if there were errors. These are strictly unrecoverable and
172 // indicate serious issues such as conflicting option names or an
174 // linked LLVM distribution.
176 report_fatal_error("inconsistency in registered CommandLine options");
178 // If we're adding this to all sub-commands, add it to the ones that have
179 // already been registered.
180 if (SC
== &*AllSubCommands
) {
181 for (const auto &Sub
: RegisteredSubCommands
) {
189 void addOption(Option
*O
) {
190 if (O
->Subs
.empty()) {
191 addOption(O
, &*TopLevelSubCommand
);
193 for (auto SC
: O
->Subs
)
198 void removeOption(Option
*O
, SubCommand
*SC
) {
199 SmallVector
<StringRef
, 16> OptionNames
;
200 O
->getExtraOptionNames(OptionNames
);
202 OptionNames
.push_back(O
->ArgStr
);
204 SubCommand
&Sub
= *SC
;
205 for (auto Name
: OptionNames
)
206 Sub
.OptionsMap
.erase(Name
);
208 if (O
->getFormattingFlag() == cl::Positional
)
209 for (auto Opt
= Sub
.PositionalOpts
.begin();
210 Opt
!= Sub
.PositionalOpts
.end(); ++Opt
) {
212 Sub
.PositionalOpts
.erase(Opt
);
216 else if (O
->getMiscFlags() & cl::Sink
)
217 for (auto Opt
= Sub
.SinkOpts
.begin(); Opt
!= Sub
.SinkOpts
.end(); ++Opt
) {
219 Sub
.SinkOpts
.erase(Opt
);
223 else if (O
== Sub
.ConsumeAfterOpt
)
224 Sub
.ConsumeAfterOpt
= nullptr;
227 void removeOption(Option
*O
) {
229 removeOption(O
, &*TopLevelSubCommand
);
231 if (O
->isInAllSubCommands()) {
232 for (auto SC
: RegisteredSubCommands
)
235 for (auto SC
: O
->Subs
)
241 bool hasOptions(const SubCommand
&Sub
) const {
242 return (!Sub
.OptionsMap
.empty() || !Sub
.PositionalOpts
.empty() ||
243 nullptr != Sub
.ConsumeAfterOpt
);
246 bool hasOptions() const {
247 for (const auto &S
: RegisteredSubCommands
) {
254 SubCommand
*getActiveSubCommand() { return ActiveSubCommand
; }
256 void updateArgStr(Option
*O
, StringRef NewName
, SubCommand
*SC
) {
257 SubCommand
&Sub
= *SC
;
258 if (!Sub
.OptionsMap
.insert(std::make_pair(NewName
, O
)).second
) {
259 errs() << ProgramName
<< ": CommandLine Error: Option '" << O
->ArgStr
260 << "' registered more than once!\n";
261 report_fatal_error("inconsistency in registered CommandLine options");
263 Sub
.OptionsMap
.erase(O
->ArgStr
);
266 void updateArgStr(Option
*O
, StringRef NewName
) {
268 updateArgStr(O
, NewName
, &*TopLevelSubCommand
);
270 for (auto SC
: O
->Subs
)
271 updateArgStr(O
, NewName
, SC
);
275 void printOptionValues();
277 void registerCategory(OptionCategory
*cat
) {
278 assert(count_if(RegisteredOptionCategories
,
279 [cat
](const OptionCategory
*Category
) {
280 return cat
->getName() == Category
->getName();
282 "Duplicate option categories");
284 RegisteredOptionCategories
.insert(cat
);
287 void registerSubCommand(SubCommand
*sub
) {
288 assert(count_if(RegisteredSubCommands
,
289 [sub
](const SubCommand
*Sub
) {
290 return (!sub
->getName().empty()) &&
291 (Sub
->getName() == sub
->getName());
293 "Duplicate subcommands");
294 RegisteredSubCommands
.insert(sub
);
296 // For all options that have been registered for all subcommands, add the
297 // option to this subcommand now.
298 if (sub
!= &*AllSubCommands
) {
299 for (auto &E
: AllSubCommands
->OptionsMap
) {
300 Option
*O
= E
.second
;
301 if ((O
->isPositional() || O
->isSink() || O
->isConsumeAfter()) ||
305 addLiteralOption(*O
, sub
, E
.first());
310 void unregisterSubCommand(SubCommand
*sub
) {
311 RegisteredSubCommands
.erase(sub
);
314 iterator_range
<typename SmallPtrSet
<SubCommand
*, 4>::iterator
>
315 getRegisteredSubcommands() {
316 return make_range(RegisteredSubCommands
.begin(),
317 RegisteredSubCommands
.end());
321 ActiveSubCommand
= nullptr;
323 ProgramOverview
= StringRef();
326 RegisteredOptionCategories
.clear();
328 ResetAllOptionOccurrences();
329 RegisteredSubCommands
.clear();
331 TopLevelSubCommand
->reset();
332 AllSubCommands
->reset();
333 registerSubCommand(&*TopLevelSubCommand
);
334 registerSubCommand(&*AllSubCommands
);
338 SubCommand
*ActiveSubCommand
;
340 Option
*LookupOption(SubCommand
&Sub
, StringRef
&Arg
, StringRef
&Value
);
341 SubCommand
*LookupSubCommand(StringRef Name
);
346 static ManagedStatic
<CommandLineParser
> GlobalParser
;
348 void cl::AddLiteralOption(Option
&O
, StringRef Name
) {
349 GlobalParser
->addLiteralOption(O
, Name
);
352 extrahelp::extrahelp(StringRef Help
) : morehelp(Help
) {
353 GlobalParser
->MoreHelp
.push_back(Help
);
356 void Option::addArgument() {
357 GlobalParser
->addOption(this);
358 FullyInitialized
= true;
361 void Option::removeArgument() { GlobalParser
->removeOption(this); }
363 void Option::setArgStr(StringRef S
) {
364 if (FullyInitialized
)
365 GlobalParser
->updateArgStr(this, S
);
366 assert((S
.empty() || S
[0] != '-') && "Option can't start with '-");
370 // Initialise the general option category.
371 OptionCategory
llvm::cl::GeneralCategory("General options");
373 void OptionCategory::registerCategory() {
374 GlobalParser
->registerCategory(this);
377 // A special subcommand representing no subcommand
378 ManagedStatic
<SubCommand
> llvm::cl::TopLevelSubCommand
;
380 // A special subcommand that can be used to put an option into all subcommands.
381 ManagedStatic
<SubCommand
> llvm::cl::AllSubCommands
;
383 void SubCommand::registerSubCommand() {
384 GlobalParser
->registerSubCommand(this);
387 void SubCommand::unregisterSubCommand() {
388 GlobalParser
->unregisterSubCommand(this);
391 void SubCommand::reset() {
392 PositionalOpts
.clear();
396 ConsumeAfterOpt
= nullptr;
399 SubCommand::operator bool() const {
400 return (GlobalParser
->getActiveSubCommand() == this);
403 //===----------------------------------------------------------------------===//
404 // Basic, shared command line option processing machinery.
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 Option
*CommandLineParser::LookupOption(SubCommand
&Sub
, StringRef
&Arg
,
412 // Reject all dashes.
415 assert(&Sub
!= &*AllSubCommands
);
417 size_t EqualPos
= Arg
.find('=');
419 // If we have an equals sign, remember the value.
420 if (EqualPos
== StringRef::npos
) {
421 // Look up the option.
422 auto I
= Sub
.OptionsMap
.find(Arg
);
423 if (I
== Sub
.OptionsMap
.end())
426 return I
!= Sub
.OptionsMap
.end() ? I
->second
: nullptr;
429 // If the argument before the = is a valid option name, we match. If not,
430 // return Arg unmolested.
431 auto I
= Sub
.OptionsMap
.find(Arg
.substr(0, EqualPos
));
432 if (I
== Sub
.OptionsMap
.end())
435 Value
= Arg
.substr(EqualPos
+ 1);
436 Arg
= Arg
.substr(0, EqualPos
);
440 SubCommand
*CommandLineParser::LookupSubCommand(StringRef Name
) {
442 return &*TopLevelSubCommand
;
443 for (auto S
: RegisteredSubCommands
) {
444 if (S
== &*AllSubCommands
)
446 if (S
->getName().empty())
449 if (StringRef(S
->getName()) == StringRef(Name
))
452 return &*TopLevelSubCommand
;
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 static Option
*LookupNearestOption(StringRef Arg
,
460 const StringMap
<Option
*> &OptionsMap
,
461 std::string
&NearestString
) {
462 // Reject all dashes.
466 // Split on any equal sign.
467 std::pair
<StringRef
, StringRef
> SplitArg
= Arg
.split('=');
468 StringRef
&LHS
= SplitArg
.first
; // LHS == Arg when no '=' is present.
469 StringRef
&RHS
= SplitArg
.second
;
471 // Find the closest match.
472 Option
*Best
= nullptr;
473 unsigned BestDistance
= 0;
474 for (StringMap
<Option
*>::const_iterator it
= OptionsMap
.begin(),
475 ie
= OptionsMap
.end();
477 Option
*O
= it
->second
;
478 SmallVector
<StringRef
, 16> OptionNames
;
479 O
->getExtraOptionNames(OptionNames
);
481 OptionNames
.push_back(O
->ArgStr
);
483 bool PermitValue
= O
->getValueExpectedFlag() != cl::ValueDisallowed
;
484 StringRef Flag
= PermitValue
? LHS
: Arg
;
485 for (auto Name
: OptionNames
) {
486 unsigned Distance
= StringRef(Name
).edit_distance(
487 Flag
, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance
);
488 if (!Best
|| Distance
< BestDistance
) {
490 BestDistance
= Distance
;
491 if (RHS
.empty() || !PermitValue
)
492 NearestString
= Name
;
494 NearestString
= (Twine(Name
) + "=" + RHS
).str();
502 /// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence()
503 /// that does special handling of cl::CommaSeparated options.
504 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 if (Handler
->getMiscFlags() & CommaSeparated
) {
510 StringRef
Val(Value
);
511 StringRef::size_type Pos
= Val
.find(',');
513 while (Pos
!= StringRef::npos
) {
514 // Process the portion before the comma.
515 if (Handler
->addOccurrence(pos
, ArgName
, Val
.substr(0, Pos
), MultiArg
))
517 // Erase the portion before the comma, AND the comma.
518 Val
= Val
.substr(Pos
+ 1);
519 // Check for another comma.
526 return Handler
->addOccurrence(pos
, ArgName
, Value
, MultiArg
);
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 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 unsigned NumAdditionalVals
= Handler
->getNumAdditionalVals();
538 // Enforce value requirements
539 switch (Handler
->getValueExpectedFlag()) {
541 if (!Value
.data()) { // No value specified?
543 return Handler
->error("requires a value!");
544 // Steal the next argument, like for '-o filename'
545 assert(argv
&& "null check");
546 Value
= StringRef(argv
[++i
]);
549 case ValueDisallowed
:
550 if (NumAdditionalVals
> 0)
551 return Handler
->error("multi-valued option specified"
552 " with ValueDisallowed modifier!");
555 return Handler
->error("does not allow a value! '" + Twine(Value
) +
562 // If this isn't a multi-arg option, just run the handler.
563 if (NumAdditionalVals
== 0)
564 return CommaSeparateAndAddOccurrence(Handler
, i
, ArgName
, Value
);
566 // If it is, run the handle several times.
567 bool MultiArg
= false;
570 if (CommaSeparateAndAddOccurrence(Handler
, i
, ArgName
, Value
, MultiArg
))
576 while (NumAdditionalVals
> 0) {
578 return Handler
->error("not enough values!");
579 assert(argv
&& "null check");
580 Value
= StringRef(argv
[++i
]);
582 if (CommaSeparateAndAddOccurrence(Handler
, i
, ArgName
, Value
, MultiArg
))
590 static bool ProvidePositionalOption(Option
*Handler
, StringRef Arg
, int i
) {
592 return ProvideOption(Handler
, Handler
->ArgStr
, Arg
, 0, nullptr, Dummy
);
595 // Option predicates...
596 static inline bool isGrouping(const Option
*O
) {
597 return O
->getFormattingFlag() == cl::Grouping
;
599 static inline bool isPrefixedOrGrouping(const Option
*O
) {
600 return isGrouping(O
) || O
->getFormattingFlag() == cl::Prefix
;
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.
609 static Option
*getOptionPred(StringRef Name
, size_t &Length
,
610 bool (*Pred
)(const Option
*),
611 const StringMap
<Option
*> &OptionsMap
) {
613 StringMap
<Option
*>::const_iterator OMI
= OptionsMap
.find(Name
);
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
618 while (OMI
== OptionsMap
.end() && Name
.size() > 1) {
619 Name
= Name
.substr(0, Name
.size() - 1); // Chop off the last character.
620 OMI
= OptionsMap
.find(Name
);
623 if (OMI
!= OptionsMap
.end() && Pred(OMI
->second
)) {
624 Length
= Name
.size();
625 return OMI
->second
; // Found one!
627 return nullptr; // No option found!
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.
635 HandlePrefixedOrGroupedOption(StringRef
&Arg
, StringRef
&Value
,
637 const StringMap
<Option
*> &OptionsMap
) {
643 Option
*PGOpt
= getOptionPred(Arg
, Length
, isPrefixedOrGrouping
, OptionsMap
);
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 if (PGOpt
->getFormattingFlag() == cl::Prefix
) {
651 Value
= Arg
.substr(Length
);
652 Arg
= Arg
.substr(0, Length
);
653 assert(OptionsMap
.count(Arg
) && OptionsMap
.find(Arg
)->second
== PGOpt
);
657 // This must be a grouped option... handle them now. Grouping options can't
659 assert(isGrouping(PGOpt
) && "Broken getOptionPred!");
662 // Move current arg name out of Arg into OneArgName.
663 StringRef OneArgName
= Arg
.substr(0, Length
);
664 Arg
= Arg
.substr(Length
);
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!");
672 ProvideOption(PGOpt
, OneArgName
, StringRef(), 0, nullptr, Dummy
);
674 // Get the next grouping option.
675 PGOpt
= getOptionPred(Arg
, Length
, isGrouping
, OptionsMap
);
676 } while (PGOpt
&& Length
!= Arg
.size());
678 // Return the last option with Arg cut down to just the last one.
682 static bool RequiresValue(const Option
*O
) {
683 return O
->getNumOccurrencesFlag() == cl::Required
||
684 O
->getNumOccurrencesFlag() == cl::OneOrMore
;
687 static bool EatsUnboundedNumberOfValues(const Option
*O
) {
688 return O
->getNumOccurrencesFlag() == cl::ZeroOrMore
||
689 O
->getNumOccurrencesFlag() == cl::OneOrMore
;
692 static bool isWhitespace(char C
) {
693 return C
== ' ' || C
== '\t' || C
== '\r' || C
== '\n';
696 static bool isWhitespaceOrNull(char C
) {
697 return isWhitespace(C
) || C
== '\0';
700 static bool isQuote(char C
) { return C
== '\"' || C
== '\''; }
702 void cl::TokenizeGNUCommandLine(StringRef Src
, StringSaver
&Saver
,
703 SmallVectorImpl
<const char *> &NewArgv
,
705 SmallString
<128> Token
;
706 for (size_t I
= 0, E
= Src
.size(); I
!= E
; ++I
) {
707 // Consume runs of whitespace.
709 while (I
!= E
&& isWhitespace(Src
[I
])) {
710 // Mark the end of lines in response files
711 if (MarkEOLs
&& Src
[I
] == '\n')
712 NewArgv
.push_back(nullptr);
721 // Backslash escapes the next character.
722 if (I
+ 1 < E
&& C
== '\\') {
723 ++I
; // Skip the escape.
724 Token
.push_back(Src
[I
]);
728 // Consume a quoted string.
731 while (I
!= E
&& Src
[I
] != C
) {
732 // Backslash escapes the next character.
733 if (Src
[I
] == '\\' && I
+ 1 != E
)
735 Token
.push_back(Src
[I
]);
743 // End the token if this is whitespace.
744 if (isWhitespace(C
)) {
746 NewArgv
.push_back(Saver
.save(StringRef(Token
)).data());
751 // This is a normal character. Append it.
755 // Append the last token after hitting EOF with no whitespace.
757 NewArgv
.push_back(Saver
.save(StringRef(Token
)).data());
758 // Mark the end of response files
760 NewArgv
.push_back(nullptr);
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.
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
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.
779 /// * Otherwise, backslashes are interpreted literally.
780 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.
787 } while (I
!= E
&& Src
[I
] == '\\');
789 bool FollowedByDoubleQuote
= (I
!= E
&& Src
[I
] == '"');
790 if (FollowedByDoubleQuote
) {
791 Token
.append(BackslashCount
/ 2, '\\');
792 if (BackslashCount
% 2 == 0)
794 Token
.push_back('"');
797 Token
.append(BackslashCount
, '\\');
801 void cl::TokenizeWindowsCommandLine(StringRef Src
, StringSaver
&Saver
,
802 SmallVectorImpl
<const char *> &NewArgv
,
804 SmallString
<128> Token
;
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 for (size_t I
= 0, E
= Src
.size(); I
!= E
; ++I
) {
812 // INIT state indicates that the current input index is at the start of
813 // the string or between tokens.
815 if (isWhitespaceOrNull(C
)) {
816 // Mark the end of lines in response files
817 if (MarkEOLs
&& C
== '\n')
818 NewArgv
.push_back(nullptr);
826 I
= parseBackslash(Src
, I
, Token
);
835 // UNQUOTED state means that it's reading a token not quoted by double
837 if (State
== UNQUOTED
) {
838 // Whitespace means the end of the token.
839 if (isWhitespaceOrNull(C
)) {
840 NewArgv
.push_back(Saver
.save(StringRef(Token
)).data());
843 // Mark the end of lines in response files
844 if (MarkEOLs
&& C
== '\n')
845 NewArgv
.push_back(nullptr);
853 I
= parseBackslash(Src
, I
, Token
);
860 // QUOTED state means that it's reading a token quoted by double quotes.
861 if (State
== QUOTED
) {
867 I
= parseBackslash(Src
, I
, Token
);
873 // Append the last token after hitting EOF with no whitespace.
875 NewArgv
.push_back(Saver
.save(StringRef(Token
)).data());
876 // Mark the end of response files
878 NewArgv
.push_back(nullptr);
881 void cl::tokenizeConfigFile(StringRef Source
, StringSaver
&Saver
,
882 SmallVectorImpl
<const char *> &NewArgv
,
884 for (const char *Cur
= Source
.begin(); Cur
!= Source
.end();) {
885 SmallString
<128> Line
;
886 // Check for comment line.
887 if (isWhitespace(*Cur
)) {
888 while (Cur
!= Source
.end() && isWhitespace(*Cur
))
893 while (Cur
!= Source
.end() && *Cur
!= '\n')
897 // Find end of the current line.
898 const char *Start
= Cur
;
899 for (const char *End
= Source
.end(); Cur
!= End
; ++Cur
) {
901 if (Cur
+ 1 != End
) {
904 (*Cur
== '\r' && (Cur
+ 1 != End
) && Cur
[1] == '\n')) {
905 Line
.append(Start
, Cur
- 1);
911 } else if (*Cur
== '\n')
915 Line
.append(Start
, Cur
);
916 cl::TokenizeGNUCommandLine(Line
, Saver
, NewArgv
, MarkEOLs
);
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 return (S
.size() >= 3 && S
[0] == '\xef' && S
[1] == '\xbb' && S
[2] == '\xbf');
926 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 MemoryBuffer::getFile(FName
);
934 MemoryBuffer
&MemBuf
= *MemBufOrErr
.get();
935 StringRef
Str(MemBuf
.getBufferStart(), MemBuf
.getBufferSize());
937 // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing.
938 ArrayRef
<char> BufRef(MemBuf
.getBufferStart(), MemBuf
.getBufferEnd());
940 if (hasUTF16ByteOrderMark(BufRef
)) {
941 if (!convertUTF16ToUTF8String(BufRef
, UTF8Buf
))
943 Str
= StringRef(UTF8Buf
);
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 Str
= StringRef(BufRef
.data() + 3, BufRef
.size() - 3);
951 // Tokenize the contents into NewArgv.
952 Tokenizer(Str
, Saver
, NewArgv
, MarkEOLs
);
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.
958 for (unsigned I
= 0; I
< NewArgv
.size(); ++I
)
960 StringRef Arg
= NewArgv
[I
];
961 if (Arg
.front() == '@') {
962 StringRef FileName
= Arg
.drop_front();
963 if (llvm::sys::path::is_relative(FileName
)) {
964 SmallString
<128> ResponseFile
;
965 ResponseFile
.append(1, '@');
966 if (llvm::sys::path::is_relative(FName
)) {
967 SmallString
<128> curr_dir
;
968 llvm::sys::fs::current_path(curr_dir
);
969 ResponseFile
.append(curr_dir
.str());
971 llvm::sys::path::append(
972 ResponseFile
, llvm::sys::path::parent_path(FName
), FileName
);
973 NewArgv
[I
] = Saver
.save(ResponseFile
.c_str()).data();
981 /// Expand response files on a command line recursively using the given
982 /// StringSaver and tokenization strategy.
983 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;
989 // Don't cache Argv.size() because it can change.
990 for (unsigned I
= 0; I
!= Argv
.size();) {
991 const char *Arg
= Argv
[I
];
992 // Check if it is an EOL marker
993 if (Arg
== nullptr) {
1002 // If we have too many response files, leave some unexpanded. This avoids
1003 // crashing on self-referential response files.
1004 if (RspFiles
++ > 20)
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 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
1014 AllExpanded
= false;
1018 Argv
.erase(Argv
.begin() + I
);
1019 Argv
.insert(Argv
.begin() + I
, ExpandedArgv
.begin(), ExpandedArgv
.end());
1024 bool cl::readConfigFile(StringRef CfgFile
, StringSaver
&Saver
,
1025 SmallVectorImpl
<const char *> &Argv
) {
1026 if (!ExpandResponseFile(CfgFile
, Saver
, cl::tokenizeConfigFile
, Argv
,
1027 /*MarkEOLs*/ false, /*RelativeNames*/ true))
1029 return ExpandResponseFiles(Saver
, cl::tokenizeConfigFile
, Argv
,
1030 /*MarkEOLs*/ false, /*RelativeNames*/ true);
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).
1038 void cl::ParseEnvironmentOptions(const char *progName
, const char *envVar
,
1039 const char *Overview
) {
1041 assert(progName
&& "Program name not specified");
1042 assert(envVar
&& "Environment variable name missing");
1044 // Get the environment variable they want us to parse options out of.
1045 llvm::Optional
<std::string
> envValue
= sys::Process::GetEnv(StringRef(envVar
));
1049 // Get program's "name", which we wouldn't know without the caller
1051 SmallVector
<const char *, 20> newArgv
;
1053 StringSaver
Saver(A
);
1054 newArgv
.push_back(Saver
.save(progName
).data());
1056 // Parse the value of the environment variable into a "command line"
1057 // and hand it off to ParseCommandLineOptions().
1058 TokenizeGNUCommandLine(*envValue
, Saver
, newArgv
);
1059 int newArgc
= static_cast<int>(newArgv
.size());
1060 ParseCommandLineOptions(newArgc
, &newArgv
[0], StringRef(Overview
));
1063 bool cl::ParseCommandLineOptions(int argc
, const char *const *argv
,
1064 StringRef Overview
, raw_ostream
*Errs
) {
1065 return GlobalParser
->ParseCommandLineOptions(argc
, argv
, Overview
,
1069 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 for (auto SC
: RegisteredSubCommands
) {
1073 for (auto &O
: SC
->OptionsMap
)
1078 bool CommandLineParser::ParseCommandLineOptions(int argc
,
1079 const char *const *argv
,
1081 raw_ostream
*Errs
) {
1082 assert(hasOptions() && "No options specified!");
1084 // Expand response files.
1085 SmallVector
<const char *, 20> newArgv(argv
, argv
+ argc
);
1087 StringSaver
Saver(A
);
1088 ExpandResponseFiles(Saver
,
1089 Triple(sys::getProcessTriple()).isOSWindows() ?
1090 cl::TokenizeWindowsCommandLine
: cl::TokenizeGNUCommandLine
,
1093 argc
= static_cast<int>(newArgv
.size());
1095 // Copy the program name into ProgName, making sure not to overflow it.
1096 ProgramName
= sys::path::filename(StringRef(argv
[0]));
1098 ProgramOverview
= Overview
;
1099 bool IgnoreErrors
= Errs
;
1102 bool ErrorParsing
= false;
1104 // Check out the positional arguments to collect information about them.
1105 unsigned NumPositionalRequired
= 0;
1107 // Determine whether or not there are an unlimited number of positionals
1108 bool HasUnlimitedPositionals
= false;
1111 SubCommand
*ChosenSubCommand
= &*TopLevelSubCommand
;
1112 if (argc
>= 2 && argv
[FirstArg
][0] != '-') {
1113 // If the first argument specifies a valid subcommand, start processing
1114 // options from the second argument.
1115 ChosenSubCommand
= LookupSubCommand(StringRef(argv
[FirstArg
]));
1116 if (ChosenSubCommand
!= &*TopLevelSubCommand
)
1119 GlobalParser
->ActiveSubCommand
= ChosenSubCommand
;
1121 assert(ChosenSubCommand
);
1122 auto &ConsumeAfterOpt
= ChosenSubCommand
->ConsumeAfterOpt
;
1123 auto &PositionalOpts
= ChosenSubCommand
->PositionalOpts
;
1124 auto &SinkOpts
= ChosenSubCommand
->SinkOpts
;
1125 auto &OptionsMap
= ChosenSubCommand
->OptionsMap
;
1127 if (ConsumeAfterOpt
) {
1128 assert(PositionalOpts
.size() > 0 &&
1129 "Cannot specify cl::ConsumeAfter without a positional argument!");
1131 if (!PositionalOpts
.empty()) {
1133 // Calculate how many positional values are _required_.
1134 bool UnboundedFound
= false;
1135 for (size_t i
= 0, e
= PositionalOpts
.size(); i
!= e
; ++i
) {
1136 Option
*Opt
= PositionalOpts
[i
];
1137 if (RequiresValue(Opt
))
1138 ++NumPositionalRequired
;
1139 else if (ConsumeAfterOpt
) {
1140 // ConsumeAfter cannot be combined with "optional" positional options
1141 // unless there is only one positional argument...
1142 if (PositionalOpts
.size() > 1) {
1144 Opt
->error("error - this positional option will never be matched, "
1145 "because it does not Require a value, and a "
1146 "cl::ConsumeAfter option is active!");
1147 ErrorParsing
= true;
1149 } 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!
1155 Opt
->error("error - option can never match, because "
1156 "another positional argument will match an "
1157 "unbounded number of values, and this option"
1158 " does not require a value!");
1159 *Errs
<< ProgramName
<< ": CommandLine Error: Option '" << Opt
->ArgStr
1160 << "' is all messed up!\n";
1161 *Errs
<< PositionalOpts
.size();
1162 ErrorParsing
= true;
1164 UnboundedFound
|= EatsUnboundedNumberOfValues(Opt
);
1166 HasUnlimitedPositionals
= UnboundedFound
|| ConsumeAfterOpt
;
1169 // PositionalVals - A vector of "positional" arguments we accumulate into
1170 // the process at the end.
1172 SmallVector
<std::pair
<StringRef
, unsigned>, 4> PositionalVals
;
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;
1179 // Loop over all of the arguments... processing them.
1180 bool DashDashFound
= false; // Have we read '--'?
1181 for (int i
= FirstArg
; i
< argc
; ++i
) {
1182 Option
*Handler
= nullptr;
1183 Option
*NearestHandler
= nullptr;
1184 std::string NearestHandlerString
;
1186 StringRef ArgName
= "";
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.
1192 if (argv
[i
][0] != '-' || argv
[i
][1] == 0 || DashDashFound
) {
1193 // Positional argument!
1194 if (ActivePositionalArg
) {
1195 ProvidePositionalOption(ActivePositionalArg
, StringRef(argv
[i
]), i
);
1196 continue; // We are done!
1199 if (!PositionalOpts
.empty()) {
1200 PositionalVals
.push_back(std::make_pair(StringRef(argv
[i
]), i
));
1202 // All of the positional arguments have been fulfulled, give the rest to
1203 // the consume after option... if it's specified...
1205 if (PositionalVals
.size() >= NumPositionalRequired
&& ConsumeAfterOpt
) {
1206 for (++i
; i
< argc
; ++i
)
1207 PositionalVals
.push_back(std::make_pair(StringRef(argv
[i
]), i
));
1208 break; // Handle outside of the argument processing loop...
1211 // Delay processing positional arguments until the end...
1214 } else if (argv
[i
][0] == '-' && argv
[i
][1] == '-' && argv
[i
][2] == 0 &&
1216 DashDashFound
= true; // This is the mythical "--"?
1217 continue; // Don't try to process it as an argument itself.
1218 } 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 ArgName
= StringRef(argv
[i
] + 1);
1224 // Eat leading dashes.
1225 while (!ArgName
.empty() && ArgName
[0] == '-')
1226 ArgName
= ArgName
.substr(1);
1228 Handler
= LookupOption(*ChosenSubCommand
, ArgName
, Value
);
1229 if (!Handler
|| Handler
->getFormattingFlag() != cl::Positional
) {
1230 ProvidePositionalOption(ActivePositionalArg
, StringRef(argv
[i
]), i
);
1231 continue; // We are done!
1234 } else { // We start with a '-', must be an argument.
1235 ArgName
= StringRef(argv
[i
] + 1);
1236 // Eat leading dashes.
1237 while (!ArgName
.empty() && ArgName
[0] == '-')
1238 ArgName
= ArgName
.substr(1);
1240 Handler
= LookupOption(*ChosenSubCommand
, ArgName
, Value
);
1242 // Check to see if this "option" is really a prefixed or grouped argument.
1244 Handler
= HandlePrefixedOrGroupedOption(ArgName
, Value
, ErrorParsing
,
1247 // Otherwise, look for the closest available option to report to the user
1248 // in the upcoming error.
1249 if (!Handler
&& SinkOpts
.empty())
1251 LookupNearestOption(ArgName
, OptionsMap
, NearestHandlerString
);
1255 if (SinkOpts
.empty()) {
1256 *Errs
<< ProgramName
<< ": Unknown command line argument '" << argv
[i
]
1257 << "'. Try: '" << argv
[0] << " -help'\n";
1259 if (NearestHandler
) {
1260 // If we know a near match, report it as well.
1261 *Errs
<< ProgramName
<< ": Did you mean '-" << NearestHandlerString
1265 ErrorParsing
= true;
1267 for (SmallVectorImpl
<Option
*>::iterator I
= SinkOpts
.begin(),
1270 (*I
)->addOccurrence(i
, "", StringRef(argv
[i
]));
1275 // If this is a named positional argument, just remember that it is the
1277 if (Handler
->getFormattingFlag() == cl::Positional
) {
1278 if ((Handler
->getMiscFlags() & PositionalEatsArgs
) && !Value
.empty()) {
1279 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 ErrorParsing
= true;
1284 ActivePositionalArg
= Handler
;
1287 ErrorParsing
|= ProvideOption(Handler
, ArgName
, Value
, argc
, argv
, i
);
1290 // Check and handle positional arguments now...
1291 if (NumPositionalRequired
> PositionalVals
.size()) {
1292 *Errs
<< ProgramName
1293 << ": Not enough positional command line arguments specified!\n"
1294 << "Must specify at least " << NumPositionalRequired
1295 << " positional argument" << (NumPositionalRequired
> 1 ? "s" : "")
1296 << ": See: " << argv
[0] << " -help\n";
1298 ErrorParsing
= true;
1299 } else if (!HasUnlimitedPositionals
&&
1300 PositionalVals
.size() > PositionalOpts
.size()) {
1301 *Errs
<< ProgramName
<< ": Too many positional arguments specified!\n"
1302 << "Can specify at most " << PositionalOpts
.size()
1303 << " positional arguments: See: " << argv
[0] << " -help\n";
1304 ErrorParsing
= true;
1306 } 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 for (size_t i
= 0, e
= PositionalOpts
.size(); i
!= e
; ++i
) {
1310 if (RequiresValue(PositionalOpts
[i
])) {
1311 ProvidePositionalOption(PositionalOpts
[i
], PositionalVals
[ValNo
].first
,
1312 PositionalVals
[ValNo
].second
);
1314 --NumPositionalRequired
; // We fulfilled our duty...
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.
1321 bool Done
= PositionalOpts
[i
]->getNumOccurrencesFlag() == cl::Required
;
1322 while (NumVals
- ValNo
> NumPositionalRequired
&& !Done
) {
1323 switch (PositionalOpts
[i
]->getNumOccurrencesFlag()) {
1325 Done
= true; // Optional arguments want _at most_ one value
1327 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 ProvidePositionalOption(PositionalOpts
[i
],
1330 PositionalVals
[ValNo
].first
,
1331 PositionalVals
[ValNo
].second
);
1335 llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
1336 "positional argument processing!");
1341 assert(ConsumeAfterOpt
&& NumPositionalRequired
<= PositionalVals
.size());
1343 for (size_t j
= 1, e
= PositionalOpts
.size(); j
!= e
; ++j
)
1344 if (RequiresValue(PositionalOpts
[j
])) {
1345 ErrorParsing
|= ProvidePositionalOption(PositionalOpts
[j
],
1346 PositionalVals
[ValNo
].first
,
1347 PositionalVals
[ValNo
].second
);
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.
1356 if (PositionalOpts
.size() == 1 && ValNo
== 0 && !PositionalVals
.empty()) {
1357 ErrorParsing
|= ProvidePositionalOption(PositionalOpts
[0],
1358 PositionalVals
[ValNo
].first
,
1359 PositionalVals
[ValNo
].second
);
1363 // Handle over all of the rest of the arguments to the
1364 // cl::ConsumeAfter command line option...
1365 for (; ValNo
!= PositionalVals
.size(); ++ValNo
)
1367 ProvidePositionalOption(ConsumeAfterOpt
, PositionalVals
[ValNo
].first
,
1368 PositionalVals
[ValNo
].second
);
1371 // Loop over args and make sure all required args are specified!
1372 for (const auto &Opt
: OptionsMap
) {
1373 switch (Opt
.second
->getNumOccurrencesFlag()) {
1376 if (Opt
.second
->getNumOccurrences() == 0) {
1377 Opt
.second
->error("must be specified at least once!");
1378 ErrorParsing
= true;
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
] << ' ';
1393 // Free all of the memory allocated to the map. Command line options may only
1394 // be processed once!
1397 // If we had an error processing our arguments, don't let the program execute
1406 //===----------------------------------------------------------------------===//
1407 // Option Base class implementation
1410 bool Option::error(const Twine
&Message
, StringRef ArgName
, raw_ostream
&Errs
) {
1411 if (!ArgName
.data())
1413 if (ArgName
.empty())
1414 Errs
<< HelpStr
; // Be nice for positional arguments
1416 Errs
<< GlobalParser
->ProgramName
<< ": for the -" << ArgName
;
1418 Errs
<< " option: " << Message
<< "\n";
1422 bool Option::addOccurrence(unsigned pos
, StringRef ArgName
, StringRef Value
,
1425 NumOccurrences
++; // Increment the number of times we have been seen
1427 switch (getNumOccurrencesFlag()) {
1429 if (NumOccurrences
> 1)
1430 return error("may only occur zero or one times!", ArgName
);
1433 if (NumOccurrences
> 1)
1434 return error("must occur exactly one time!", ArgName
);
1442 return handleOccurrence(pos
, ArgName
, Value
);
1445 // getValueStr - Get the value description string, using "DefaultMsg" if nothing
1446 // has been specified yet.
1448 static StringRef
getValueStr(const Option
&O
, StringRef DefaultMsg
) {
1449 if (O
.ValueStr
.empty())
1454 //===----------------------------------------------------------------------===//
1455 // cl::alias class implementation
1458 // Return the width of the option tag for printing...
1459 size_t alias::getOptionWidth() const { return ArgStr
.size() + 6; }
1461 void Option::printHelpStr(StringRef HelpStr
, size_t Indent
,
1462 size_t FirstLineIndentedBy
) {
1463 std::pair
<StringRef
, StringRef
> Split
= HelpStr
.split('\n');
1464 outs().indent(Indent
- FirstLineIndentedBy
) << " - " << Split
.first
<< "\n";
1465 while (!Split
.second
.empty()) {
1466 Split
= Split
.second
.split('\n');
1467 outs().indent(Indent
) << Split
.first
<< "\n";
1471 // Print out the option for the alias.
1472 void alias::printOptionInfo(size_t GlobalWidth
) const {
1473 outs() << " -" << ArgStr
;
1474 printHelpStr(HelpStr
, GlobalWidth
, ArgStr
.size() + 6);
1477 //===----------------------------------------------------------------------===//
1478 // Parser Implementation code...
1481 // basic_parser implementation
1484 // Return the width of the option tag for printing...
1485 size_t basic_parser_impl::getOptionWidth(const Option
&O
) const {
1486 size_t Len
= O
.ArgStr
.size();
1487 auto ValName
= getValueName();
1488 if (!ValName
.empty()) {
1489 size_t FormattingLen
= 3;
1490 if (O
.getMiscFlags() & PositionalEatsArgs
)
1492 Len
+= getValueStr(O
, ValName
).size() + FormattingLen
;
1498 // printOptionInfo - Print out information about this option. The
1499 // to-be-maintained width is specified.
1501 void basic_parser_impl::printOptionInfo(const Option
&O
,
1502 size_t GlobalWidth
) const {
1503 outs() << " -" << O
.ArgStr
;
1505 auto ValName
= getValueName();
1506 if (!ValName
.empty()) {
1507 if (O
.getMiscFlags() & PositionalEatsArgs
) {
1508 outs() << " <" << getValueStr(O
, ValName
) << ">...";
1510 outs() << "=<" << getValueStr(O
, ValName
) << '>';
1514 Option::printHelpStr(O
.HelpStr
, GlobalWidth
, getOptionWidth(O
));
1517 void basic_parser_impl::printOptionName(const Option
&O
,
1518 size_t GlobalWidth
) const {
1519 outs() << " -" << O
.ArgStr
;
1520 outs().indent(GlobalWidth
- O
.ArgStr
.size());
1523 // parser<bool> implementation
1525 bool parser
<bool>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1527 if (Arg
== "" || Arg
== "true" || Arg
== "TRUE" || Arg
== "True" ||
1533 if (Arg
== "false" || Arg
== "FALSE" || Arg
== "False" || Arg
== "0") {
1537 return O
.error("'" + Arg
+
1538 "' is invalid value for boolean argument! Try 0 or 1");
1541 // parser<boolOrDefault> implementation
1543 bool parser
<boolOrDefault
>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1544 boolOrDefault
&Value
) {
1545 if (Arg
== "" || Arg
== "true" || Arg
== "TRUE" || Arg
== "True" ||
1550 if (Arg
== "false" || Arg
== "FALSE" || Arg
== "False" || Arg
== "0") {
1555 return O
.error("'" + Arg
+
1556 "' is invalid value for boolean argument! Try 0 or 1");
1559 // parser<int> implementation
1561 bool parser
<int>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1563 if (Arg
.getAsInteger(0, Value
))
1564 return O
.error("'" + Arg
+ "' value invalid for integer argument!");
1568 // parser<unsigned> implementation
1570 bool parser
<unsigned>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1573 if (Arg
.getAsInteger(0, Value
))
1574 return O
.error("'" + Arg
+ "' value invalid for uint argument!");
1578 // parser<unsigned long long> implementation
1580 bool parser
<unsigned long long>::parse(Option
&O
, StringRef ArgName
,
1582 unsigned long long &Value
) {
1584 if (Arg
.getAsInteger(0, Value
))
1585 return O
.error("'" + Arg
+ "' value invalid for uint argument!");
1589 // parser<double>/parser<float> implementation
1591 static bool parseDouble(Option
&O
, StringRef Arg
, double &Value
) {
1592 if (to_float(Arg
, Value
))
1594 return O
.error("'" + Arg
+ "' value invalid for floating point argument!");
1597 bool parser
<double>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1599 return parseDouble(O
, Arg
, Val
);
1602 bool parser
<float>::parse(Option
&O
, StringRef ArgName
, StringRef Arg
,
1605 if (parseDouble(O
, Arg
, dVal
))
1611 // generic_parser_base implementation
1614 // findOption - Return the option number corresponding to the specified
1615 // argument string. If the option is not found, getNumOptions() is returned.
1617 unsigned generic_parser_base::findOption(StringRef Name
) {
1618 unsigned e
= getNumOptions();
1620 for (unsigned i
= 0; i
!= e
; ++i
) {
1621 if (getOption(i
) == Name
)
1627 // Return the width of the option tag for printing...
1628 size_t generic_parser_base::getOptionWidth(const Option
&O
) const {
1629 if (O
.hasArgStr()) {
1630 size_t Size
= O
.ArgStr
.size() + 6;
1631 for (unsigned i
= 0, e
= getNumOptions(); i
!= e
; ++i
)
1632 Size
= std::max(Size
, getOption(i
).size() + 8);
1635 size_t BaseSize
= 0;
1636 for (unsigned i
= 0, e
= getNumOptions(); i
!= e
; ++i
)
1637 BaseSize
= std::max(BaseSize
, getOption(i
).size() + 8);
1642 // printOptionInfo - Print out information about this option. The
1643 // to-be-maintained width is specified.
1645 void generic_parser_base::printOptionInfo(const Option
&O
,
1646 size_t GlobalWidth
) const {
1647 if (O
.hasArgStr()) {
1648 outs() << " -" << O
.ArgStr
;
1649 Option::printHelpStr(O
.HelpStr
, GlobalWidth
, O
.ArgStr
.size() + 6);
1651 for (unsigned i
= 0, e
= getNumOptions(); i
!= e
; ++i
) {
1652 size_t NumSpaces
= GlobalWidth
- getOption(i
).size() - 8;
1653 outs() << " =" << getOption(i
);
1654 outs().indent(NumSpaces
) << " - " << getDescription(i
) << '\n';
1657 if (!O
.HelpStr
.empty())
1658 outs() << " " << O
.HelpStr
<< '\n';
1659 for (unsigned i
= 0, e
= getNumOptions(); i
!= e
; ++i
) {
1660 auto Option
= getOption(i
);
1661 outs() << " -" << Option
;
1662 Option::printHelpStr(getDescription(i
), GlobalWidth
, Option
.size() + 8);
1667 static const size_t MaxOptWidth
= 8; // arbitrary spacing for printOptionDiff
1669 // printGenericOptionDiff - Print the value of this option and it's default.
1671 // "Generic" options have each value mapped to a name.
1672 void generic_parser_base::printGenericOptionDiff(
1673 const Option
&O
, const GenericOptionValue
&Value
,
1674 const GenericOptionValue
&Default
, size_t GlobalWidth
) const {
1675 outs() << " -" << O
.ArgStr
;
1676 outs().indent(GlobalWidth
- O
.ArgStr
.size());
1678 unsigned NumOpts
= getNumOptions();
1679 for (unsigned i
= 0; i
!= NumOpts
; ++i
) {
1680 if (Value
.compare(getOptionValue(i
)))
1683 outs() << "= " << getOption(i
);
1684 size_t L
= getOption(i
).size();
1685 size_t NumSpaces
= MaxOptWidth
> L
? MaxOptWidth
- L
: 0;
1686 outs().indent(NumSpaces
) << " (default: ";
1687 for (unsigned j
= 0; j
!= NumOpts
; ++j
) {
1688 if (Default
.compare(getOptionValue(j
)))
1690 outs() << getOption(j
);
1696 outs() << "= *unknown option value*\n";
1699 // printOptionDiff - Specializations for printing basic value types.
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); \
1707 raw_string_ostream SS(Str); \
1710 outs() << "= " << Str; \
1711 size_t NumSpaces = \
1712 MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \
1713 outs().indent(NumSpaces) << " (default: "; \
1715 outs() << D.getValue(); \
1717 outs() << "*no default*"; \
1721 PRINT_OPT_DIFF(bool)
1722 PRINT_OPT_DIFF(boolOrDefault
)
1724 PRINT_OPT_DIFF(unsigned)
1725 PRINT_OPT_DIFF(unsigned long long)
1726 PRINT_OPT_DIFF(double)
1727 PRINT_OPT_DIFF(float)
1728 PRINT_OPT_DIFF(char)
1730 void parser
<std::string
>::printOptionDiff(const Option
&O
, StringRef V
,
1731 const OptionValue
<std::string
> &D
,
1732 size_t GlobalWidth
) const {
1733 printOptionName(O
, GlobalWidth
);
1734 outs() << "= " << V
;
1735 size_t NumSpaces
= MaxOptWidth
> V
.size() ? MaxOptWidth
- V
.size() : 0;
1736 outs().indent(NumSpaces
) << " (default: ";
1738 outs() << D
.getValue();
1740 outs() << "*no default*";
1744 // Print a placeholder for options that don't yet support printOptionDiff().
1745 void basic_parser_impl::printOptionNoValue(const Option
&O
,
1746 size_t GlobalWidth
) const {
1747 printOptionName(O
, GlobalWidth
);
1748 outs() << "= *cannot print option value*\n";
1751 //===----------------------------------------------------------------------===//
1752 // -help and -help-hidden option implementation
1755 static int OptNameCompare(const std::pair
<const char *, Option
*> *LHS
,
1756 const std::pair
<const char *, Option
*> *RHS
) {
1757 return strcmp(LHS
->first
, RHS
->first
);
1760 static int SubNameCompare(const std::pair
<const char *, SubCommand
*> *LHS
,
1761 const std::pair
<const char *, SubCommand
*> *RHS
) {
1762 return strcmp(LHS
->first
, RHS
->first
);
1765 // Copy Options into a vector so we can sort them as we like.
1766 static void sortOpts(StringMap
<Option
*> &OptMap
,
1767 SmallVectorImpl
<std::pair
<const char *, Option
*>> &Opts
,
1769 SmallPtrSet
<Option
*, 32> OptionSet
; // Duplicate option detection.
1771 for (StringMap
<Option
*>::iterator I
= OptMap
.begin(), E
= OptMap
.end();
1773 // Ignore really-hidden options.
1774 if (I
->second
->getOptionHiddenFlag() == ReallyHidden
)
1777 // Unless showhidden is set, ignore hidden flags.
1778 if (I
->second
->getOptionHiddenFlag() == Hidden
&& !ShowHidden
)
1781 // If we've already seen this option, don't add it to the list again.
1782 if (!OptionSet
.insert(I
->second
).second
)
1786 std::pair
<const char *, Option
*>(I
->getKey().data(), I
->second
));
1789 // Sort the options list alphabetically.
1790 array_pod_sort(Opts
.begin(), Opts
.end(), OptNameCompare
);
1794 sortSubCommands(const SmallPtrSetImpl
<SubCommand
*> &SubMap
,
1795 SmallVectorImpl
<std::pair
<const char *, SubCommand
*>> &Subs
) {
1796 for (const auto &S
: SubMap
) {
1797 if (S
->getName().empty())
1799 Subs
.push_back(std::make_pair(S
->getName().data(), S
));
1801 array_pod_sort(Subs
.begin(), Subs
.end(), SubNameCompare
);
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 virtual void printOptions(StrOptionPairVector
&Opts
, size_t MaxArgLen
) {
1815 for (size_t i
= 0, e
= Opts
.size(); i
!= e
; ++i
)
1816 Opts
[i
].second
->printOptionInfo(MaxArgLen
);
1819 void printSubCommands(StrSubCommandPairVector
&Subs
, size_t MaxSubLen
) {
1820 for (const auto &S
: Subs
) {
1821 outs() << " " << S
.first
;
1822 if (!S
.second
->getDescription().empty()) {
1823 outs().indent(MaxSubLen
- strlen(S
.first
));
1824 outs() << " - " << S
.second
->getDescription();
1831 explicit HelpPrinter(bool showHidden
) : ShowHidden(showHidden
) {}
1832 virtual ~HelpPrinter() {}
1834 // Invoke the printer.
1835 void operator=(bool Value
) {
1840 // Halt the program since help information was printed
1845 SubCommand
*Sub
= GlobalParser
->getActiveSubCommand();
1846 auto &OptionsMap
= Sub
->OptionsMap
;
1847 auto &PositionalOpts
= Sub
->PositionalOpts
;
1848 auto &ConsumeAfterOpt
= Sub
->ConsumeAfterOpt
;
1850 StrOptionPairVector Opts
;
1851 sortOpts(OptionsMap
, Opts
, ShowHidden
);
1853 StrSubCommandPairVector Subs
;
1854 sortSubCommands(GlobalParser
->RegisteredSubCommands
, Subs
);
1856 if (!GlobalParser
->ProgramOverview
.empty())
1857 outs() << "OVERVIEW: " << GlobalParser
->ProgramOverview
<< "\n";
1859 if (Sub
== &*TopLevelSubCommand
) {
1860 outs() << "USAGE: " << GlobalParser
->ProgramName
;
1861 if (Subs
.size() > 2)
1862 outs() << " [subcommand]";
1863 outs() << " [options]";
1865 if (!Sub
->getDescription().empty()) {
1866 outs() << "SUBCOMMAND '" << Sub
->getName()
1867 << "': " << Sub
->getDescription() << "\n\n";
1869 outs() << "USAGE: " << GlobalParser
->ProgramName
<< " " << Sub
->getName()
1873 for (auto Opt
: PositionalOpts
) {
1874 if (Opt
->hasArgStr())
1875 outs() << " --" << Opt
->ArgStr
;
1876 outs() << " " << Opt
->HelpStr
;
1879 // Print the consume after option info if it exists...
1880 if (ConsumeAfterOpt
)
1881 outs() << " " << ConsumeAfterOpt
->HelpStr
;
1883 if (Sub
== &*TopLevelSubCommand
&& !Subs
.empty()) {
1884 // Compute the maximum subcommand length...
1885 size_t MaxSubLen
= 0;
1886 for (size_t i
= 0, e
= Subs
.size(); i
!= e
; ++i
)
1887 MaxSubLen
= std::max(MaxSubLen
, strlen(Subs
[i
].first
));
1890 outs() << "SUBCOMMANDS:\n\n";
1891 printSubCommands(Subs
, MaxSubLen
);
1893 outs() << " Type \"" << GlobalParser
->ProgramName
1894 << " <subcommand> -help\" to get more help on a specific "
1900 // Compute the maximum argument length...
1901 size_t MaxArgLen
= 0;
1902 for (size_t i
= 0, e
= Opts
.size(); i
!= e
; ++i
)
1903 MaxArgLen
= std::max(MaxArgLen
, Opts
[i
].second
->getOptionWidth());
1905 outs() << "OPTIONS:\n";
1906 printOptions(Opts
, MaxArgLen
);
1908 // Print any extra help the user has declared.
1909 for (auto I
: GlobalParser
->MoreHelp
)
1911 GlobalParser
->MoreHelp
.clear();
1915 class CategorizedHelpPrinter
: public HelpPrinter
{
1917 explicit CategorizedHelpPrinter(bool showHidden
) : HelpPrinter(showHidden
) {}
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 static int OptionCategoryCompare(OptionCategory
*const *A
,
1924 OptionCategory
*const *B
) {
1925 return (*A
)->getName().compare((*B
)->getName());
1928 // Make sure we inherit our base class's operator=()
1929 using HelpPrinter::operator=;
1932 void printOptions(StrOptionPairVector
&Opts
, size_t MaxArgLen
) override
{
1933 std::vector
<OptionCategory
*> SortedCategories
;
1934 std::map
<OptionCategory
*, std::vector
<Option
*>> CategorizedOptions
;
1936 // Collect registered option categories into vector in preparation for
1938 for (auto I
= GlobalParser
->RegisteredOptionCategories
.begin(),
1939 E
= GlobalParser
->RegisteredOptionCategories
.end();
1941 SortedCategories
.push_back(*I
);
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
);
1949 // Create map to empty vectors.
1950 for (std::vector
<OptionCategory
*>::const_iterator
1951 I
= SortedCategories
.begin(),
1952 E
= SortedCategories
.end();
1954 CategorizedOptions
[*I
] = std::vector
<Option
*>();
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 for (size_t I
= 0, E
= Opts
.size(); I
!= E
; ++I
) {
1960 Option
*Opt
= Opts
[I
].second
;
1961 assert(CategorizedOptions
.count(Opt
->Category
) > 0 &&
1962 "Option has an unregistered category");
1963 CategorizedOptions
[Opt
->Category
].push_back(Opt
);
1967 for (std::vector
<OptionCategory
*>::const_iterator
1968 Category
= SortedCategories
.begin(),
1969 E
= SortedCategories
.end();
1970 Category
!= E
; ++Category
) {
1971 // Hide empty categories for -help, but show for -help-hidden.
1972 const auto &CategoryOptions
= CategorizedOptions
[*Category
];
1973 bool IsEmptyCategory
= CategoryOptions
.empty();
1974 if (!ShowHidden
&& IsEmptyCategory
)
1977 // Print category information.
1979 outs() << (*Category
)->getName() << ":\n";
1981 // Check if description is set.
1982 if (!(*Category
)->getDescription().empty())
1983 outs() << (*Category
)->getDescription() << "\n\n";
1987 // When using -help-hidden explicitly state if the category has no
1988 // options associated with it.
1989 if (IsEmptyCategory
) {
1990 outs() << " This option category has no options.\n";
1993 // Loop over the options in the category and print.
1994 for (const Option
*Opt
: CategoryOptions
)
1995 Opt
->printOptionInfo(MaxArgLen
);
2000 // This wraps the Uncategorizing and Categorizing printers and decides
2001 // at run time which should be invoked.
2002 class HelpPrinterWrapper
{
2004 HelpPrinter
&UncategorizedPrinter
;
2005 CategorizedHelpPrinter
&CategorizedPrinter
;
2008 explicit HelpPrinterWrapper(HelpPrinter
&UncategorizedPrinter
,
2009 CategorizedHelpPrinter
&CategorizedPrinter
)
2010 : UncategorizedPrinter(UncategorizedPrinter
),
2011 CategorizedPrinter(CategorizedPrinter
) {}
2013 // Invoke the printer.
2014 void operator=(bool Value
);
2017 } // End anonymous namespace
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);
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
);
2033 // Define a category for generic options that all tools should have.
2034 static cl::OptionCategory
GenericCategory("Generic Options");
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(
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
));
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
));
2051 // Define uncategorized/categorized help printers. These printers change their
2052 // behaviour at runtime depending on whether one or more Option categories have
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
));
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
));
2064 static cl::opt
<bool> PrintOptions(
2066 cl::desc("Print non-default options after command line parsing"),
2067 cl::Hidden
, cl::init(false), cl::cat(GenericCategory
),
2068 cl::sub(*AllSubCommands
));
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
));
2075 void HelpPrinterWrapper::operator=(bool Value
) {
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 if (GlobalParser
->RegisteredOptionCategories
.size() > 1) {
2083 // unhide -help-list option so user can have uncategorized output if they
2085 HLOp
.setHiddenFlag(NotHidden
);
2087 CategorizedPrinter
= true; // Invoke categorized printer
2089 UncategorizedPrinter
= true; // Invoke uncategorized printer
2092 // Print the value of each option.
2093 void cl::PrintOptionValues() { GlobalParser
->printOptionValues(); }
2095 void CommandLineParser::printOptionValues() {
2096 if (!PrintOptions
&& !PrintAllOptions
)
2099 SmallVector
<std::pair
<const char *, Option
*>, 128> Opts
;
2100 sortOpts(ActiveSubCommand
->OptionsMap
, Opts
, /*ShowHidden*/ true);
2102 // Compute the maximum argument length...
2103 size_t MaxArgLen
= 0;
2104 for (size_t i
= 0, e
= Opts
.size(); i
!= e
; ++i
)
2105 MaxArgLen
= std::max(MaxArgLen
, Opts
[i
].second
->getOptionWidth());
2107 for (size_t i
= 0, e
= Opts
.size(); i
!= e
; ++i
)
2108 Opts
[i
].second
->printOptionValue(MaxArgLen
, PrintAllOptions
);
2111 static VersionPrinterTy OverrideVersionPrinter
= nullptr;
2113 static std::vector
<VersionPrinterTy
> *ExtraVersionPrinters
= nullptr;
2116 class VersionPrinter
{
2119 raw_ostream
&OS
= outs();
2120 #ifdef PACKAGE_VENDOR
2121 OS
<< PACKAGE_VENDOR
<< " ";
2123 OS
<< "LLVM (http://llvm.org/):\n ";
2125 OS
<< PACKAGE_NAME
<< " version " << PACKAGE_VERSION
;
2126 #ifdef LLVM_VERSION_INFO
2127 OS
<< " " << LLVM_VERSION_INFO
;
2130 #ifndef __OPTIMIZE__
2131 OS
<< "DEBUG build";
2133 OS
<< "Optimized build";
2136 OS
<< " with assertions";
2138 #if LLVM_VERSION_PRINTER_SHOW_HOST_TARGET_INFO
2139 std::string CPU
= sys::getHostCPUName();
2140 if (CPU
== "generic")
2143 << " Default target: " << sys::getDefaultTargetTriple() << '\n'
2144 << " Host CPU: " << CPU
;
2148 void operator=(bool OptionWasSpecified
) {
2149 if (!OptionWasSpecified
)
2152 if (OverrideVersionPrinter
!= nullptr) {
2153 OverrideVersionPrinter(outs());
2158 // Iterate over any registered extra printers and call them to add further
2160 if (ExtraVersionPrinters
!= nullptr) {
2162 for (auto I
: *ExtraVersionPrinters
)
2169 } // End anonymous namespace
2171 // Define the --version option that prints out the LLVM version for the tool
2172 static VersionPrinter VersionPrinterInstance
;
2174 static cl::opt
<VersionPrinter
, true, parser
<bool>>
2175 VersOp("version", cl::desc("Display the version of this program"),
2176 cl::location(VersionPrinterInstance
), cl::ValueDisallowed
,
2177 cl::cat(GenericCategory
));
2179 // Utility function for printing the help message.
2180 void cl::PrintHelpMessage(bool Hidden
, bool Categorized
) {
2181 if (!Hidden
&& !Categorized
)
2182 UncategorizedNormalPrinter
.printHelp();
2183 else if (!Hidden
&& Categorized
)
2184 CategorizedNormalPrinter
.printHelp();
2185 else if (Hidden
&& !Categorized
)
2186 UncategorizedHiddenPrinter
.printHelp();
2188 CategorizedHiddenPrinter
.printHelp();
2191 /// Utility function for printing version number.
2192 void cl::PrintVersionMessage() { VersionPrinterInstance
.print(); }
2194 void cl::SetVersionPrinter(VersionPrinterTy func
) { OverrideVersionPrinter
= func
; }
2196 void cl::AddExtraVersionPrinter(VersionPrinterTy func
) {
2197 if (!ExtraVersionPrinters
)
2198 ExtraVersionPrinters
= new std::vector
<VersionPrinterTy
>;
2200 ExtraVersionPrinters
->push_back(func
);
2203 StringMap
<Option
*> &cl::getRegisteredOptions(SubCommand
&Sub
) {
2204 auto &Subs
= GlobalParser
->RegisteredSubCommands
;
2206 assert(is_contained(Subs
, &Sub
));
2207 return Sub
.OptionsMap
;
2210 iterator_range
<typename SmallPtrSet
<SubCommand
*, 4>::iterator
>
2211 cl::getRegisteredSubcommands() {
2212 return GlobalParser
->getRegisteredSubcommands();
2215 void cl::HideUnrelatedOptions(cl::OptionCategory
&Category
, SubCommand
&Sub
) {
2216 for (auto &I
: Sub
.OptionsMap
) {
2217 if (I
.second
->Category
!= &Category
&&
2218 I
.second
->Category
!= &GenericCategory
)
2219 I
.second
->setHiddenFlag(cl::ReallyHidden
);
2223 void cl::HideUnrelatedOptions(ArrayRef
<const cl::OptionCategory
*> Categories
,
2225 auto CategoriesBegin
= Categories
.begin();
2226 auto CategoriesEnd
= Categories
.end();
2227 for (auto &I
: Sub
.OptionsMap
) {
2228 if (std::find(CategoriesBegin
, CategoriesEnd
, I
.second
->Category
) ==
2230 I
.second
->Category
!= &GenericCategory
)
2231 I
.second
->setHiddenFlag(cl::ReallyHidden
);
2235 void cl::ResetCommandLineParser() { GlobalParser
->reset(); }
2236 void cl::ResetAllOptionOccurrences() {
2237 GlobalParser
->ResetAllOptionOccurrences();
2240 void LLVMParseCommandLineOptions(int argc
, const char *const *argv
,
2241 const char *Overview
) {
2242 llvm::cl::ParseCommandLineOptions(argc
, argv
, StringRef(Overview
),