LLVM API Documentation

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CommandLine.cpp
Go to the documentation of this file.
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 
20 #include "llvm/ADT/ArrayRef.h"
21 #include "llvm/ADT/OwningPtr.h"
22 #include "llvm/ADT/SmallPtrSet.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringMap.h"
25 #include "llvm/ADT/Twine.h"
26 #include "llvm/Config/config.h"
28 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/Host.h"
33 #include "llvm/Support/Path.h"
36 #include <cerrno>
37 #include <cstdlib>
38 #include <map>
39 using namespace llvm;
40 using namespace cl;
41 
42 //===----------------------------------------------------------------------===//
43 // Template instantiations and anchors.
44 //
45 namespace llvm { namespace cl {
55 
61 } } // end namespace llvm::cl
62 
63 // Pin the vtables to this file.
64 void GenericOptionValue::anchor() {}
67 void Option::anchor() {}
69 void parser<bool>::anchor() {}
71 void parser<int>::anchor() {}
74 void parser<double>::anchor() {}
75 void parser<float>::anchor() {}
77 void parser<char>::anchor() {}
78 void StringSaver::anchor() {}
79 
80 //===----------------------------------------------------------------------===//
81 
82 // Globals for name and overview of program. Program name is not a string to
83 // avoid static ctor/dtor issues.
84 static char ProgramName[80] = "<premain>";
85 static const char *ProgramOverview = 0;
86 
87 // This collects additional help to be printed.
89 
91  : morehelp(Help) {
92  MoreHelp->push_back(Help);
93 }
94 
95 static bool OptionListChanged = false;
96 
97 // MarkOptionsChanged - Internal helper function.
99  OptionListChanged = true;
100 }
101 
102 /// RegisteredOptionList - This is the list of the command line options that
103 /// have statically constructed themselves.
105 
107  assert(NextRegistered == 0 && "argument multiply registered!");
108 
109  NextRegistered = RegisteredOptionList;
110  RegisteredOptionList = this;
112 }
113 
114 // This collects the different option categories that have been registered.
117 
118 // Initialise the general option category.
119 OptionCategory llvm::cl::GeneralCategory("General options");
120 
121 void OptionCategory::registerCategory()
122 {
123  RegisteredOptionCategories->insert(this);
124 }
125 
126 //===----------------------------------------------------------------------===//
127 // Basic, shared command line option processing machinery.
128 //
129 
130 /// GetOptionInfo - Scan the list of registered options, turning them into data
131 /// structures that are easier to handle.
132 static void GetOptionInfo(SmallVectorImpl<Option*> &PositionalOpts,
133  SmallVectorImpl<Option*> &SinkOpts,
134  StringMap<Option*> &OptionsMap) {
135  SmallVector<const char*, 16> OptionNames;
136  Option *CAOpt = 0; // The ConsumeAfter option if it exists.
137  for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) {
138  // If this option wants to handle multiple option names, get the full set.
139  // This handles enum options like "-O1 -O2" etc.
140  O->getExtraOptionNames(OptionNames);
141  if (O->ArgStr[0])
142  OptionNames.push_back(O->ArgStr);
143 
144  // Handle named options.
145  for (size_t i = 0, e = OptionNames.size(); i != e; ++i) {
146  // Add argument to the argument map!
147  if (OptionsMap.GetOrCreateValue(OptionNames[i], O).second != O) {
148  errs() << ProgramName << ": CommandLine Error: Argument '"
149  << OptionNames[i] << "' defined more than once!\n";
150  }
151  }
152 
153  OptionNames.clear();
154 
155  // Remember information about positional options.
156  if (O->getFormattingFlag() == cl::Positional)
157  PositionalOpts.push_back(O);
158  else if (O->getMiscFlags() & cl::Sink) // Remember sink options
159  SinkOpts.push_back(O);
160  else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) {
161  if (CAOpt)
162  O->error("Cannot specify more than one option with cl::ConsumeAfter!");
163  CAOpt = O;
164  }
165  }
166 
167  if (CAOpt)
168  PositionalOpts.push_back(CAOpt);
169 
170  // Make sure that they are in order of registration not backwards.
171  std::reverse(PositionalOpts.begin(), PositionalOpts.end());
172 }
173 
174 
175 /// LookupOption - Lookup the option specified by the specified option on the
176 /// command line. If there is a value specified (after an equal sign) return
177 /// that as well. This assumes that leading dashes have already been stripped.
179  const StringMap<Option*> &OptionsMap) {
180  // Reject all dashes.
181  if (Arg.empty()) return 0;
182 
183  size_t EqualPos = Arg.find('=');
184 
185  // If we have an equals sign, remember the value.
186  if (EqualPos == StringRef::npos) {
187  // Look up the option.
188  StringMap<Option*>::const_iterator I = OptionsMap.find(Arg);
189  return I != OptionsMap.end() ? I->second : 0;
190  }
191 
192  // If the argument before the = is a valid option name, we match. If not,
193  // return Arg unmolested.
195  OptionsMap.find(Arg.substr(0, EqualPos));
196  if (I == OptionsMap.end()) return 0;
197 
198  Value = Arg.substr(EqualPos+1);
199  Arg = Arg.substr(0, EqualPos);
200  return I->second;
201 }
202 
203 /// LookupNearestOption - Lookup the closest match to the option specified by
204 /// the specified option on the command line. If there is a value specified
205 /// (after an equal sign) return that as well. This assumes that leading dashes
206 /// have already been stripped.
208  const StringMap<Option*> &OptionsMap,
209  std::string &NearestString) {
210  // Reject all dashes.
211  if (Arg.empty()) return 0;
212 
213  // Split on any equal sign.
214  std::pair<StringRef, StringRef> SplitArg = Arg.split('=');
215  StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present.
216  StringRef &RHS = SplitArg.second;
217 
218  // Find the closest match.
219  Option *Best = 0;
220  unsigned BestDistance = 0;
221  for (StringMap<Option*>::const_iterator it = OptionsMap.begin(),
222  ie = OptionsMap.end(); it != ie; ++it) {
223  Option *O = it->second;
224  SmallVector<const char*, 16> OptionNames;
225  O->getExtraOptionNames(OptionNames);
226  if (O->ArgStr[0])
227  OptionNames.push_back(O->ArgStr);
228 
229  bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed;
230  StringRef Flag = PermitValue ? LHS : Arg;
231  for (size_t i = 0, e = OptionNames.size(); i != e; ++i) {
232  StringRef Name = OptionNames[i];
233  unsigned Distance = StringRef(Name).edit_distance(
234  Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance);
235  if (!Best || Distance < BestDistance) {
236  Best = O;
237  BestDistance = Distance;
238  if (RHS.empty() || !PermitValue)
239  NearestString = OptionNames[i];
240  else
241  NearestString = std::string(OptionNames[i]) + "=" + RHS.str();
242  }
243  }
244  }
245 
246  return Best;
247 }
248 
249 /// CommaSeparateAndAddOccurence - A wrapper around Handler->addOccurence() that
250 /// does special handling of cl::CommaSeparated options.
251 static bool CommaSeparateAndAddOccurence(Option *Handler, unsigned pos,
252  StringRef ArgName,
253  StringRef Value, bool MultiArg = false)
254 {
255  // Check to see if this option accepts a comma separated list of values. If
256  // it does, we have to split up the value into multiple values.
257  if (Handler->getMiscFlags() & CommaSeparated) {
258  StringRef Val(Value);
259  StringRef::size_type Pos = Val.find(',');
260 
261  while (Pos != StringRef::npos) {
262  // Process the portion before the comma.
263  if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg))
264  return true;
265  // Erase the portion before the comma, AND the comma.
266  Val = Val.substr(Pos+1);
267  Value.substr(Pos+1); // Increment the original value pointer as well.
268  // Check for another comma.
269  Pos = Val.find(',');
270  }
271 
272  Value = Val;
273  }
274 
275  if (Handler->addOccurrence(pos, ArgName, Value, MultiArg))
276  return true;
277 
278  return false;
279 }
280 
281 /// ProvideOption - For Value, this differentiates between an empty value ("")
282 /// and a null value (StringRef()). The later is accepted for arguments that
283 /// don't allow a value (-foo) the former is rejected (-foo=).
284 static inline bool ProvideOption(Option *Handler, StringRef ArgName,
285  StringRef Value, int argc,
286  const char *const *argv, int &i) {
287  // Is this a multi-argument option?
288  unsigned NumAdditionalVals = Handler->getNumAdditionalVals();
289 
290  // Enforce value requirements
291  switch (Handler->getValueExpectedFlag()) {
292  case ValueRequired:
293  if (Value.data() == 0) { // No value specified?
294  if (i+1 >= argc)
295  return Handler->error("requires a value!");
296  // Steal the next argument, like for '-o filename'
297  Value = argv[++i];
298  }
299  break;
300  case ValueDisallowed:
301  if (NumAdditionalVals > 0)
302  return Handler->error("multi-valued option specified"
303  " with ValueDisallowed modifier!");
304 
305  if (Value.data())
306  return Handler->error("does not allow a value! '" +
307  Twine(Value) + "' specified.");
308  break;
309  case ValueOptional:
310  break;
311  }
312 
313  // If this isn't a multi-arg option, just run the handler.
314  if (NumAdditionalVals == 0)
315  return CommaSeparateAndAddOccurence(Handler, i, ArgName, Value);
316 
317  // If it is, run the handle several times.
318  bool MultiArg = false;
319 
320  if (Value.data()) {
321  if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg))
322  return true;
323  --NumAdditionalVals;
324  MultiArg = true;
325  }
326 
327  while (NumAdditionalVals > 0) {
328  if (i+1 >= argc)
329  return Handler->error("not enough values!");
330  Value = argv[++i];
331 
332  if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg))
333  return true;
334  MultiArg = true;
335  --NumAdditionalVals;
336  }
337  return false;
338 }
339 
340 static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
341  int Dummy = i;
342  return ProvideOption(Handler, Handler->ArgStr, Arg, 0, 0, Dummy);
343 }
344 
345 
346 // Option predicates...
347 static inline bool isGrouping(const Option *O) {
348  return O->getFormattingFlag() == cl::Grouping;
349 }
350 static inline bool isPrefixedOrGrouping(const Option *O) {
351  return isGrouping(O) || O->getFormattingFlag() == cl::Prefix;
352 }
353 
354 // getOptionPred - Check to see if there are any options that satisfy the
355 // specified predicate with names that are the prefixes in Name. This is
356 // checked by progressively stripping characters off of the name, checking to
357 // see if there options that satisfy the predicate. If we find one, return it,
358 // otherwise return null.
359 //
360 static Option *getOptionPred(StringRef Name, size_t &Length,
361  bool (*Pred)(const Option*),
362  const StringMap<Option*> &OptionsMap) {
363 
364  StringMap<Option*>::const_iterator OMI = OptionsMap.find(Name);
365 
366  // Loop while we haven't found an option and Name still has at least two
367  // characters in it (so that the next iteration will not be the empty
368  // string.
369  while (OMI == OptionsMap.end() && Name.size() > 1) {
370  Name = Name.substr(0, Name.size()-1); // Chop off the last character.
371  OMI = OptionsMap.find(Name);
372  }
373 
374  if (OMI != OptionsMap.end() && Pred(OMI->second)) {
375  Length = Name.size();
376  return OMI->second; // Found one!
377  }
378  return 0; // No option found!
379 }
380 
381 /// HandlePrefixedOrGroupedOption - The specified argument string (which started
382 /// with at least one '-') does not fully match an available option. Check to
383 /// see if this is a prefix or grouped option. If so, split arg into output an
384 /// Arg/Value pair and return the Option to parse it with.
386  bool &ErrorParsing,
387  const StringMap<Option*> &OptionsMap) {
388  if (Arg.size() == 1) return 0;
389 
390  // Do the lookup!
391  size_t Length = 0;
392  Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap);
393  if (PGOpt == 0) return 0;
394 
395  // If the option is a prefixed option, then the value is simply the
396  // rest of the name... so fall through to later processing, by
397  // setting up the argument name flags and value fields.
398  if (PGOpt->getFormattingFlag() == cl::Prefix) {
399  Value = Arg.substr(Length);
400  Arg = Arg.substr(0, Length);
401  assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);
402  return PGOpt;
403  }
404 
405  // This must be a grouped option... handle them now. Grouping options can't
406  // have values.
407  assert(isGrouping(PGOpt) && "Broken getOptionPred!");
408 
409  do {
410  // Move current arg name out of Arg into OneArgName.
411  StringRef OneArgName = Arg.substr(0, Length);
412  Arg = Arg.substr(Length);
413 
414  // Because ValueRequired is an invalid flag for grouped arguments,
415  // we don't need to pass argc/argv in.
416  assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired &&
417  "Option can not be cl::Grouping AND cl::ValueRequired!");
418  int Dummy = 0;
419  ErrorParsing |= ProvideOption(PGOpt, OneArgName,
420  StringRef(), 0, 0, Dummy);
421 
422  // Get the next grouping option.
423  PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap);
424  } while (PGOpt && Length != Arg.size());
425 
426  // Return the last option with Arg cut down to just the last one.
427  return PGOpt;
428 }
429 
430 
431 
432 static bool RequiresValue(const Option *O) {
433  return O->getNumOccurrencesFlag() == cl::Required ||
435 }
436 
437 static bool EatsUnboundedNumberOfValues(const Option *O) {
438  return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
440 }
441 
442 static bool isWhitespace(char C) {
443  return strchr(" \t\n\r\f\v", C);
444 }
445 
446 static bool isQuote(char C) {
447  return C == '\"' || C == '\'';
448 }
449 
450 static bool isGNUSpecial(char C) {
451  return strchr("\\\"\' ", C);
452 }
453 
456  SmallString<128> Token;
457  for (size_t I = 0, E = Src.size(); I != E; ++I) {
458  // Consume runs of whitespace.
459  if (Token.empty()) {
460  while (I != E && isWhitespace(Src[I]))
461  ++I;
462  if (I == E) break;
463  }
464 
465  // Backslashes can escape backslashes, spaces, and other quotes. Otherwise
466  // they are literal. This makes it much easier to read Windows file paths.
467  if (I + 1 < E && Src[I] == '\\' && isGNUSpecial(Src[I + 1])) {
468  ++I; // Skip the escape.
469  Token.push_back(Src[I]);
470  continue;
471  }
472 
473  // Consume a quoted string.
474  if (isQuote(Src[I])) {
475  char Quote = Src[I++];
476  while (I != E && Src[I] != Quote) {
477  // Backslashes are literal, unless they escape a special character.
478  if (Src[I] == '\\' && I + 1 != E && isGNUSpecial(Src[I + 1]))
479  ++I;
480  Token.push_back(Src[I]);
481  ++I;
482  }
483  if (I == E) break;
484  continue;
485  }
486 
487  // End the token if this is whitespace.
488  if (isWhitespace(Src[I])) {
489  if (!Token.empty())
490  NewArgv.push_back(Saver.SaveString(Token.c_str()));
491  Token.clear();
492  continue;
493  }
494 
495  // This is a normal character. Append it.
496  Token.push_back(Src[I]);
497  }
498 
499  // Append the last token after hitting EOF with no whitespace.
500  if (!Token.empty())
501  NewArgv.push_back(Saver.SaveString(Token.c_str()));
502 }
503 
504 /// Backslashes are interpreted in a rather complicated way in the Windows-style
505 /// command line, because backslashes are used both to separate path and to
506 /// escape double quote. This method consumes runs of backslashes as well as the
507 /// following double quote if it's escaped.
508 ///
509 /// * If an even number of backslashes is followed by a double quote, one
510 /// backslash is output for every pair of backslashes, and the last double
511 /// quote remains unconsumed. The double quote will later be interpreted as
512 /// the start or end of a quoted string in the main loop outside of this
513 /// function.
514 ///
515 /// * If an odd number of backslashes is followed by a double quote, one
516 /// backslash is output for every pair of backslashes, and a double quote is
517 /// output for the last pair of backslash-double quote. The double quote is
518 /// consumed in this case.
519 ///
520 /// * Otherwise, backslashes are interpreted literally.
521 static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) {
522  size_t E = Src.size();
523  int BackslashCount = 0;
524  // Skip the backslashes.
525  do {
526  ++I;
527  ++BackslashCount;
528  } while (I != E && Src[I] == '\\');
529 
530  bool FollowedByDoubleQuote = (I != E && Src[I] == '"');
531  if (FollowedByDoubleQuote) {
532  Token.append(BackslashCount / 2, '\\');
533  if (BackslashCount % 2 == 0)
534  return I - 1;
535  Token.push_back('"');
536  return I;
537  }
538  Token.append(BackslashCount, '\\');
539  return I - 1;
540 }
541 
544  SmallString<128> Token;
545 
546  // This is a small state machine to consume characters until it reaches the
547  // end of the source string.
548  enum { INIT, UNQUOTED, QUOTED } State = INIT;
549  for (size_t I = 0, E = Src.size(); I != E; ++I) {
550  // INIT state indicates that the current input index is at the start of
551  // the string or between tokens.
552  if (State == INIT) {
553  if (isWhitespace(Src[I]))
554  continue;
555  if (Src[I] == '"') {
556  State = QUOTED;
557  continue;
558  }
559  if (Src[I] == '\\') {
560  I = parseBackslash(Src, I, Token);
561  State = UNQUOTED;
562  continue;
563  }
564  Token.push_back(Src[I]);
565  State = UNQUOTED;
566  continue;
567  }
568 
569  // UNQUOTED state means that it's reading a token not quoted by double
570  // quotes.
571  if (State == UNQUOTED) {
572  // Whitespace means the end of the token.
573  if (isWhitespace(Src[I])) {
574  NewArgv.push_back(Saver.SaveString(Token.c_str()));
575  Token.clear();
576  State = INIT;
577  continue;
578  }
579  if (Src[I] == '"') {
580  State = QUOTED;
581  continue;
582  }
583  if (Src[I] == '\\') {
584  I = parseBackslash(Src, I, Token);
585  continue;
586  }
587  Token.push_back(Src[I]);
588  continue;
589  }
590 
591  // QUOTED state means that it's reading a token quoted by double quotes.
592  if (State == QUOTED) {
593  if (Src[I] == '"') {
594  State = UNQUOTED;
595  continue;
596  }
597  if (Src[I] == '\\') {
598  I = parseBackslash(Src, I, Token);
599  continue;
600  }
601  Token.push_back(Src[I]);
602  }
603  }
604  // Append the last token after hitting EOF with no whitespace.
605  if (!Token.empty())
606  NewArgv.push_back(Saver.SaveString(Token.c_str()));
607 }
608 
609 static bool ExpandResponseFile(const char *FName, StringSaver &Saver,
610  TokenizerCallback Tokenizer,
613  if (MemoryBuffer::getFile(FName, MemBuf))
614  return false;
615  StringRef Str(MemBuf->getBufferStart(), MemBuf->getBufferSize());
616 
617  // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing.
618  ArrayRef<char> BufRef(MemBuf->getBufferStart(), MemBuf->getBufferEnd());
619  std::string UTF8Buf;
620  if (hasUTF16ByteOrderMark(BufRef)) {
621  if (!convertUTF16ToUTF8String(BufRef, UTF8Buf))
622  return false;
623  Str = StringRef(UTF8Buf);
624  }
625 
626  // Tokenize the contents into NewArgv.
627  Tokenizer(Str, Saver, NewArgv);
628 
629  return true;
630 }
631 
632 /// \brief Expand response files on a command line recursively using the given
633 /// StringSaver and tokenization strategy.
636  unsigned RspFiles = 0;
637  bool AllExpanded = false;
638 
639  // Don't cache Argv.size() because it can change.
640  for (unsigned I = 0; I != Argv.size(); ) {
641  const char *Arg = Argv[I];
642  if (Arg[0] != '@') {
643  ++I;
644  continue;
645  }
646 
647  // If we have too many response files, leave some unexpanded. This avoids
648  // crashing on self-referential response files.
649  if (RspFiles++ > 20)
650  return false;
651 
652  // Replace this response file argument with the tokenization of its
653  // contents. Nested response files are expanded in subsequent iterations.
654  // FIXME: If a nested response file uses a relative path, is it relative to
655  // the cwd of the process or the response file?
656  SmallVector<const char *, 0> ExpandedArgv;
657  if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv)) {
658  AllExpanded = false;
659  continue;
660  }
661  Argv.erase(Argv.begin() + I);
662  Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end());
663  }
664  return AllExpanded;
665 }
666 
667 namespace {
668  class StrDupSaver : public StringSaver {
669  std::vector<char*> Dups;
670  public:
671  ~StrDupSaver() {
672  for (std::vector<char *>::iterator I = Dups.begin(), E = Dups.end();
673  I != E; ++I) {
674  char *Dup = *I;
675  free(Dup);
676  }
677  }
678  const char *SaveString(const char *Str) LLVM_OVERRIDE {
679  char *Dup = strdup(Str);
680  Dups.push_back(Dup);
681  return Dup;
682  }
683  };
684 }
685 
686 /// ParseEnvironmentOptions - An alternative entry point to the
687 /// CommandLine library, which allows you to read the program's name
688 /// from the caller (as PROGNAME) and its command-line arguments from
689 /// an environment variable (whose name is given in ENVVAR).
690 ///
691 void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
692  const char *Overview) {
693  // Check args.
694  assert(progName && "Program name not specified");
695  assert(envVar && "Environment variable name missing");
696 
697  // Get the environment variable they want us to parse options out of.
698  const char *envValue = getenv(envVar);
699  if (!envValue)
700  return;
701 
702  // Get program's "name", which we wouldn't know without the caller
703  // telling us.
705  StrDupSaver Saver;
706  newArgv.push_back(Saver.SaveString(progName));
707 
708  // Parse the value of the environment variable into a "command line"
709  // and hand it off to ParseCommandLineOptions().
710  TokenizeGNUCommandLine(envValue, Saver, newArgv);
711  int newArgc = static_cast<int>(newArgv.size());
712  ParseCommandLineOptions(newArgc, &newArgv[0], Overview);
713 }
714 
715 void cl::ParseCommandLineOptions(int argc, const char * const *argv,
716  const char *Overview) {
717  // Process all registered options.
718  SmallVector<Option*, 4> PositionalOpts;
719  SmallVector<Option*, 4> SinkOpts;
720  StringMap<Option*> Opts;
721  GetOptionInfo(PositionalOpts, SinkOpts, Opts);
722 
723  assert((!Opts.empty() || !PositionalOpts.empty()) &&
724  "No options specified!");
725 
726  // Expand response files.
728  for (int i = 0; i != argc; ++i)
729  newArgv.push_back(argv[i]);
730  StrDupSaver Saver;
732  argv = &newArgv[0];
733  argc = static_cast<int>(newArgv.size());
734 
735  // Copy the program name into ProgName, making sure not to overflow it.
736  std::string ProgName = sys::path::filename(argv[0]);
737  size_t Len = std::min(ProgName.size(), size_t(79));
738  memcpy(ProgramName, ProgName.data(), Len);
739  ProgramName[Len] = '\0';
740 
741  ProgramOverview = Overview;
742  bool ErrorParsing = false;
743 
744  // Check out the positional arguments to collect information about them.
745  unsigned NumPositionalRequired = 0;
746 
747  // Determine whether or not there are an unlimited number of positionals
748  bool HasUnlimitedPositionals = false;
749 
750  Option *ConsumeAfterOpt = 0;
751  if (!PositionalOpts.empty()) {
752  if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) {
753  assert(PositionalOpts.size() > 1 &&
754  "Cannot specify cl::ConsumeAfter without a positional argument!");
755  ConsumeAfterOpt = PositionalOpts[0];
756  }
757 
758  // Calculate how many positional values are _required_.
759  bool UnboundedFound = false;
760  for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size();
761  i != e; ++i) {
762  Option *Opt = PositionalOpts[i];
763  if (RequiresValue(Opt))
764  ++NumPositionalRequired;
765  else if (ConsumeAfterOpt) {
766  // ConsumeAfter cannot be combined with "optional" positional options
767  // unless there is only one positional argument...
768  if (PositionalOpts.size() > 2)
769  ErrorParsing |=
770  Opt->error("error - this positional option will never be matched, "
771  "because it does not Require a value, and a "
772  "cl::ConsumeAfter option is active!");
773  } else if (UnboundedFound && !Opt->ArgStr[0]) {
774  // This option does not "require" a value... Make sure this option is
775  // not specified after an option that eats all extra arguments, or this
776  // one will never get any!
777  //
778  ErrorParsing |= Opt->error("error - option can never match, because "
779  "another positional argument will match an "
780  "unbounded number of values, and this option"
781  " does not require a value!");
782  }
783  UnboundedFound |= EatsUnboundedNumberOfValues(Opt);
784  }
785  HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;
786  }
787 
788  // PositionalVals - A vector of "positional" arguments we accumulate into
789  // the process at the end.
790  //
792 
793  // If the program has named positional arguments, and the name has been run
794  // across, keep track of which positional argument was named. Otherwise put
795  // the positional args into the PositionalVals list...
796  Option *ActivePositionalArg = 0;
797 
798  // Loop over all of the arguments... processing them.
799  bool DashDashFound = false; // Have we read '--'?
800  for (int i = 1; i < argc; ++i) {
801  Option *Handler = 0;
802  Option *NearestHandler = 0;
803  std::string NearestHandlerString;
805  StringRef ArgName = "";
806 
807  // If the option list changed, this means that some command line
808  // option has just been registered or deregistered. This can occur in
809  // response to things like -load, etc. If this happens, rescan the options.
810  if (OptionListChanged) {
811  PositionalOpts.clear();
812  SinkOpts.clear();
813  Opts.clear();
814  GetOptionInfo(PositionalOpts, SinkOpts, Opts);
815  OptionListChanged = false;
816  }
817 
818  // Check to see if this is a positional argument. This argument is
819  // considered to be positional if it doesn't start with '-', if it is "-"
820  // itself, or if we have seen "--" already.
821  //
822  if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
823  // Positional argument!
824  if (ActivePositionalArg) {
825  ProvidePositionalOption(ActivePositionalArg, argv[i], i);
826  continue; // We are done!
827  }
828 
829  if (!PositionalOpts.empty()) {
830  PositionalVals.push_back(std::make_pair(argv[i],i));
831 
832  // All of the positional arguments have been fulfulled, give the rest to
833  // the consume after option... if it's specified...
834  //
835  if (PositionalVals.size() >= NumPositionalRequired &&
836  ConsumeAfterOpt != 0) {
837  for (++i; i < argc; ++i)
838  PositionalVals.push_back(std::make_pair(argv[i],i));
839  break; // Handle outside of the argument processing loop...
840  }
841 
842  // Delay processing positional arguments until the end...
843  continue;
844  }
845  } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
846  !DashDashFound) {
847  DashDashFound = true; // This is the mythical "--"?
848  continue; // Don't try to process it as an argument itself.
849  } else if (ActivePositionalArg &&
850  (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) {
851  // If there is a positional argument eating options, check to see if this
852  // option is another positional argument. If so, treat it as an argument,
853  // otherwise feed it to the eating positional.
854  ArgName = argv[i]+1;
855  // Eat leading dashes.
856  while (!ArgName.empty() && ArgName[0] == '-')
857  ArgName = ArgName.substr(1);
858 
859  Handler = LookupOption(ArgName, Value, Opts);
860  if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
861  ProvidePositionalOption(ActivePositionalArg, argv[i], i);
862  continue; // We are done!
863  }
864 
865  } else { // We start with a '-', must be an argument.
866  ArgName = argv[i]+1;
867  // Eat leading dashes.
868  while (!ArgName.empty() && ArgName[0] == '-')
869  ArgName = ArgName.substr(1);
870 
871  Handler = LookupOption(ArgName, Value, Opts);
872 
873  // Check to see if this "option" is really a prefixed or grouped argument.
874  if (Handler == 0)
875  Handler = HandlePrefixedOrGroupedOption(ArgName, Value,
876  ErrorParsing, Opts);
877 
878  // Otherwise, look for the closest available option to report to the user
879  // in the upcoming error.
880  if (Handler == 0 && SinkOpts.empty())
881  NearestHandler = LookupNearestOption(ArgName, Opts,
882  NearestHandlerString);
883  }
884 
885  if (Handler == 0) {
886  if (SinkOpts.empty()) {
887  errs() << ProgramName << ": Unknown command line argument '"
888  << argv[i] << "'. Try: '" << argv[0] << " -help'\n";
889 
890  if (NearestHandler) {
891  // If we know a near match, report it as well.
892  errs() << ProgramName << ": Did you mean '-"
893  << NearestHandlerString << "'?\n";
894  }
895 
896  ErrorParsing = true;
897  } else {
898  for (SmallVectorImpl<Option*>::iterator I = SinkOpts.begin(),
899  E = SinkOpts.end(); I != E ; ++I)
900  (*I)->addOccurrence(i, "", argv[i]);
901  }
902  continue;
903  }
904 
905  // If this is a named positional argument, just remember that it is the
906  // active one...
907  if (Handler->getFormattingFlag() == cl::Positional)
908  ActivePositionalArg = Handler;
909  else
910  ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
911  }
912 
913  // Check and handle positional arguments now...
914  if (NumPositionalRequired > PositionalVals.size()) {
915  errs() << ProgramName
916  << ": Not enough positional command line arguments specified!\n"
917  << "Must specify at least " << NumPositionalRequired
918  << " positional arguments: See: " << argv[0] << " -help\n";
919 
920  ErrorParsing = true;
921  } else if (!HasUnlimitedPositionals &&
922  PositionalVals.size() > PositionalOpts.size()) {
923  errs() << ProgramName
924  << ": Too many positional arguments specified!\n"
925  << "Can specify at most " << PositionalOpts.size()
926  << " positional arguments: See: " << argv[0] << " -help\n";
927  ErrorParsing = true;
928 
929  } else if (ConsumeAfterOpt == 0) {
930  // Positional args have already been handled if ConsumeAfter is specified.
931  unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());
932  for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
933  if (RequiresValue(PositionalOpts[i])) {
934  ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first,
935  PositionalVals[ValNo].second);
936  ValNo++;
937  --NumPositionalRequired; // We fulfilled our duty...
938  }
939 
940  // If we _can_ give this option more arguments, do so now, as long as we
941  // do not give it values that others need. 'Done' controls whether the
942  // option even _WANTS_ any more.
943  //
944  bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required;
945  while (NumVals-ValNo > NumPositionalRequired && !Done) {
946  switch (PositionalOpts[i]->getNumOccurrencesFlag()) {
947  case cl::Optional:
948  Done = true; // Optional arguments want _at most_ one value
949  // FALL THROUGH
950  case cl::ZeroOrMore: // Zero or more will take all they can get...
951  case cl::OneOrMore: // One or more will take all they can get...
952  ProvidePositionalOption(PositionalOpts[i],
953  PositionalVals[ValNo].first,
954  PositionalVals[ValNo].second);
955  ValNo++;
956  break;
957  default:
958  llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
959  "positional argument processing!");
960  }
961  }
962  }
963  } else {
964  assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
965  unsigned ValNo = 0;
966  for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j)
967  if (RequiresValue(PositionalOpts[j])) {
968  ErrorParsing |= ProvidePositionalOption(PositionalOpts[j],
969  PositionalVals[ValNo].first,
970  PositionalVals[ValNo].second);
971  ValNo++;
972  }
973 
974  // Handle the case where there is just one positional option, and it's
975  // optional. In this case, we want to give JUST THE FIRST option to the
976  // positional option and keep the rest for the consume after. The above
977  // loop would have assigned no values to positional options in this case.
978  //
979  if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) {
980  ErrorParsing |= ProvidePositionalOption(PositionalOpts[1],
981  PositionalVals[ValNo].first,
982  PositionalVals[ValNo].second);
983  ValNo++;
984  }
985 
986  // Handle over all of the rest of the arguments to the
987  // cl::ConsumeAfter command line option...
988  for (; ValNo != PositionalVals.size(); ++ValNo)
989  ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt,
990  PositionalVals[ValNo].first,
991  PositionalVals[ValNo].second);
992  }
993 
994  // Loop over args and make sure all required args are specified!
995  for (StringMap<Option*>::iterator I = Opts.begin(),
996  E = Opts.end(); I != E; ++I) {
997  switch (I->second->getNumOccurrencesFlag()) {
998  case Required:
999  case OneOrMore:
1000  if (I->second->getNumOccurrences() == 0) {
1001  I->second->error("must be specified at least once!");
1002  ErrorParsing = true;
1003  }
1004  // Fall through
1005  default:
1006  break;
1007  }
1008  }
1009 
1010  // Now that we know if -debug is specified, we can use it.
1011  // Note that if ReadResponseFiles == true, this must be done before the
1012  // memory allocated for the expanded command line is free()d below.
1013  DEBUG(dbgs() << "Args: ";
1014  for (int i = 0; i < argc; ++i)
1015  dbgs() << argv[i] << ' ';
1016  dbgs() << '\n';
1017  );
1018 
1019  // Free all of the memory allocated to the map. Command line options may only
1020  // be processed once!
1021  Opts.clear();
1022  PositionalOpts.clear();
1023  MoreHelp->clear();
1024 
1025  // If we had an error processing our arguments, don't let the program execute
1026  if (ErrorParsing) exit(1);
1027 }
1028 
1029 //===----------------------------------------------------------------------===//
1030 // Option Base class implementation
1031 //
1032 
1033 bool Option::error(const Twine &Message, StringRef ArgName) {
1034  if (ArgName.data() == 0) ArgName = ArgStr;
1035  if (ArgName.empty())
1036  errs() << HelpStr; // Be nice for positional arguments
1037  else
1038  errs() << ProgramName << ": for the -" << ArgName;
1039 
1040  errs() << " option: " << Message << "\n";
1041  return true;
1042 }
1043 
1044 bool Option::addOccurrence(unsigned pos, StringRef ArgName,
1045  StringRef Value, bool MultiArg) {
1046  if (!MultiArg)
1047  NumOccurrences++; // Increment the number of times we have been seen
1048 
1049  switch (getNumOccurrencesFlag()) {
1050  case Optional:
1051  if (NumOccurrences > 1)
1052  return error("may only occur zero or one times!", ArgName);
1053  break;
1054  case Required:
1055  if (NumOccurrences > 1)
1056  return error("must occur exactly one time!", ArgName);
1057  // Fall through
1058  case OneOrMore:
1059  case ZeroOrMore:
1060  case ConsumeAfter: break;
1061  }
1062 
1063  return handleOccurrence(pos, ArgName, Value);
1064 }
1065 
1066 
1067 // getValueStr - Get the value description string, using "DefaultMsg" if nothing
1068 // has been specified yet.
1069 //
1070 static const char *getValueStr(const Option &O, const char *DefaultMsg) {
1071  if (O.ValueStr[0] == 0) return DefaultMsg;
1072  return O.ValueStr;
1073 }
1074 
1075 //===----------------------------------------------------------------------===//
1076 // cl::alias class implementation
1077 //
1078 
1079 // Return the width of the option tag for printing...
1080 size_t alias::getOptionWidth() const {
1081  return std::strlen(ArgStr)+6;
1082 }
1083 
1084 static void printHelpStr(StringRef HelpStr, size_t Indent,
1085  size_t FirstLineIndentedBy) {
1086  std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
1087  outs().indent(Indent - FirstLineIndentedBy) << " - " << Split.first << "\n";
1088  while (!Split.second.empty()) {
1089  Split = Split.second.split('\n');
1090  outs().indent(Indent) << Split.first << "\n";
1091  }
1092 }
1093 
1094 // Print out the option for the alias.
1095 void alias::printOptionInfo(size_t GlobalWidth) const {
1096  outs() << " -" << ArgStr;
1097  printHelpStr(HelpStr, GlobalWidth, std::strlen(ArgStr) + 6);
1098 }
1099 
1100 //===----------------------------------------------------------------------===//
1101 // Parser Implementation code...
1102 //
1103 
1104 // basic_parser implementation
1105 //
1106 
1107 // Return the width of the option tag for printing...
1109  size_t Len = std::strlen(O.ArgStr);
1110  if (const char *ValName = getValueName())
1111  Len += std::strlen(getValueStr(O, ValName))+3;
1112 
1113  return Len + 6;
1114 }
1115 
1116 // printOptionInfo - Print out information about this option. The
1117 // to-be-maintained width is specified.
1118 //
1120  size_t GlobalWidth) const {
1121  outs() << " -" << O.ArgStr;
1122 
1123  if (const char *ValName = getValueName())
1124  outs() << "=<" << getValueStr(O, ValName) << '>';
1125 
1126  printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O));
1127 }
1128 
1130  size_t GlobalWidth) const {
1131  outs() << " -" << O.ArgStr;
1132  outs().indent(GlobalWidth-std::strlen(O.ArgStr));
1133 }
1134 
1135 
1136 // parser<bool> implementation
1137 //
1138 bool parser<bool>::parse(Option &O, StringRef ArgName,
1139  StringRef Arg, bool &Value) {
1140  if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1141  Arg == "1") {
1142  Value = true;
1143  return false;
1144  }
1145 
1146  if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1147  Value = false;
1148  return false;
1149  }
1150  return O.error("'" + Arg +
1151  "' is invalid value for boolean argument! Try 0 or 1");
1152 }
1153 
1154 // parser<boolOrDefault> implementation
1155 //
1157  StringRef Arg, boolOrDefault &Value) {
1158  if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||
1159  Arg == "1") {
1160  Value = BOU_TRUE;
1161  return false;
1162  }
1163  if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {
1164  Value = BOU_FALSE;
1165  return false;
1166  }
1167 
1168  return O.error("'" + Arg +
1169  "' is invalid value for boolean argument! Try 0 or 1");
1170 }
1171 
1172 // parser<int> implementation
1173 //
1174 bool parser<int>::parse(Option &O, StringRef ArgName,
1175  StringRef Arg, int &Value) {
1176  if (Arg.getAsInteger(0, Value))
1177  return O.error("'" + Arg + "' value invalid for integer argument!");
1178  return false;
1179 }
1180 
1181 // parser<unsigned> implementation
1182 //
1183 bool parser<unsigned>::parse(Option &O, StringRef ArgName,
1184  StringRef Arg, unsigned &Value) {
1185 
1186  if (Arg.getAsInteger(0, Value))
1187  return O.error("'" + Arg + "' value invalid for uint argument!");
1188  return false;
1189 }
1190 
1191 // parser<unsigned long long> implementation
1192 //
1194  StringRef Arg, unsigned long long &Value){
1195 
1196  if (Arg.getAsInteger(0, Value))
1197  return O.error("'" + Arg + "' value invalid for uint argument!");
1198  return false;
1199 }
1200 
1201 // parser<double>/parser<float> implementation
1202 //
1203 static bool parseDouble(Option &O, StringRef Arg, double &Value) {
1204  SmallString<32> TmpStr(Arg.begin(), Arg.end());
1205  const char *ArgStart = TmpStr.c_str();
1206  char *End;
1207  Value = strtod(ArgStart, &End);
1208  if (*End != 0)
1209  return O.error("'" + Arg + "' value invalid for floating point argument!");
1210  return false;
1211 }
1212 
1213 bool parser<double>::parse(Option &O, StringRef ArgName,
1214  StringRef Arg, double &Val) {
1215  return parseDouble(O, Arg, Val);
1216 }
1217 
1218 bool parser<float>::parse(Option &O, StringRef ArgName,
1219  StringRef Arg, float &Val) {
1220  double dVal;
1221  if (parseDouble(O, Arg, dVal))
1222  return true;
1223  Val = (float)dVal;
1224  return false;
1225 }
1226 
1227 
1228 
1229 // generic_parser_base implementation
1230 //
1231 
1232 // findOption - Return the option number corresponding to the specified
1233 // argument string. If the option is not found, getNumOptions() is returned.
1234 //
1235 unsigned generic_parser_base::findOption(const char *Name) {
1236  unsigned e = getNumOptions();
1237 
1238  for (unsigned i = 0; i != e; ++i) {
1239  if (strcmp(getOption(i), Name) == 0)
1240  return i;
1241  }
1242  return e;
1243 }
1244 
1245 
1246 // Return the width of the option tag for printing...
1248  if (O.hasArgStr()) {
1249  size_t Size = std::strlen(O.ArgStr)+6;
1250  for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
1251  Size = std::max(Size, std::strlen(getOption(i))+8);
1252  return Size;
1253  } else {
1254  size_t BaseSize = 0;
1255  for (unsigned i = 0, e = getNumOptions(); i != e; ++i)
1256  BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8);
1257  return BaseSize;
1258  }
1259 }
1260 
1261 // printOptionInfo - Print out information about this option. The
1262 // to-be-maintained width is specified.
1263 //
1265  size_t GlobalWidth) const {
1266  if (O.hasArgStr()) {
1267  outs() << " -" << O.ArgStr;
1268  printHelpStr(O.HelpStr, GlobalWidth, std::strlen(O.ArgStr) + 6);
1269 
1270  for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
1271  size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8;
1272  outs() << " =" << getOption(i);
1273  outs().indent(NumSpaces) << " - " << getDescription(i) << '\n';
1274  }
1275  } else {
1276  if (O.HelpStr[0])
1277  outs() << " " << O.HelpStr << '\n';
1278  for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
1279  const char *Option = getOption(i);
1280  outs() << " -" << Option;
1281  printHelpStr(getDescription(i), GlobalWidth, std::strlen(Option) + 8);
1282  }
1283  }
1284 }
1285 
1286 static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff
1287 
1288 // printGenericOptionDiff - Print the value of this option and it's default.
1289 //
1290 // "Generic" options have each value mapped to a name.
1293  const GenericOptionValue &Default,
1294  size_t GlobalWidth) const {
1295  outs() << " -" << O.ArgStr;
1296  outs().indent(GlobalWidth-std::strlen(O.ArgStr));
1297 
1298  unsigned NumOpts = getNumOptions();
1299  for (unsigned i = 0; i != NumOpts; ++i) {
1300  if (Value.compare(getOptionValue(i)))
1301  continue;
1302 
1303  outs() << "= " << getOption(i);
1304  size_t L = std::strlen(getOption(i));
1305  size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0;
1306  outs().indent(NumSpaces) << " (default: ";
1307  for (unsigned j = 0; j != NumOpts; ++j) {
1308  if (Default.compare(getOptionValue(j)))
1309  continue;
1310  outs() << getOption(j);
1311  break;
1312  }
1313  outs() << ")\n";
1314  return;
1315  }
1316  outs() << "= *unknown option value*\n";
1317 }
1318 
1319 // printOptionDiff - Specializations for printing basic value types.
1320 //
1321 #define PRINT_OPT_DIFF(T) \
1322  void parser<T>:: \
1323  printOptionDiff(const Option &O, T V, OptionValue<T> D, \
1324  size_t GlobalWidth) const { \
1325  printOptionName(O, GlobalWidth); \
1326  std::string Str; \
1327  { \
1328  raw_string_ostream SS(Str); \
1329  SS << V; \
1330  } \
1331  outs() << "= " << Str; \
1332  size_t NumSpaces = MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0;\
1333  outs().indent(NumSpaces) << " (default: "; \
1334  if (D.hasValue()) \
1335  outs() << D.getValue(); \
1336  else \
1337  outs() << "*no default*"; \
1338  outs() << ")\n"; \
1339  } \
1340 
1341 PRINT_OPT_DIFF(bool)
1343 PRINT_OPT_DIFF(int)
1344 PRINT_OPT_DIFF(unsigned)
1345 PRINT_OPT_DIFF(unsigned long long)
1346 PRINT_OPT_DIFF(double)
1347 PRINT_OPT_DIFF(float)
1348 PRINT_OPT_DIFF(char)
1349 
1350 void parser<std::string>::
1351 printOptionDiff(const Option &O, StringRef V, OptionValue<std::string> D,
1352  size_t GlobalWidth) const {
1353  printOptionName(O, GlobalWidth);
1354  outs() << "= " << V;
1355  size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0;
1356  outs().indent(NumSpaces) << " (default: ";
1357  if (D.hasValue())
1358  outs() << D.getValue();
1359  else
1360  outs() << "*no default*";
1361  outs() << ")\n";
1362 }
1363 
1364 // Print a placeholder for options that don't yet support printOptionDiff().
1366 printOptionNoValue(const Option &O, size_t GlobalWidth) const {
1367  printOptionName(O, GlobalWidth);
1368  outs() << "= *cannot print option value*\n";
1369 }
1370 
1371 //===----------------------------------------------------------------------===//
1372 // -help and -help-hidden option implementation
1373 //
1374 
1375 static int OptNameCompare(const void *LHS, const void *RHS) {
1376  typedef std::pair<const char *, Option*> pair_ty;
1377 
1378  return strcmp(((const pair_ty*)LHS)->first, ((const pair_ty*)RHS)->first);
1379 }
1380 
1381 // Copy Options into a vector so we can sort them as we like.
1382 static void
1384  SmallVectorImpl< std::pair<const char *, Option*> > &Opts,
1385  bool ShowHidden) {
1386  SmallPtrSet<Option*, 128> OptionSet; // Duplicate option detection.
1387 
1388  for (StringMap<Option*>::iterator I = OptMap.begin(), E = OptMap.end();
1389  I != E; ++I) {
1390  // Ignore really-hidden options.
1391  if (I->second->getOptionHiddenFlag() == ReallyHidden)
1392  continue;
1393 
1394  // Unless showhidden is set, ignore hidden flags.
1395  if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)
1396  continue;
1397 
1398  // If we've already seen this option, don't add it to the list again.
1399  if (!OptionSet.insert(I->second))
1400  continue;
1401 
1402  Opts.push_back(std::pair<const char *, Option*>(I->getKey().data(),
1403  I->second));
1404  }
1405 
1406  // Sort the options list alphabetically.
1407  qsort(Opts.data(), Opts.size(), sizeof(Opts[0]), OptNameCompare);
1408 }
1409 
1410 namespace {
1411 
1412 class HelpPrinter {
1413 protected:
1414  const bool ShowHidden;
1415  typedef SmallVector<std::pair<const char *, Option*>,128> StrOptionPairVector;
1416  // Print the options. Opts is assumed to be alphabetically sorted.
1417  virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
1418  for (size_t i = 0, e = Opts.size(); i != e; ++i)
1419  Opts[i].second->printOptionInfo(MaxArgLen);
1420  }
1421 
1422 public:
1423  explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}
1424  virtual ~HelpPrinter() {}
1425 
1426  // Invoke the printer.
1427  void operator=(bool Value) {
1428  if (Value == false) return;
1429 
1430  // Get all the options.
1431  SmallVector<Option*, 4> PositionalOpts;
1432  SmallVector<Option*, 4> SinkOpts;
1433  StringMap<Option*> OptMap;
1434  GetOptionInfo(PositionalOpts, SinkOpts, OptMap);
1435 
1436  StrOptionPairVector Opts;
1437  sortOpts(OptMap, Opts, ShowHidden);
1438 
1439  if (ProgramOverview)
1440  outs() << "OVERVIEW: " << ProgramOverview << "\n";
1441 
1442  outs() << "USAGE: " << ProgramName << " [options]";
1443 
1444  // Print out the positional options.
1445  Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists...
1446  if (!PositionalOpts.empty() &&
1447  PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter)
1448  CAOpt = PositionalOpts[0];
1449 
1450  for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) {
1451  if (PositionalOpts[i]->ArgStr[0])
1452  outs() << " --" << PositionalOpts[i]->ArgStr;
1453  outs() << " " << PositionalOpts[i]->HelpStr;
1454  }
1455 
1456  // Print the consume after option info if it exists...
1457  if (CAOpt) outs() << " " << CAOpt->HelpStr;
1458 
1459  outs() << "\n\n";
1460 
1461  // Compute the maximum argument length...
1462  size_t MaxArgLen = 0;
1463  for (size_t i = 0, e = Opts.size(); i != e; ++i)
1464  MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
1465 
1466  outs() << "OPTIONS:\n";
1467  printOptions(Opts, MaxArgLen);
1468 
1469  // Print any extra help the user has declared.
1470  for (std::vector<const char *>::iterator I = MoreHelp->begin(),
1471  E = MoreHelp->end();
1472  I != E; ++I)
1473  outs() << *I;
1474  MoreHelp->clear();
1475 
1476  // Halt the program since help information was printed
1477  exit(1);
1478  }
1479 };
1480 
1481 class CategorizedHelpPrinter : public HelpPrinter {
1482 public:
1483  explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}
1484 
1485  // Helper function for printOptions().
1486  // It shall return true if A's name should be lexographically
1487  // ordered before B's name. It returns false otherwise.
1488  static bool OptionCategoryCompare(OptionCategory *A, OptionCategory *B) {
1489  int Length = strcmp(A->getName(), B->getName());
1490  assert(Length != 0 && "Duplicate option categories");
1491  return Length < 0;
1492  }
1493 
1494  // Make sure we inherit our base class's operator=()
1495  using HelpPrinter::operator= ;
1496 
1497 protected:
1498  virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {
1499  std::vector<OptionCategory *> SortedCategories;
1500  std::map<OptionCategory *, std::vector<Option *> > CategorizedOptions;
1501 
1502  // Collect registered option categories into vector in preperation for
1503  // sorting.
1505  E = RegisteredOptionCategories->end();
1506  I != E; ++I)
1507  SortedCategories.push_back(*I);
1508 
1509  // Sort the different option categories alphabetically.
1510  assert(SortedCategories.size() > 0 && "No option categories registered!");
1511  std::sort(SortedCategories.begin(), SortedCategories.end(),
1512  OptionCategoryCompare);
1513 
1514  // Create map to empty vectors.
1515  for (std::vector<OptionCategory *>::const_iterator
1516  I = SortedCategories.begin(),
1517  E = SortedCategories.end();
1518  I != E; ++I)
1519  CategorizedOptions[*I] = std::vector<Option *>();
1520 
1521  // Walk through pre-sorted options and assign into categories.
1522  // Because the options are already alphabetically sorted the
1523  // options within categories will also be alphabetically sorted.
1524  for (size_t I = 0, E = Opts.size(); I != E; ++I) {
1525  Option *Opt = Opts[I].second;
1526  assert(CategorizedOptions.count(Opt->Category) > 0 &&
1527  "Option has an unregistered category");
1528  CategorizedOptions[Opt->Category].push_back(Opt);
1529  }
1530 
1531  // Now do printing.
1532  for (std::vector<OptionCategory *>::const_iterator
1533  Category = SortedCategories.begin(),
1534  E = SortedCategories.end();
1535  Category != E; ++Category) {
1536  // Hide empty categories for -help, but show for -help-hidden.
1537  bool IsEmptyCategory = CategorizedOptions[*Category].size() == 0;
1538  if (!ShowHidden && IsEmptyCategory)
1539  continue;
1540 
1541  // Print category information.
1542  outs() << "\n";
1543  outs() << (*Category)->getName() << ":\n";
1544 
1545  // Check if description is set.
1546  if ((*Category)->getDescription() != 0)
1547  outs() << (*Category)->getDescription() << "\n\n";
1548  else
1549  outs() << "\n";
1550 
1551  // When using -help-hidden explicitly state if the category has no
1552  // options associated with it.
1553  if (IsEmptyCategory) {
1554  outs() << " This option category has no options.\n";
1555  continue;
1556  }
1557  // Loop over the options in the category and print.
1558  for (std::vector<Option *>::const_iterator
1559  Opt = CategorizedOptions[*Category].begin(),
1560  E = CategorizedOptions[*Category].end();
1561  Opt != E; ++Opt)
1562  (*Opt)->printOptionInfo(MaxArgLen);
1563  }
1564  }
1565 };
1566 
1567 // This wraps the Uncategorizing and Categorizing printers and decides
1568 // at run time which should be invoked.
1569 class HelpPrinterWrapper {
1570 private:
1571  HelpPrinter &UncategorizedPrinter;
1572  CategorizedHelpPrinter &CategorizedPrinter;
1573 
1574 public:
1575  explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,
1576  CategorizedHelpPrinter &CategorizedPrinter) :
1577  UncategorizedPrinter(UncategorizedPrinter),
1578  CategorizedPrinter(CategorizedPrinter) { }
1579 
1580  // Invoke the printer.
1581  void operator=(bool Value);
1582 };
1583 
1584 } // End anonymous namespace
1585 
1586 // Declare the four HelpPrinter instances that are used to print out help, or
1587 // help-hidden as an uncategorized list or in categories.
1588 static HelpPrinter UncategorizedNormalPrinter(false);
1589 static HelpPrinter UncategorizedHiddenPrinter(true);
1590 static CategorizedHelpPrinter CategorizedNormalPrinter(false);
1591 static CategorizedHelpPrinter CategorizedHiddenPrinter(true);
1592 
1593 
1594 // Declare HelpPrinter wrappers that will decide whether or not to invoke
1595 // a categorizing help printer
1596 static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter,
1598 static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter,
1600 
1601 // Define uncategorized help printers.
1602 // -help-list is hidden by default because if Option categories are being used
1603 // then -help behaves the same as -help-list.
1605 HLOp("help-list",
1606  cl::desc("Display list of available options (-help-list-hidden for more)"),
1608 
1610 HLHOp("help-list-hidden",
1611  cl::desc("Display list of all available options"),
1613 
1614 // Define uncategorized/categorized help printers. These printers change their
1615 // behaviour at runtime depending on whether one or more Option categories have
1616 // been declared.
1618 HOp("help", cl::desc("Display available options (-help-hidden for more)"),
1620 
1622 HHOp("help-hidden", cl::desc("Display all available options"),
1624 
1625 
1626 
1627 static cl::opt<bool>
1628 PrintOptions("print-options",
1629  cl::desc("Print non-default options after command line parsing"),
1630  cl::Hidden, cl::init(false));
1631 
1632 static cl::opt<bool>
1633 PrintAllOptions("print-all-options",
1634  cl::desc("Print all option values after command line parsing"),
1635  cl::Hidden, cl::init(false));
1636 
1637 void HelpPrinterWrapper::operator=(bool Value) {
1638  if (Value == false)
1639  return;
1640 
1641  // Decide which printer to invoke. If more than one option category is
1642  // registered then it is useful to show the categorized help instead of
1643  // uncategorized help.
1644  if (RegisteredOptionCategories->size() > 1) {
1645  // unhide -help-list option so user can have uncategorized output if they
1646  // want it.
1647  HLOp.setHiddenFlag(NotHidden);
1648 
1649  CategorizedPrinter = true; // Invoke categorized printer
1650  }
1651  else
1652  UncategorizedPrinter = true; // Invoke uncategorized printer
1653 }
1654 
1655 // Print the value of each option.
1657  if (!PrintOptions && !PrintAllOptions) return;
1658 
1659  // Get all the options.
1660  SmallVector<Option*, 4> PositionalOpts;
1661  SmallVector<Option*, 4> SinkOpts;
1662  StringMap<Option*> OptMap;
1663  GetOptionInfo(PositionalOpts, SinkOpts, OptMap);
1664 
1666  sortOpts(OptMap, Opts, /*ShowHidden*/true);
1667 
1668  // Compute the maximum argument length...
1669  size_t MaxArgLen = 0;
1670  for (size_t i = 0, e = Opts.size(); i != e; ++i)
1671  MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
1672 
1673  for (size_t i = 0, e = Opts.size(); i != e; ++i)
1674  Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions);
1675 }
1676 
1677 static void (*OverrideVersionPrinter)() = 0;
1678 
1679 static std::vector<void (*)()>* ExtraVersionPrinters = 0;
1680 
1681 namespace {
1682 class VersionPrinter {
1683 public:
1684  void print() {
1685  raw_ostream &OS = outs();
1686  OS << "LLVM (http://llvm.org/):\n"
1687  << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION;
1688 #ifdef LLVM_VERSION_INFO
1689  OS << LLVM_VERSION_INFO;
1690 #endif
1691  OS << "\n ";
1692 #ifndef __OPTIMIZE__
1693  OS << "DEBUG build";
1694 #else
1695  OS << "Optimized build";
1696 #endif
1697 #ifndef NDEBUG
1698  OS << " with assertions";
1699 #endif
1700  std::string CPU = sys::getHostCPUName();
1701  if (CPU == "generic") CPU = "(unknown)";
1702  OS << ".\n"
1703 #if (ENABLE_TIMESTAMPS == 1)
1704  << " Built " << __DATE__ << " (" << __TIME__ << ").\n"
1705 #endif
1706  << " Default target: " << sys::getDefaultTargetTriple() << '\n'
1707  << " Host CPU: " << CPU << '\n';
1708  }
1709  void operator=(bool OptionWasSpecified) {
1710  if (!OptionWasSpecified) return;
1711 
1712  if (OverrideVersionPrinter != 0) {
1713  (*OverrideVersionPrinter)();
1714  exit(1);
1715  }
1716  print();
1717 
1718  // Iterate over any registered extra printers and call them to add further
1719  // information.
1720  if (ExtraVersionPrinters != 0) {
1721  outs() << '\n';
1722  for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(),
1723  E = ExtraVersionPrinters->end();
1724  I != E; ++I)
1725  (*I)();
1726  }
1727 
1728  exit(1);
1729  }
1730 };
1731 } // End anonymous namespace
1732 
1733 
1734 // Define the --version option that prints out the LLVM version for the tool
1735 static VersionPrinter VersionPrinterInstance;
1736 
1738 VersOp("version", cl::desc("Display the version of this program"),
1740 
1741 // Utility function for printing the help message.
1742 void cl::PrintHelpMessage(bool Hidden, bool Categorized) {
1743  // This looks weird, but it actually prints the help message. The Printers are
1744  // types of HelpPrinter and the help gets printed when its operator= is
1745  // invoked. That's because the "normal" usages of the help printer is to be
1746  // assigned true/false depending on whether -help or -help-hidden was given or
1747  // not. Since we're circumventing that we have to make it look like -help or
1748  // -help-hidden were given, so we assign true.
1749 
1750  if (!Hidden && !Categorized)
1752  else if (!Hidden && Categorized)
1753  CategorizedNormalPrinter = true;
1754  else if (Hidden && !Categorized)
1756  else
1757  CategorizedHiddenPrinter = true;
1758 }
1759 
1760 /// Utility function for printing version number.
1762  VersionPrinterInstance.print();
1763 }
1764 
1765 void cl::SetVersionPrinter(void (*func)()) {
1766  OverrideVersionPrinter = func;
1767 }
1768 
1769 void cl::AddExtraVersionPrinter(void (*func)()) {
1770  if (ExtraVersionPrinters == 0)
1771  ExtraVersionPrinters = new std::vector<void (*)()>;
1772 
1773  ExtraVersionPrinters->push_back(func);
1774 }
1775 
1777 {
1778  // Get all the options.
1779  SmallVector<Option*, 4> PositionalOpts; //NOT USED
1780  SmallVector<Option*, 4> SinkOpts; //NOT USED
1781  assert(Map.size() == 0 && "StringMap must be empty");
1782  GetOptionInfo(PositionalOpts, SinkOpts, Map);
1783  return;
1784 }
static void Help(const SubtargetFeatureKV *CPUTable, size_t CPUTableSize, const SubtargetFeatureKV *FeatTable, size_t FeatTableSize)
int strcmp(const char *s1, const char *s2);
void push_back(const T &Elt)
Definition: SmallVector.h:236
const char * ArgStr
Definition: CommandLine.h:195
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:181
Saves strings in the inheritor's stable storage and returns a stable raw character pointer...
Definition: CommandLine.h:1757
static bool isQuote(char C)
raw_ostream & errs()
OptionCategory GeneralCategory
Option * getNextRegisteredOption() const
Definition: CommandLine.h:252
static Option * HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, bool &ErrorParsing, const StringMap< Option * > &OptionsMap)
static bool isPrefixedOrGrouping(const Option *O)
static bool parseDouble(Option &O, StringRef Arg, double &Value)
size_t size() const
size - Get the string size.
Definition: StringRef.h:113
const char * getBufferStart() const
Definition: MemoryBuffer.h:51
static bool isGrouping(const Option *O)
virtual const GenericOptionValue & getOptionValue(unsigned N) const =0
void PrintVersionMessage()
Utility function for printing version number.
size_t find(char C, size_t From=0) const
Definition: StringRef.h:233
static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)
static const char * ProgramOverview
Definition: CommandLine.cpp:85
static ManagedStatic< std::vector< const char * > > MoreHelp
Definition: CommandLine.cpp:88
bool empty() const
Definition: StringMap.h:103
std::string getDefaultTargetTriple()
raw_ostream & indent(unsigned NumSpaces)
indent - Insert 'NumSpaces' spaces.
void(* TokenizerCallback)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv)
String tokenization function type. Should be compatible with either Windows or Unix command line toke...
Definition: CommandLine.h:1791
std::pair< StringRef, StringRef > split(char Separator) const
Definition: StringRef.h:437
#define PRINT_OPT_DIFF(T)
bool insert(PtrType Ptr)
Definition: SmallPtrSet.h:253
StringRef substr(size_t Start, size_t N=npos) const
Definition: StringRef.h:392
iterator find(StringRef Key)
Definition: StringMap.h:291
iterator insert(iterator I, const T &Elt)
Definition: SmallVector.h:537
unsigned findOption(const char *Name)
static void sortOpts(StringMap< Option * > &OptMap, SmallVectorImpl< std::pair< const char *, Option * > > &Opts, bool ShowHidden)
void printOptionName(const Option &O, size_t GlobalWidth) const
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:181
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:173
void SetVersionPrinter(void(*func)())
static HelpPrinter UncategorizedHiddenPrinter(true)
static void(* OverrideVersionPrinter)()=0
double strtod(const char *nptr, char **endptr);
virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const
#define llvm_unreachable(msg)
static const size_t MaxOptWidth
void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)
Definition: CommandLine.h:957
static VersionPrinter VersionPrinterInstance
char *strchr(const char *s, int c);
size_type count(StringRef Key) const
Definition: StringMap.h:316
static cl::opt< HelpPrinter, true, parser< bool > > HLOp("help-list", cl::desc("Display list of available options (-help-list-hidden for more)"), cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed)
virtual bool compare(const GenericOptionValue &V) const =0
bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)
void printOptionInfo(const Option &O, size_t GlobalWidth) const
void AddExtraVersionPrinter(void(*func)())
static size_t parseBackslash(StringRef Src, size_t I, SmallString< 128 > &Token)
static HelpPrinter UncategorizedNormalPrinter(false)
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: SmallVector.h:56
static cl::opt< HelpPrinter, true, parser< bool > > HLHOp("help-list-hidden", cl::desc("Display list of all available options"), cl::location(UncategorizedHiddenPrinter), cl::Hidden, cl::ValueDisallowed)
const char * data() const
Definition: StringRef.h:107
TEMPLATE_INSTANTIATION(class basic_parser< bool >)
void PrintOptionValues()
void ParseEnvironmentOptions(const char *progName, const char *envvar, const char *Overview=0)
iterator begin() const
Definition: StringRef.h:97
static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)
void append(in_iter S, in_iter E)
Append from an iterator pair.
Definition: SmallString.h:77
static ManagedStatic< OptionCatSet > RegisteredOptionCategories
raw_ostream & outs()
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:314
void ParseCommandLineOptions(int argc, const char *const *argv, const char *Overview=0)
size_t getOptionWidth(const Option &O) const
static cl::opt< VersionPrinter, true, parser< bool > > VersOp("version", cl::desc("Display the version of this program"), cl::location(VersionPrinterInstance), cl::ValueDisallowed)
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)
Definition: CommandLine.h:655
void getRegisteredOptions(StringMap< Option * > &Map)
Use this to get a StringMap to all registered named options (e.g. -help). Note Map Should be an empty...
enum NumOccurrencesFlag getNumOccurrencesFlag() const
Definition: CommandLine.h:200
void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv)
Tokenizes a Windows command line which may contain quotes and escaped quotes.
void PrintHelpMessage(bool Hidden=false, bool Categorized=false)
extrahelp(const char *help)
Definition: CommandLine.cpp:90
std::string getHostCPUName()
Definition: Host.cpp:667
void free(void *ptr);
unsigned size() const
Definition: StringMap.h:104
virtual const char * SaveString(const char *Str)=0
virtual unsigned getNumOptions() const =0
static Option * LookupNearestOption(StringRef Arg, const StringMap< Option * > &OptionsMap, std::string &NearestString)
OptionCategory * Category
Definition: CommandLine.h:198
static bool EatsUnboundedNumberOfValues(const Option *O)
static bool OptionListChanged
Definition: CommandLine.cpp:95
#define INIT(o, n)
Definition: regexec.c:120
void MarkOptionsChanged()
Definition: CommandLine.cpp:98
enable_if_c< std::numeric_limits< T >::is_signed, bool >::type getAsInteger(unsigned Radix, T &Result) const
Definition: StringRef.h:337
void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv)
Tokenizes a command line that can contain escapes and quotes.
iterator erase(iterator I)
Definition: SmallVector.h:478
void printGenericOptionDiff(const Option &O, const GenericOptionValue &V, const GenericOptionValue &Default, size_t GlobalWidth) const
unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const
Determine the edit distance between this string and another string.
Definition: StringRef.cpp:105
char *strdup(const char *s1);
SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet.
Definition: SmallPtrSet.h:174
void printOptionNoValue(const Option &O, size_t GlobalWidth) const
static cl::opt< bool > PrintOptions("print-options", cl::desc("Print non-default options after command line parsing"), cl::Hidden, cl::init(false))
static error_code getFile(Twine Filename, OwningPtr< MemoryBuffer > &result, int64_t FileSize=-1, bool RequiresNullTerminator=true)
static void Split(std::vector< std::string > &V, const StringRef S)
SmallPtrSet< OptionCategory *, 16 > OptionCatSet
enum FormattingFlags getFormattingFlag() const
Definition: CommandLine.h:210
virtual const char * getOption(unsigned N) const =0
const char * HelpStr
Definition: CommandLine.h:196
static HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter, CategorizedNormalPrinter)
static bool CommaSeparateAndAddOccurence(Option *Handler, unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)
static const char * getValueStr(const Option &O, const char *DefaultMsg)
static void GetOptionInfo(SmallVectorImpl< Option * > &PositionalOpts, SmallVectorImpl< Option * > &SinkOpts, StringMap< Option * > &OptionsMap)
static bool ProvideOption(Option *Handler, StringRef ArgName, StringRef Value, int argc, const char *const *argv, int &i)
virtual void getExtraOptionNames(SmallVectorImpl< const char * > &)
Definition: CommandLine.h:264
size_t strlen(const char *s);
virtual size_t getOptionWidth(const Option &O) const
raw_ostream & dbgs()
dbgs - Return a circular-buffered debug stream.
Definition: Debug.cpp:101
static cl::opt< bool > PrintAllOptions("print-all-options", cl::desc("Print all option values after command line parsing"), cl::Hidden, cl::init(false))
static bool isWhitespace(char C)
static bool isGNUSpecial(char C)
static bool RequiresValue(const Option *O)
size_t getBufferSize() const
Definition: MemoryBuffer.h:53
bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)
static int OptNameCompare(const void *LHS, const void *RHS)
unsigned getNumAdditionalVals() const
Definition: CommandLine.h:217
MapEntryTy & GetOrCreateValue(StringRef Key, InitTy Val)
Definition: StringMap.h:361
enum ValueExpected getValueExpectedFlag() const
Definition: CommandLine.h:203
static bool ExpandResponseFile(const char *FName, StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &NewArgv)
static const size_t npos
Definition: StringRef.h:45
static CategorizedHelpPrinter CategorizedNormalPrinter(false)
iterator begin()
Definition: StringMap.h:278
size_t size_type
Definition: StringRef.h:46
static Option * RegisteredOptionList
const char * c_str()
Definition: SmallString.h:273
#define I(x, y, z)
Definition: MD5.cpp:54
static char ProgramName[80]
Definition: CommandLine.cpp:84
virtual const char * getValueName() const
Definition: CommandLine.h:718
virtual const char * getDescription(unsigned N) const =0
const char * getBufferEnd() const
Definition: MemoryBuffer.h:52
const char * ValueStr
Definition: CommandLine.h:197
const char * getName()
Definition: CommandLine.h:152
LLVM Value Representation.
Definition: Value.h:66
static Option * LookupOption(StringRef &Arg, StringRef &Value, const StringMap< Option * > &OptionsMap)
bool hasUTF16ByteOrderMark(ArrayRef< char > S)
iterator end() const
Definition: StringRef.h:99
bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv)
Expand response files on a command line recursively using the given StringSaver and tokenization stra...
static cl::opt< HelpPrinterWrapper, true, parser< bool > > HOp("help", cl::desc("Display available options (-help-hidden for more)"), cl::location(WrappedNormalPrinter), cl::ValueDisallowed)
#define DEBUG(X)
Definition: Debug.h:97
static Option * getOptionPred(StringRef Name, size_t &Length, bool(*Pred)(const Option *), const StringMap< Option * > &OptionsMap)
static CategorizedHelpPrinter CategorizedHiddenPrinter(true)
static std::vector< void(*)()> * ExtraVersionPrinters
bool error(const Twine &Message, StringRef ArgName=StringRef())
const StringRef filename(StringRef path)
Get filename.
Definition: Path.cpp:467
static cl::opt< HelpPrinterWrapper, true, parser< bool > > HHOp("help-hidden", cl::desc("Display all available options"), cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed)
char *getenv(const char *name);
static HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter, CategorizedHiddenPrinter)
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:333
iterator end()
Definition: StringMap.h:281
unsigned getMiscFlags() const
Definition: CommandLine.h:213
bool hasArgStr() const
Definition: CommandLine.h:220
#define LLVM_OVERRIDE
Definition: Compiler.h:155
bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:110