CbC/CbC_llvm: docs/CommandLine.rst comparison

comparison docs/CommandLine.rst @ 148:63bd29f05246

merged

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Wed, 14 Aug 2019 19:46:37 +0900
parents	c2174574ed3a
children

comparison

equal deleted inserted replaced

-:3fc4d5c3e21e
+:63bd29f05246
 ::
 USAGE: compiler [options]
 OPTIONS:
+-h                - Alias for -help
 -help             - display available options (-help-hidden for more)
 -o <filename>     - Specify output filename
 Because we specified that the command line option should parse using the
 ``string`` data type, the variable declared is automatically usable as a real
 ::
 USAGE: compiler [options] <input file>
 OPTIONS:
+-h                - Alias for -help
 -help             - display available options (-help-hidden for more)
 -o <filename>     - Specify output filename
 ... indicating that an input filename is expected.
 // 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.
 #ifdef NDEBUG
-#define DEBUG(X)
+#define LLVM_DEBUG(X)
 #else
-#define DEBUG(X) do { if (DebugFlag) { X; } } while (0)
+#define LLVM_DEBUG(X) do { if (DebugFlag) { X; } } while (0)
 #endif
-This allows clients to blissfully use the ``DEBUG()`` macro, or the
+This allows clients to blissfully use the ``LLVM_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
 additional argument to our command line argument processor, and we specify where
 to fill in with the `cl::location`_ attribute:
 specified.
 .. _grouping:
 .. _cl::Grouping:
-* The **cl::Grouping** modifier is used to implement Unix-style tools (like
+Controlling options grouping
-``ls``) that have lots of single letter arguments, but only require a single
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-dash.  For example, the '``ls -labF``' command actually enables four different
-options, all of which are single letters.  Note that **cl::Grouping** options
+The **cl::Grouping** modifier can be combined with any formatting types except
-cannot have values.
+for `cl::Positional`_.  It is used to implement Unix-style tools (like ``ls``)
+that have lots of single letter arguments, but only require a single dash.
+For example, the '``ls -labF``' command actually enables four different options,
+all of which are single letters.
+Note that **cl::Grouping** options can have values only if they are used
+separately or at the end of the groups.  For `cl::ValueRequired`_, it is
+a runtime error if such an option is used elsewhere in the group.
 The CommandLine library does not restrict how you use the **cl::Prefix** or
 **cl::Grouping** modifiers, but it is possible to specify ambiguous argument
 settings.  Thus, it is possible to have multiple letter options that are prefix
 or grouping options, and they will still work as designed.
 ::
 parse(string OrigInput) {
-1. string input = OrigInput;
+1. string Input = OrigInput;
-2. if (isOption(input)) return getOption(input).parse();  // Normal option
+2. if (isOption(Input)) return getOption(Input).parse();  // Normal option
-3. while (!isOption(input) && !input.empty()) input.pop_back();  // Remove the last letter
+3. while (!Input.empty() && !isOption(Input)) Input.pop_back();  // Remove the last letter
-4. if (input.empty()) return error();  // No matching option
+4. while (!Input.empty()) {
-5. if (getOption(input).isPrefix())
+string MaybeValue = OrigInput.substr(Input.length())
-return getOption(input).parse(input);
+if (getOption(Input).isPrefix())
-6. while (!input.empty()) {  // Must be grouping options
+return getOption(Input).parse(MaybeValue)
-getOption(input).parse();
+if (!MaybeValue.empty() && MaybeValue[0] == '=')
-OrigInput.erase(OrigInput.begin(), OrigInput.begin()+input.length());
+return getOption(Input).parse(MaybeValue.substr(1))
-input = OrigInput;
+if (!getOption(Input).isGrouping())
-while (!isOption(input) && !input.empty()) input.pop_back();
+return error()
+getOption(Input).parse()
+Input = OrigInput = MaybeValue
+while (!Input.empty() && !isOption(Input)) Input.pop_back();
+if (!Input.empty() && !getOption(Input).isGrouping())
+return error()
 }
-7. if (!OrigInput.empty()) error();
+5. if (!OrigInput.empty()) error();
 }
 Miscellaneous option modifiers
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 the option.  For example, these two options are equivalent when
 ``cl::CommaSeparated`` is specified: "``-foo=a -foo=b -foo=c``" and
 "``-foo=a,b,c``".  This option only makes sense to be used in a case where the
 option is allowed to accept one or more values (i.e. it is a `cl::list`_
 option).
+.. _cl::DefaultOption:
+* The **cl::DefaultOption** modifier is used to specify that the option is a
+default that can be overridden by application specific parsers. For example,
+the ``-help`` alias, ``-h``, is registered this way, so it can be overridden
+by applications that need to use the ``-h`` option for another purpose,
+either as a regular option or an alias for another option.
 .. _cl::PositionalEatsArgs:
 * The **cl::PositionalEatsArgs** modifier (which only applies to positional
 arguments, and only makes sense for lists) indicates that positional argument
 least one option with ``cl::Sink`` modifier specified, the parser passes
 unrecognized option strings to it as values instead of signaling an error. As
 with ``cl::CommaSeparated``, this modifier only makes sense with a `cl::list`_
 option.
-So far, these are the only three miscellaneous option modifiers.
 .. _response files:
 Response files
 ^^^^^^^^^^^^^^
 Note this method should not be called during any static initialisation because
 it cannot be guaranteed that all options will have been initialised. Hence it
 should be called from ``main``.
 This function can be used to gain access to options declared in libraries that
-the tool writter may not have direct access to.
+the tool writer may not have direct access to.
 The function retrieves a :ref:`StringMap <dss_stringmap>` that maps the option
 string (e.g. ``-help``) to an ``Option*``.
 Here is an example of how the function could be used:
 a feature. However, sometimes it is necessary to know the value of the command
 line option outside of the library. In these cases the library does or should
 provide an external storage location that is accessible to users of the
 library. Examples of this include the ``llvm::DebugFlag`` exported by the
 ``lib/Support/Debug.cpp`` file and the ``llvm::TimePassesIsEnabled`` flag
-exported by the ``lib/VMCore/PassManager.cpp`` file.
+exported by the ``lib/IR/PassManager.cpp`` file.
 .. todo::
 TODO: complete this section

Mercurial > hg > CbC > CbC_llvm

comparison docs/CommandLine.rst @ 148:63bd29f05246