From e76d4abfe2469916c6c46b1cdea33e10df599001 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 6 Aug 2002 19:36:06 +0000 Subject: Write the reference section, make other minor editing changes elsewhere. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3253 91177308-0d34-0410-b5e6-96231b3b80d8 --- docs/CommandLine.html | 859 ++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 754 insertions(+), 105 deletions(-) (limited to 'docs/CommandLine.html') diff --git a/docs/CommandLine.html b/docs/CommandLine.html index 7672ec4..b3e9840 100644 --- a/docs/CommandLine.html +++ b/docs/CommandLine.html @@ -3,7 +3,7 @@ - +
  CommandLine 2.0 Library Manual
  CommandLine 2.0 Library Manual
    @@ -12,34 +12,58 @@
    1. Boolean Arguments
    2. Argument Aliases -
    3. Selecting an alternative from a set of possibilities +
    4. Selecting an alternative from a + set of possibilities
    5. Named alternatives
    6. Parsing a list of options
  1. Reference Guide
      -
    1. Option Modifiers: +
    2. Positional Arguments -
    3. Positional Arguments -
    4. Internal vs External Storage -
    5. The option classes +
    6. Internal vs External Storage +
    7. Option Attributes +
    8. Option Modifiers +
    9. Option Classes + +
    10. Builtin parsers +
  2. Extension Guide
      -
    1. Writing a custom parser -
    2. Exploiting external storage -
    3. Dynamically adding command line options +
    4. Writing a custom parser +
    5. Exploiting external storage +
    6. Dynamically adding command line options
    + +

    Written by Chris Lattner

@@ -51,7 +75,11 @@ This document describes the CommandLine argument processing library. It will -show you how to use it, and what it can do.

+show you how to use it, and what it can do. The CommandLine library uses a +declarative approach to specifying the command line options that your program +takes. By default, these options declarations implicitly hold the value parsed +for the option declared (of course this can be +changed).

Although there are a lot of command line argument parsing libraries out there in many different languages, none of them fit well with what I needed. By @@ -72,36 +100,51 @@ error prone constructs, it also leads to dramatically cleaner source code.

  • No subclasses required: To use CommandLine, you instantiate variables that correspond to the arguments that you would like to capture, you don't subclass a -parser. This leads to much less boilerplate code.

    +parser. This means that you don't have to write any boilerplate code.

  • Globally accessible: Libraries can specify command line arguments that are automatically enabled in any tool that links to the library. This is possible because the application doesn't have to keep a "list" of arguments to pass to -the parser.

    +the parser. This also makes supporting dynamically +loaded options trivial.

    -

  • More Clean: CommandLine supports enum types directly, meaning that there is -less error and more security built into the library. You don't have to worry -about whether your integral command line argument accidentally got assigned a -value that is not valid for your enum type.

    +

  • More Clean: CommandLine supports enum and other types directly, meaning that +there is less error and more security built into the library. You don't have to +worry about whether your integral command line argument accidentally got +assigned a value that is not valid for your enum type.

  • Powerful: The CommandLine library supports many different types of -arguments, from simple boolean flags to scalars arguments (strings, integers, -enums, doubles), to lists of arguments. This is possible because CommandLine -is...

    +arguments, from simple boolean flags to scalars arguments (strings, integers, enums, doubles), to lists of +arguments. This is possible because CommandLine is...

  • Extensible: It is very simple to add a new argument type to CommandLine. Simply specify the parser that you want to use with the command line option when -you declare it. Custom parsers are no problem.

    +you declare it. Custom parsers are no problem.

  • Labor Saving: The CommandLine library cuts down on the amount of grunt work -that you, the user, have to do. For example, it automatically provides a --help -option that shows the available command line options for your tool.

    +that you, the user, have to do. For example, it automatically provides a +--help option that shows the available command line options for your +tool. Additionally, it does most of the basic correctness checking for you.

    + +

  • Capable: The CommandLine library can handle lots of different forms of +options often found in real programs. For example, positional arguments, ls style grouping options (to allow processing 'ls +-lad' naturally), ld style prefix +options (to parse '-lmalloc -L/usr/lib'), and interpreter style options.

    + This document will hopefully let you jump in and start using CommandLine in your utility quickly and painlessly. Additionally it should be a simple reference -manual to figure out how stuff works. If it is failing in some area, nag the -author, Chris Lattner.

    +manual to figure out how stuff works. If it is failing in some area (or you +want an extension to the library), nag the author, Chris Lattner.

    + @@ -144,15 +187,16 @@ support the unix standard '-o <filename>' option to specify where to put the output. With the CommandLine library, this is represented like this:

    -

    -cl::opt<string> OutputFilename("o", cl::desc("Specify output filename"), cl::value_desc("filename"));
+
    
+cl::opt<string> OutputFilename("o", cl::desc("Specify output filename"), cl::value_desc("filename"));
 
    
 
 This declares a variable "OutputFilename" that is used to capture the
 result of the "o" argument (first parameter).  We specify that this is
-a simple scalar option by using the "opt<>" template (as opposed
-to the "list<> template), and tell the
-CommandLine library that the data type that we are parsing is a string.
    
+a simple scalar option by using the "cl::opt"
+template (as opposed to the "cl::list
+template), and tell the CommandLine library that the data type that we are
+parsing is a string.
    
 
 The second and third parameters (which are optional) are used to specify what to
 output for the "--help" option.  In this case, we get a line that looks
@@ -181,50 +225,52 @@ example:
    
 There are many different options that you can use to customize the command line
 option handling library, but the above example shows the general interface to
 these options.  The options can be specified in any order, and are specified
-with helper functions like cl::desc(...), so there are no positional
-dependencies to have to remember.  We will discuss the options you can use later
-in this document.  Also note that if your compiler supports Koenig lookup (gcc
-2.95.x doesn't), that you don't have to specify as many cl:: namespace
-qualifiers to use the library.
    
+with helper functions like cl::desc(...), so
+there are no positional dependencies to have to remember.  The available options
+are discussed in detail in the Reference Guide.
    
+
 
 Continuing the example, we would like to have our compiler take an input
 filename as well as an output filename, but we do not want the input filename to
 be specified with a hyphen (ie, not -filename.c).  To support this
-style of argument, the CommandLine library allows for positional arguments to be
-specified for the program.  These positional arguments are filled with command
-line parameters that are not in option form.  We use this feature like this:
    
+style of argument, the CommandLine library allows for positional arguments to be specified for the program.
+These positional arguments are filled with command line parameters that are not
+in option form.  We use this feature like this:
    
 
 
    -cl::opt<string> InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
+cl::opt<string> InputFilename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
 
    
 
 This declaration indicates that the first positional argument should be treated
-as the input filename.  Here we use the cl::init option to specify an
-initial value for the command line option, which is used if the option is not
-specified (if you do not specify a cl::init modifier for an option,
-then the default constructor for the data type is used to initialize the value).
+as the input filename.  Here we use the cl::init option to specify an initial value for the
+command line option, which is used if the option is not specified (if you do not
+specify a cl::init modifier for an option, then
+the default constructor for the data type is used to initialize the value).
 Command line options default to being optional, so if we would like to require
-that the user always specify an input filename, we would add the
-cl::Required flag, and we could eliminate the cl::init
-modifier, like this:
    
+that the user always specify an input filename, we would add the cl::Required flag, and we could eliminate the
+cl::init modifier, like this:
    
 
 
    -cl::opt<string> InputFilename(cl::Positional, cl::desc("<input file>"), cl::Required);
+cl::opt<string> InputFilename(cl::Positional, cl::desc("<input file>"), cl::Required);
 
    
 
 Again, the CommandLine library does not require the options to be specified in
 any particular order, so the above declaration is equivalent to:
    
 
 
    -cl::opt<string> InputFilename(cl::Positional, cl::Required, cl::desc("<input file>"));
+cl::opt<string> InputFilename(cl::Positional, cl::Required, cl::desc("<input file>"));
 
    
 
-By simply adding the cl::Required flag, the CommandLine library will
-automatically issue an error if the argument is not specified, which shifts all
-of the command line option verification code out of your application into the
-library.  This is just one example of how using flags can alter the default
-behaviour of the library, on a per-option basis.  By adding one of the
-declarations above, the --help option synopsis is now extended to:
    
+By simply adding the cl::Required flag, the
+CommandLine library will automatically issue an error if the argument is not
+specified, which shifts all of the command line option verification code out of
+your application into the library.  This is just one example of how using flags
+can alter the default behaviour of the library, on a per-option basis.  By
+adding one of the declarations above, the --help option synopsis is now
+extended to:
    
 
 
     USAGE: compiler [options] <input file>
@@ -249,17 +295,17 @@ compatibility with some of our users.  We can support these by declaring options
 of boolean type like this:
    
 
 
    -cl::opt<bool> Force ("f", cl::desc("Overwrite output files"));
-cl::opt<bool> Quiet ("quiet", cl::desc("Don't print informational messages"));
-cl::opt<bool> Quiet2("q", cl::desc("Don't print informational messages"), cl::Hidden);
+cl::opt<bool> Force ("f", cl::desc("Overwrite output files"));
+cl::opt<bool> Quiet ("quiet", cl::desc("Don't print informational messages"));
+cl::opt<bool> Quiet2("q", cl::desc("Don't print informational messages"), cl::Hidden);
 
    
 
 This does what you would expect: it declares three boolean variables
 ("Force", "Quiet", and "Quiet2") to recognize these
-options.  Note that the "-q" option is specified with the
-"cl::Hidden" flag.  This modifier prevents it from being shown by the
-standard "--help" output (note that it is still shown in the
-"--help-hidden" output).
    
+options.  Note that the "-q" option is specified with the "cl::Hidden" flag.  This modifier prevents it
+from being shown by the standard "--help" output (note that it is still
+shown in the "--help-hidden" output).
    
 
 The CommandLine library uses a different parser for different data types.  For
 example, in the string case, the argument passed to the option is copied
@@ -307,11 +353,11 @@ OPTIONS:
   -help  - display available options (--help-hidden for more)
 
    
 
-This brief example has shown you how to use the 'opt<>' class to
-parse simple scalar command line arguments.  In addition to simple scalar
-arguments, the CommandLine library also provides primitives to support
-CommandLine option aliases, and lists
-of options.
    
+This brief example has shown you how to use the 'cl::opt' class to parse simple scalar command line
+arguments.  In addition to simple scalar arguments, the CommandLine library also
+provides primitives to support CommandLine option aliases,
+and lists of options.
    
 
 
 
@@ -329,23 +375,24 @@ quiet condition like this now:

    ... which is a real pain! Instead of defining two values for the same -condition, we can use the "cl::alias" class to make the "-q" +condition, we can use the "cl::alias" class to make the "-q" option an alias for the "-quiet" option, instead of providing a value itself:

    -cl::opt<bool> Force ("f", cl::desc("Overwrite output files"));
-cl::opt<bool> Quiet ("quiet", cl::desc("Don't print informational messages"));
-cl::alias     QuietA("q", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet));
+cl::opt<bool> Force ("f", cl::desc("Overwrite output files"));
+cl::opt<bool> Quiet ("quiet", cl::desc("Don't print informational messages"));
+cl::alias     QuietA("q", cl::desc("Alias for -quiet"), cl::aliasopt(Quiet));

    The third line (which is the only one we modified from above) defines a "-q alias that updates the "Quiet" variable (as specified by -the cl::aliasopt modifier) whenever it is specified. Because aliases -do not hold state, the only thing the program has to query is the Quiet -variable now. Another nice feature of aliases is that they automatically hide -themselves from the -help output (although, again, they are still -visible in the --help-hidden output).

    +the cl::aliasopt modifier) whenever it is +specified. Because aliases do not hold state, the only thing the program has to +query is the Quiet variable now. Another nice feature of aliases is +that they automatically hide themselves from the -help output +(although, again, they are still visible in the --help-hidden +output).

    Now the application code can simply use:

    @@ -355,7 +402,7 @@ Now the application code can simply use:

    ...

    -... which is much nicer! The "cl::alias" can be used to specify an +... which is much nicer! The "cl::alias" can be used to specify an alternative name for any variable type, and has many uses.

    @@ -400,8 +447,8 @@ enum OptLevel { g, O1, O2, O3 }; -cl::opt<OptLevel> OptimizationLevel(cl::desc("Choose optimization level:"), - cl::values( +cl::opt<OptLevel> OptimizationLevel(cl::desc("Choose optimization level:"), + cl::values( clEnumVal(g , "No optimizations, enable debugging"), clEnumVal(O1, "Enable trivial optimizations"), clEnumVal(O2, "Enable default optimizations"), @@ -419,8 +466,8 @@ that are listed in the declaration (Note that the declaration list must be terminated with the "0" argument!). The CommandLine library enforces that the user can only specify one of the options, and it ensure that only valid enum values can be specified. The "clEnumVal" macros ensure that the -command line arguments matche the enum values. With this option added, our help -output now is:

    +command line arguments matched the enum values. With this option added, our +help output now is:

     USAGE: compiler [options] <input file>
@@ -447,8 +494,8 @@ enum OptLevel {
   Debug, O1, O2, O3
 };
 
-cl::opt<OptLevel> OptimizationLevel(cl::desc("Choose optimization level:"),
-  cl::values(
+cl::opt<OptLevel> OptimizationLevel(cl::desc("Choose optimization level:"),
+  cl::values(
    clEnumValN(Debug, "g", "No optimizations, enable debugging"),
     clEnumVal(O1        , "Enable trivial optimizations"),
     clEnumVal(O2        , "Enable default optimizations"),
@@ -487,8 +534,8 @@ enum DebugLev {
 };
 
 // Enable Debug Options to be specified on the command line
-cl::opt DebugLevel("debug_level", cl::desc("Set the debugging level:"),
-  cl::values(
+cl::opt DebugLevel("debug_level", cl::desc("Set the debugging level:"),
+  cl::values(
     clEnumValN(nodebuginfo, "none", "disable debug information"),
      clEnumVal(quick,               "enable quick debug information"),
      clEnumVal(detailed,            "enable detailed debug information"),
@@ -537,9 +584,9 @@ lets get a little wild and crazy.  Lets say that we want our optimizer to accept
 a list of optimizations to perform, allowing duplicates.  For example, we
 might want to run: "compiler -dce -constprop -inline -dce -strip".  In
 this case, the order of the arguments and the number of appearances is very
-important.  This is what the "cl::list" template is for.  First,
-start by defining an enum of the optimizations that you would like to
-perform:
    
+important.  This is what the "cl::list"
+template is for.  First, start by defining an enum of the optimizations that you
+would like to perform:
    
 
 
     enum Opts {
@@ -548,11 +595,11 @@ enum Opts {
 };
 
    
 
-Then define your "cl::list" variable:
    
+Then define your "cl::list" variable:
    
 
 
    -cl::list<Opts> OptimizationList(cl::desc("Available Optimizations:"),
-  cl::values(
+cl::list<Opts> OptimizationList(cl::desc("Available Optimizations:"),
+  cl::values(
     clEnumVal(dce               , "Dead Code Elimination"),
     clEnumVal(constprop         , "Constant Propogation"),
    clEnumValN(inlining, "inline", "Procedure Integration"),
@@ -572,9 +619,9 @@ vector methods:
    
 
 ... to iterate through the list of options specified.
    
 
-Note that the "cl::list" template is completely general and may be used
+Note that the "cl::list" template is completely general and may be used
 with any data types or other arguments that you can use with the
-"cl::opt" template.  One especially useful way to use a list is to
+"cl::opt" template.  One especially useful way to use a list is to
 capture all of the positional arguments together if there may be more than one
 specified.  In the case of a linker, for example, the linker takes several
 '.o' files, and needs to capture them into a list.  This is naturally
@@ -582,15 +629,16 @@ specified as:
    
 
 
     ...
-cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<Input files>"), cl::OneOrMore);
+cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<Input files>"), cl::OneOrMore);
 ...
 
    
 
 This variable works just like a "vector<string>" object.  As
 such, accessing the list is simple, just like above.  In this example, we used
-the cl::OneOrMore modifier to inform the CommandLine library that it is
-an error if the user does not specify any .o files on our command line.
-Again, this just reduces the amount of checking we have to do.
    
+the cl::OneOrMore modifier to inform the
+CommandLine library that it is an error if the user does not specify any
+.o files on our command line.  Again, this just reduces the amount of
+checking we have to do.
    
 
 
 
@@ -600,7 +648,588 @@ Again, this just reduces the amount of checking we have to do.
    
 
      
 
 
-Reference Guide: TODO
+Now that you know the basics of how to use the CommandLine library, this section
+will give you the detailed information you need to tune how command line options
+work, as well as information on more "advanced" command line option processing
+capabilities.
      
+
+
+
+
       
+Positional Arguments
+
      
+
+Positional arguments are those arguments that are not named, and are not
+specified with a hyphen.  Positional arguments should be used when an option is
+specified by its position alone.  For example, the standard Unix grep
+tool takes a regular expression argument, and an optional filename to search
+through (which defaults to standard input if a filename is not specified).
+Using the CommandLine library, this would be specified as:
      
+
+
      +cl::opt<string> Regex   (cl::Positional, cl::desc("<regular expression>"), cl::Required);
+cl::opt<string> Filename(cl::Positional, cl::desc("<input file>"), cl::init("-"));
+
      
+
+Given these two option declarations, the --help output for our grep
+replacement would look like this:
      
+
+
      +USAGE: spiffygrep [options] <regular expression> <input file>
+
+OPTIONS:
+  -help - display available options (--help-hidden for more)
+
      
+
+... and the resultant program could be used just like the standard grep
+tool.
      
+
+Positional arguments are sorted by their order of construction.  This means that
+command line options will be ordered according to how they are listed in a .cpp
+file, but will not have an ordering defined if they positional arguments are
+defined in multiple .cpp files.  The fix for this problem is simply to define
+all of your positional arguments in one .cpp file.
      
+
+
+
+
+
    Specifying positional options with hyphens
      
+
+Sometimes you may want to specify a value to your positional argument that
+starts with a hyphen (for example, searching for '-foo' in a file).  At
+first, you will have trouble doing this, because it will try to find an argument
+named '-foo', and will fail (and single quotes will not save you).
+Note that the system grep has the same problem:
      
+
+
      +  $ spiffygrep '-foo' test.txt
+  Unknown command line argument '-foo'.  Try: spiffygrep --help'
+
+  $ grep '-foo' test.txt
+  grep: illegal option -- f
+  grep: illegal option -- o
+  grep: illegal option -- o
+  Usage: grep -hblcnsviw pattern file . . .
+
      
+
+The solution for this problem is the same for both your tool and the system
+version: use the '--' marker.  When the user specifies '--' on
+the command line, it is telling the program that all options after the
+'--' should be treated as positional arguments, not options.  Thus, we
+can use it like this:
      
+
+
      +  $ spiffygrep -- -foo test.txt
+    ...output...
+
      
+
+
+
+
+
    The cl::ConsumeAfter modifier
      
+
+The cl::ConsumeAfter formatting option is
+used to construct programs that use "interpreter style" option processing.  With
+this style of option processing, all arguments specified after the last
+positional argument are treated as special interpreter arguments that are not
+interpreted by the command line argument.
      
+
+As a concrete example, lets say we are developing a replacement for the standard
+Unix Bourne shell (/bin/sh).  To run /bin/sh, first you
+specify options to the shell itself (like -x which turns on trace
+output), then you specify the name of the script to run, then you specify
+arguments to the script.  These arguments to the script are parsed by the bourne
+shell command line option processor, but are not interpreted as options to the
+shell itself.  Using the CommandLine library, we would specify this as:
      
+
+
      +cl::opt<string> Script(cl::Positional, cl::desc("<input script>"), cl::init("-"));
+cl::list<string>  Argv(cl::ConsumeAfter, cl::desc("<program arguments>..."));
+cl::opt<bool>    Trace("x", cl::desc("Enable trace output"));
+
      
+
+which automatically provides the help output:
      
+
+
      +USAGE: spiffysh [options] <input script> <program arguments>...
+
+OPTIONS:
+  -help - display available options (--help-hidden for more)
+  -x    - Enable trace output
+
      
+
+At runtime, if we run our new shell replacement as 'spiffysh -x test.sh -a
+-x -y bar', the Trace variable will be set to true, the
+Script variable will be set to "test.sh", and the
+Argv list will contain ["-a", "-x", "-y", "bar"], because
+they were specified after the last positional argument (which is the script
+name).
      
+
+There are several limitations to when cl::ConsumeAfter options can be
+specified.  For example, only one cl::ConsumeAfter can be specified per
+program, there must be at least one positional
+argument specified, and the cl::ConsumeAfter option should be a cl::list option.
      
+
+
+
+
+
       
+Internal vs External Storage
+
      
+
+By default, all command line options automatically hold the value that they
+parse from the command line.  This is very convenient in the common case,
+especially when combined with the ability to define command line options in the
+files that use them.  This is called the internal storage model.
      
+
+Sometimes, however, it is nice to separate the command line option processing
+code from the storage of the value parsed.  For example, lets say that we have a
+'-debug' option that we would like to use to enable debug information
+across the entire body of our program.  In this case, the boolean value
+controlling the debug code should be globally accessable (in a header file, for
+example) yet the command line option processing code should not be exposed to
+all of these clients (requiring lots of .cpp files to #include
+CommandLine.h).
      
+
+To do this, set up your .h file with your option, like this for example:
      
+
+
      +// DebugFlag.h - Get access to the '-debug' command line option
+//
+
+// DebugFlag - This boolean is set to true if the '-debug' command line option
+// is specified.  This should probably not be referenced directly, instead, use
+// the DEBUG macro below.
+//
+extern bool DebugFlag;
+
+// DEBUG macro - This macro should be used by code to emit debug information.
+// In the '-debug' option is specified on the command line, and if this is a
+// debug build, then the code specified as the option to the macro will be
+// executed.  Otherwise it will not be.  Example:
+//
+// DEBUG(cerr << "Bitset contains: " << Bitset << "\n");
+//
+#ifdef NDEBUG
+#define DEBUG(X)
+#else
+#define DEBUG(X) \
+  do { if (DebugFlag) { X; } } while (0)
+#endif
+
      
+
+This allows clients to blissfully use the DEBUG() macro, or the
+DebugFlag explicitly if they want to.  Now we just need to be able to
+set the DebugFlag boolean when the option is set.  To do this, we pass
+an additial argument to our command line argument processor, and we specify
+where to fill in with the cl::location attribute:
      
+
+
      +bool DebugFlag;      // the actual value
+static cl::opt       // The parser
+Debug("debug", cl::desc("Enable debug output"), cl::Hidden,
+      cl::location(DebugFlag));
+
      
+
+In the above example, we specify "true" as the second argument to the
+cl::opt template, indicating that the template should not
+maintain a copy of the value itself.  In addition to this, we specify the cl::location attribute, so that DebugFlag is
+automatically set.
      
+
+
+
+
+
       
+Option Attributes
+
       
+Option Modifiers
+
    Hiding an option from --help output
    Controlling the number of occurances required and allowed
    Controlling whether or not a value must be specified
    Controlling other formatting options
       
+Option Classes
+
      
+
+Despite all of the builtin flexibility, the CommandLine option library really
+only consists of three main classes: cl::opt, cl::list, and cl::alias.  This
+section describes these three classes in detail.
      
+
+
+
    The cl::opt class
    The cl::list class
    The cl::alias class
       
+Builtin parsers
+