1 //===- Support/CommandLine.h - Flexible Command line parser ------*- C++ -*--=//
3 // This class implements a command line argument processor that is useful when
4 // creating a tool. It provides a simple, minimalistic interface that is easily
5 // extensible and supports nonlocal (library) command line options.
7 // Note that rather than trying to figure out what this code does, you could try
8 // reading the library documentation located in docs/CommandLine.html
10 //===----------------------------------------------------------------------===//
12 #ifndef LLVM_SUPPORT_COMMANDLINE_H
13 #define LLVM_SUPPORT_COMMANDLINE_H
20 namespace cl { // Short namespace to make usage concise
22 //===----------------------------------------------------------------------===//
23 // ParseCommandLineOptions - Minimalistic command line option processing entry
25 void cl::ParseCommandLineOptions(int &argc, char **argv,
26 const char *Overview = 0,
29 // ParserOptions - This set of option is use to control global behavior of the
30 // command line processor.
33 // DisableSingleLetterArgGrouping - With this option enabled, multiple letter
34 // options are allowed to bunch together with only a single hyphen for the
35 // whole group. This allows emulation of the behavior that ls uses for
36 // example: ls -la === ls -l -a Providing this option, disables this.
38 DisableSingleLetterArgGrouping = 0x0001,
40 // EnableSingleLetterArgValue - This option allows arguments that are
41 // otherwise unrecognized to match single letter flags that take a value.
42 // This is useful for cases like a linker, where options are typically of the
43 // form '-lfoo' or '-L../../include' where -l or -L are the actual flags.
45 EnableSingleLetterArgValue = 0x0002,
49 //===----------------------------------------------------------------------===//
50 // Global flags permitted to be passed to command line arguments
53 NoFlags = 0x00, // Marker to make explicit that we have no flags
54 Default = 0x00, // Equally, marker to use the default flags
59 enum NumOccurances { // Flags for the number of occurances allowed...
60 Optional = 0x01, // Zero or One occurance
61 ZeroOrMore = 0x02, // Zero or more occurances allowed
62 Required = 0x03, // One occurance required
63 OneOrMore = 0x04, // One or more occurances required
65 // ConsumeAfter - Marker for a null ("") flag that can be used to indicate
66 // that anything that matches the null marker starts a sequence of options
67 // that all get sent to the null marker. Thus, for example, all arguments
68 // to LLI are processed until a filename is found. Once a filename is found,
69 // all of the succeeding arguments are passed, unprocessed, to the null flag.
73 OccurancesMask = 0x07,
76 enum ValueExpected { // Is a value required for the option?
77 ValueOptional = 0x08, // The value can oppear... or not
78 ValueRequired = 0x10, // The value is required to appear!
79 ValueDisallowed = 0x18, // A value may not be specified (for flags)
83 enum OptionHidden { // Control whether -help shows this option
84 NotHidden = 0x20, // Option included in --help & --help-hidden
85 Hidden = 0x40, // -help doesn't, but --help-hidden does
86 ReallyHidden = 0x60, // Neither --help nor --help-hidden show this arg
91 //===----------------------------------------------------------------------===//
96 friend void cl::ParseCommandLineOptions(int &, char **, const char *, int);
99 // handleOccurances - Overriden by subclasses to handle the value passed into
100 // an argument. Should return true if there was an error processing the
101 // argument and the program should exit.
103 virtual bool handleOccurance(const char *ArgName, const std::string &Arg) = 0;
105 virtual enum NumOccurances getNumOccurancesFlagDefault() const {
108 virtual enum ValueExpected getValueExpectedFlagDefault() const {
109 return ValueOptional;
111 virtual enum OptionHidden getOptionHiddenFlagDefault() const {
115 int NumOccurances; // The number of times specified
116 const int Flags; // Flags for the argument
118 const char * const ArgStr; // The argument string itself (ex: "help", "o")
119 const char * const HelpStr; // The descriptive text message for --help
121 inline enum NumOccurances getNumOccurancesFlag() const {
122 int NO = Flags & OccurancesMask;
123 return NO ? (enum NumOccurances)NO : getNumOccurancesFlagDefault();
125 inline enum ValueExpected getValueExpectedFlag() const {
126 int VE = Flags & ValueMask;
127 return VE ? (enum ValueExpected)VE : getValueExpectedFlagDefault();
129 inline enum OptionHidden getOptionHiddenFlag() const {
130 int OH = Flags & HiddenMask;
131 return OH ? (enum OptionHidden)OH : getOptionHiddenFlagDefault();
135 Option(const char *ArgStr, const char *Message, int Flags);
136 Option(int flags) : NumOccurances(0), Flags(flags), ArgStr(""), HelpStr("") {}
139 // Return the width of the option tag for printing...
140 virtual unsigned getOptionWidth() const;
142 // printOptionInfo - Print out information about this option. The
143 // to-be-maintained width is specified.
145 virtual void printOptionInfo(unsigned GlobalWidth) const;
147 // addOccurance - Wrapper around handleOccurance that enforces Flags
149 bool addOccurance(const char *ArgName, const std::string &Value);
151 // Prints option name followed by message. Always returns true.
152 bool error(std::string Message, const char *ArgName = 0);
155 inline int getNumOccurances() const { return NumOccurances; }
160 //===----------------------------------------------------------------------===//
161 // Aliased command line option (alias this name to a preexisting name)
163 class Alias : public Option {
165 virtual bool handleOccurance(const char *ArgName, const std::string &Arg) {
166 return AliasFor.handleOccurance(AliasFor.ArgStr, Arg);
168 virtual enum OptionHidden getOptionHiddenFlagDefault() const {return Hidden;}
170 inline Alias(const char *ArgStr, const char *Message, int Flags,
171 Option &aliasFor) : Option(ArgStr, Message, Flags),
172 AliasFor(aliasFor) {}
175 //===----------------------------------------------------------------------===//
176 // Boolean/flag command line option
178 class Flag : public Option {
180 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
182 inline Flag(const char *ArgStr, const char *Message, int Flags = 0,
183 bool DefaultVal = 0) : Option(ArgStr, Message, Flags),
185 operator const bool() const { return Value; }
186 inline bool operator=(bool Val) { Value = Val; return Val; }
191 //===----------------------------------------------------------------------===//
192 // Integer valued command line option
194 class Int : public Option {
196 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
197 virtual enum ValueExpected getValueExpectedFlagDefault() const {
198 return ValueRequired;
201 inline Int(const char *ArgStr, const char *Help, int Flags = 0,
202 int DefaultVal = 0) : Option(ArgStr, Help, Flags),
204 inline operator int() const { return Value; }
205 inline int operator=(int Val) { Value = Val; return Val; }
209 //===----------------------------------------------------------------------===//
210 // String valued command line option
212 class String : public Option, public std::string {
213 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
214 virtual enum ValueExpected getValueExpectedFlagDefault() const {
215 return ValueRequired;
218 inline String(const char *ArgStr, const char *Help, int Flags = 0,
219 const char *DefaultVal = "")
220 : Option(ArgStr, Help, Flags), std::string(DefaultVal) {}
222 inline const std::string &operator=(const std::string &Val) {
223 return std::string::operator=(Val);
228 //===----------------------------------------------------------------------===//
229 // String list command line option
231 class StringList : public Option, public std::vector<std::string> {
233 virtual enum NumOccurances getNumOccurancesFlagDefault() const {
236 virtual enum ValueExpected getValueExpectedFlagDefault() const {
237 return ValueRequired;
239 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
242 inline StringList(const char *ArgStr, const char *Help, int Flags = 0)
243 : Option(ArgStr, Help, Flags) {}
247 //===----------------------------------------------------------------------===//
248 // Enum valued command line option
250 #define clEnumVal(ENUMVAL, DESC) #ENUMVAL, ENUMVAL, DESC
251 #define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, ENUMVAL, DESC
253 // EnumBase - Base class for all enum/varargs related argument types...
254 class EnumBase : public Option {
256 // Use a vector instead of a map, because the lists should be short,
257 // the overhead is less, and most importantly, it keeps them in the order
258 // inserted so we can print our option out nicely.
259 std::vector<std::pair<const char *, std::pair<int, const char *> > > ValueMap;
261 inline EnumBase(const char *ArgStr, const char *Help, int Flags)
262 : Option(ArgStr, Help, Flags) {}
263 inline EnumBase(int Flags) : Option(Flags) {}
265 // processValues - Incorporate the specifed varargs arglist into the
268 void processValues(va_list Vals);
270 // registerArgs - notify the system about these new arguments
274 // Turn an enum into the arg name that activates it
275 const char *getArgName(int ID) const;
276 const char *getArgDescription(int ID) const;
279 class EnumValueBase : public EnumBase {
282 inline EnumValueBase(const char *ArgStr, const char *Help, int Flags)
283 : EnumBase(ArgStr, Help, Flags) {}
284 inline EnumValueBase(int Flags) : EnumBase(Flags) {}
286 // handleOccurance - Set Value to the enum value specified by Arg
287 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
289 // Return the width of the option tag for printing...
290 virtual unsigned getOptionWidth() const;
292 // printOptionInfo - Print out information about this option. The
293 // to-be-maintained width is specified.
295 virtual void printOptionInfo(unsigned GlobalWidth) const;
298 template <class E> // The enum we are representing
299 class Enum : public EnumValueBase {
300 virtual enum ValueExpected getValueExpectedFlagDefault() const {
301 return ValueRequired;
304 inline Enum(const char *ArgStr, int Flags, const char *Help, ...)
305 : EnumValueBase(ArgStr, Help, Flags) {
307 va_start(Values, Help);
308 processValues(Values);
310 Value = ValueMap.front().second.first; // Grab default value
313 inline operator E() const { return (E)Value; }
314 inline E operator=(E Val) { Value = Val; return Val; }
318 //===----------------------------------------------------------------------===//
319 // Enum flags command line option
321 class EnumFlagsBase : public EnumValueBase {
322 virtual enum ValueExpected getValueExpectedFlagDefault() const {
323 return ValueDisallowed;
326 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
327 inline EnumFlagsBase(int Flags) : EnumValueBase(Flags) {}
329 // Return the width of the option tag for printing...
330 virtual unsigned getOptionWidth() const;
332 // printOptionInfo - Print out information about this option. The
333 // to-be-maintained width is specified.
335 virtual void printOptionInfo(unsigned GlobalWidth) const;
338 template <class E> // The enum we are representing
339 class EnumFlags : public EnumFlagsBase {
341 inline EnumFlags(int Flags, ...) : EnumFlagsBase(Flags) {
343 va_start(Values, Flags);
344 processValues(Values);
347 Value = ValueMap.front().second.first; // Grab default value
350 inline operator E() const { return (E)Value; }
351 inline E operator=(E Val) { Value = Val; return Val; }
355 //===----------------------------------------------------------------------===//
356 // Enum list command line option
358 class EnumListBase : public EnumBase {
359 virtual enum NumOccurances getNumOccurancesFlagDefault() const {
362 virtual enum ValueExpected getValueExpectedFlagDefault() const {
363 return ValueDisallowed;
366 std::vector<int> Values; // The options specified so far.
368 inline EnumListBase(int Flags)
370 virtual bool handleOccurance(const char *ArgName, const std::string &Arg);
372 // Return the width of the option tag for printing...
373 virtual unsigned getOptionWidth() const;
375 // printOptionInfo - Print out information about this option. The
376 // to-be-maintained width is specified.
378 virtual void printOptionInfo(unsigned GlobalWidth) const;
380 inline unsigned size() { return Values.size(); }
383 template <class E> // The enum we are representing
384 class EnumList : public EnumListBase {
386 inline EnumList(int Flags, ...) : EnumListBase(Flags) {
388 va_start(Values, Flags);
389 processValues(Values);
393 inline E operator[](unsigned i) const { return (E)Values[i]; }
394 inline E &operator[](unsigned i) { return (E&)Values[i]; }
397 } // End namespace cl