Initial work on CLI port

Add options files with all the documentation. Move documentation and usage to
use the new approach. Finally get rid of dependency on libbackend-elements.

2 files changed, 418 insertions, 534 deletions

diff --git a/xsd/cxx/tree/generator.cxx b/xsd/cxx/tree/generator.cxx
index 5fe4af5..7a6759b 100644
--- a/xsd/cxx/tree/generator.cxx
+++ b/xsd/cxx/tree/generator.cxx
@@ -16,8 +16,6 @@
 #include <cutl/compiler/cxx-indenter.hxx>
 #include <cutl/compiler/sloc-counter.hxx>
 
-#include <backend-elements/indentation/clip.hxx>
-
 #include <xsd-frontend/semantic-graph.hxx>
 
 #include <cxx/tree/generator.hxx>
@@ -47,7 +45,7 @@
 #include <cxx/tree/stream-insertion-source.hxx>
 #include <cxx/tree/stream-extraction-source.hxx>
 
-#include <usage.hxx>
+#include <cxx/tree/options.hxx>
 
 #include "../../../libxsd/xsd/cxx/version.hxx"
 
@@ -223,536 +221,8 @@ namespace CXX
   Void Tree::Generator::
   usage ()
   {
-    std::wostream& o (wcout);
-    ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (o);
-
-    o << "--char-type <type>" << endl
-      << " Use <type> as the base character type. Valid\n"
-      << " values are 'char' (default) and 'wchar_t'."
-      << endl;
-
-    o << "--char-encoding <enc>" << endl
-      << " Specify the character encoding that should be used\n"
-      << " in the object model. Valid values for the 'char'\n"
-      << " character type are 'utf8' (default), 'iso8859-1',\n"
-      << " 'lcp', and 'custom'. For the 'wchar_t' character\n"
-      << " type the only valid value is 'auto'."
-      << endl;
-
-    o << "--output-dir <dir>" << endl
-      << " Write generated files to <dir> instead of current\n"
-      << " directory."
-      << endl;
-
-    o << "--generate-polymorphic" << endl
-      << " Generate polymorphism-aware code. Specify this\n"
-      << " option if you use substitution groups or xsi:type."
-      << endl;
-
-    o << "--polymorphic-type <type>" << endl
-      << " Indicate that <type> is a root of a polymorphic\n"
-      << " type hierarchy."
-      << endl;
-
-    o << "--polymorphic-type-all" << endl
-      << " Indicate that all types should be treated as\n"
-      << " polymorphic."
-      << endl;
-
-    o << "--generate-serialization" << endl
-      << " Generate serialization functions. They convert an\n"
-      << " in-memory representation back to XML."
-      << endl;
-
-    o << "--generate-inline" << endl
-      << " Generate certain functions inline."
-      << endl;
-
-    o << "--generate-ostream" << endl
-      << " Generate ostream insertion operators."
-      << endl;
-
-    o << "--generate-doxygen" << endl
-      << " Generate documentation comments in the Doxygen\n"
-      << " format."
-      << endl;
-
-    o << "--generate-comparison" << endl
-      << " Generate comparison operators."
-      << endl;
-
-    o << "--generate-default-ctor" << endl
-      << " Generate default constructors even for types that\n"
-      << " have required members."
-      << endl;
-
-    o << "--generate-from-base-ctor" << endl
-      << " Generate from-base constructors."
-      << endl;
-
-    o << "--suppress-assignment" << endl
-      << " Suppress the generation of copy assignment\n"
-      << " operators for complex types."
-      << endl;
-
-    o << "--generate-detach" << endl
-      << " Generate detach functions for required members."
-      << endl;
-
-    o << "--generate-wildcard" << endl
-      << " Generate accessors/modifiers as well as parsing\n"
-      << " and serialization code for XML Schema wildcards."
-      << endl;
-
-    o << "--generate-insertion <os>" << endl
-      << " Generate data representation stream insertion\n"
-      << " operators for the <os> output stream type."
-      << endl;
-
-    o << "--generate-extraction <is>" << endl
-      << " Generate data representation stream extraction\n"
-      << " constructors for the <is> input stream type."
-      << endl;
-
-    o << "--generate-forward" << endl
-      << " Generate forward declaration file."
-      << endl;
-
-    o << "--generate-xml-schema" << endl
-      << " Generate a C++ header file as if the schema being\n"
-      << " compiled defines the XML Schema namespace."
-      << endl;
-
-    o << "--extern-xml-schema <file>" << endl
-      << " Generate code as if the XML Schema namespace was\n"
-      << " defined in <file> and xsd:included in the schema\n"
-      << " being compiled."
-      << endl;
-
-    o << "--suppress-parsing" << endl
-      << " Suppress the generation of parsing functions."
-      << endl;
-
-    o << "--generate-element-type" << endl
-      << " Generate types instead of parsing/serialization\n"
-      << " functions for root elements."
-      << endl;
-
-    o << "--generate-element-map" << endl
-      << " Generate a root element map that allows uniform\n"
-      << " parsing/serialization of multiple root elements.\n"
-      << endl;
-
-    o << "--generate-intellisense" << endl
-      << " Generate workarounds for IntelliSense bugs in\n"
-      << " Visual Studio 2005 (8.0)."
-      << endl;
-
-    o << "--omit-default-attributes" << endl
-      << " Omit attributes with default and fixed values\n"
-      << " from serialized XML documents."
-      << endl;
-
-    o << "--namespace-map <xns>=<cns>" << endl
-      << " Map XML Schema namespace <xns> to C++ namespace\n"
-      << " <cns>. Repeat this option to specify mapping for\n"
-      << " more than one XML Schema namespace."
-      << endl;
-
-    o << "--namespace-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to translate XML Schema namespace names to\n"
-      << " C++ namespace names."
-      << endl;
-
-    o << "--namespace-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --namespace-regex option."
-      << endl;
-
-    o << "--reserved-name <name>" << endl
-      << " Add <name> to the list of names that should not\n"
-      << " be used as identifiers. The name can optionally\n"
-      << " be followed by '=' and the replacement name that\n"
-      << " should be used instead."
-      << endl;
-
-    o << "--type-naming <style>" << endl
-      << " Specify the type naming convention that should be\n"
-      << " used in the generated code. Valid styles are 'knr'\n"
-      << " (default), 'ucc', and 'java'."
-      << endl;
-
-    o << "--function-naming <style>" << endl
-      << " Specify the function naming convention that should\n"
-      << " be used in the generated code. Valid styles are\n"
-      << " 'knr' (default), 'lcc', and 'java'."
-      << endl;
-
-    o << "--type-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema type names to C++\n"
-      << " type names."
-      << endl;
-
-    o << "--accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements and\n"
-      << " attributes to C++ accessor function names."
-      << endl;
-
-    o << "--one-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality one to C++\n"
-      << " accessor function names."
-      << endl;
-
-    o << "--opt-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality optional to C++\n"
-      << " accessor function names."
-      << endl;
-
-    o << "--seq-accessor-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality sequence to C++\n"
-      << " accessor function names."
-      << endl;
-
-    o << "--modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements and\n"
-      << " attributes to C++ modifier function names."
-      << endl;
-
-    o << "--one-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality one to C++\n"
-      << " modifier function names."
-      << endl;
-
-    o << "--opt-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality optional to C++\n"
-      << " modifier function names."
-      << endl;
-
-    o << "--seq-modifier-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema names of elements\n"
-      << " and attributes with cardinality sequence to C++\n"
-      << " modifier function names."
-      << endl;
-
-    o << "--parser-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ parsing function names."
-      << endl;
-
-    o << "--serializer-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ serialization function names."
-      << endl;
-
-    o << "--enumerator-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema enumeration values\n"
-      << " to C++ enumerator names."
-      << endl;
-
-    o << "--element-type-regex <expr>" << endl
-      << " Add <expr> to the list of regular expressions\n"
-      << " used to translate XML Schema element names to\n"
-      << " C++ element type names."
-      << endl;
-
-    o << "--name-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the name transformation options."
-      << endl;
-
-    o << "--include-with-brackets" << endl
-      << " Use angle brackets (<>) instead of quotes (\"\") in\n"
-      << " generated #include directives."
-      << endl;
-
-    o << "--include-prefix <prefix>" << endl
-      << " Add <prefix> to generated #include directive\n"
-      << " paths."
-      << endl;
-
-    o << "--include-regex <regex>" << endl
-      << " Add <regex> to the list of regular expressions\n"
-      << " used to transform #include directive paths."
-      << endl;
-
-    o << "--include-regex-trace" << endl
-      << " Trace the process of applying regular expressions\n"
-      << " specified with the --include-regex option."
-      << endl;
-
-    o << "--guard-prefix <prefix>" << endl
-      << " Add <prefix> to generated header inclusion guards."
-      << endl;
-
-    o << "--root-element-first" << endl
-      << " Treat only the first global element as a document\n"
-      << " root."
-      << endl;
-
-    o << "--root-element-last" << endl
-      << " Treat only the last global element as a document\n"
-      << " root."
-      << endl;
-
-    o << "--root-element-all" << endl
-      << " Treat all global elements as document roots."
-      << endl;
-
-    o << "--root-element-none" << endl
-      << " Don't treat any global elements as document roots."
-      << endl;
-
-    o << "--root-element <element>" << endl
-      << " Treat only <element> as a document root. Repeat\n"
-      << " this option to specify more than one root element."
-      << endl;
-
-    o << "--custom-type <map>" << endl
-      << " Use a custom C++ type instead of the generated\n"
-      << " class. The <map> argument is in the form\n"
-      << " name[=type[/base]], where <name> is a type name as\n"
-      << " defined in XML Schema, <type> is a C++ type name\n"
-      << " that should be used instead, and optional <base>\n"
-      << " is a C++ name that should be given to the C++\n"
-      << " class generated from the XML Schema definition\n"
-      << " which is normally used as a base for the custom\n"
-      << " type."
-      << endl;
-
-    o << "--custom-type-regex <regex>" << endl
-      << " Use custom C++ types instead of the generated\n"
-      << " classes. The <regex> argument is in the form\n"
-      << " /name/[type/[base/]], where <name> is a regex\n"
-      << " pattern that will be matched against type names\n"
-      << " as defined in XML Schema, <type> is a C++ type\n"
-      << " name that should be used instead, and optional\n"
-      << " <base> is a C++ name that should be given to\n"
-      << " the C++ class generated from the XML Schema\n"
-      << " definition."
-      << endl;
-
-    o << "--hxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.hxx' to\n"
-      << " construct the name of the header file."
-      << endl;
-
-    o << "--ixx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.ixx' to\n"
-      << " construct the name of the inline file."
-      << endl;
-
-    o << "--cxx-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '.cxx' to\n"
-      << " construct the name of the source file."
-      << endl;
-
-    o << "--fwd-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-fwd.hxx'\n"
-      << " to construct the name of the forward declaration\n"
-      << " file."
-      << endl;
-
-    o << "--hxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the header\n"
-      << " file."
-      << endl;
-
-    o << "--ixx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the inline\n"
-      << " file."
-      << endl;
-
-    o << "--cxx-regex <regex>" << endl
-      << " Use <regex> to construct the name of the source\n"
-      << " file."
-      << endl;
-
-    o << "--fwd-regex <regex>" << endl
-      << " Use <regex> to construct the name of the forward\n"
-      << " declaration file."
-      << endl;
-
-    // Prologues.
-    //
-    o << "--hxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the header file."
-      << endl;
-
-    o << "--ixx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the inline file."
-      << endl;
-
-    o << "--cxx-prologue <text>" << endl
-      << " Insert <text> at the beginning of the source file."
-      << endl;
-
-    o << "--fwd-prologue <text>" << endl
-      << " Insert <text> at the beginning of the forward\n"
-      << " declaration file."
-      << endl;
-
-    o << "--prologue <text>" << endl
-      << " Insert <text> at the beginning of each generated\n"
-      << " file for which there is no file-specific prologue."
-      << endl;
-
-
-    // Epilogues.
-    //
-    o << "--hxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the header file."
-      << endl;
-
-    o << "--ixx-epilogue <text>" << endl
-      << " Insert <text> at the end of the inline file."
-      << endl;
-
-    o << "--cxx-epilogue <text>" << endl
-      << " Insert <text> at the end of the source file."
-      << endl;
-
-    o << "--fwd-epilogue <text>" << endl
-      << " Insert <text> at the end of the forward\n"
-      << " declaration file."
-      << endl;
-
-    o << "--epilogue <text>" << endl
-      << " Insert <text> at the end of each generated file\n"
-      << " for which there is no file-specific epilogue."
-      << endl;
-
-
-    // Prologue files.
-    //
-    o << "--hxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the header file."
-      << endl;
-
-    o << "--ixx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the inline file."
-      << endl;
-
-    o << "--cxx-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the source file."
-      << endl;
-
-    o << "--fwd-prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of the forward declaration file."
-      << endl;
-
-    o << "--prologue-file <file>" << endl
-      << " Insert the content of the <file> at the beginning\n"
-      << " of each generated file for which there is no file-\n"
-      << " specific prologue file."
-      << endl;
-
-    // Epilogue files.
-    //
-    o << "--hxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the header file."
-      << endl;
-
-    o << "--ixx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the inline file."
-      << endl;
-
-    o << "--cxx-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the source file."
-      << endl;
-
-    o << "--fwd-epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " the forward declaration file."
-      << endl;
-
-    o << "--epilogue-file <file>" << endl
-      << " Insert the content of the <file> at the end of\n"
-      << " each generated file for which there is no file-\n"
-      << " specific epilogue file."
-      << endl;
-
-    // Misc.
-    //
-    o << "--parts <num>" << endl
-      << " Split generated source code into <num> parts."
-      << endl;
-
-    o << "--parts-suffix <suffix>" << endl
-      << " Use <suffix> instead of the default '-' to\n"
-      << " separate the file name from the part number."
-      << endl;
-
-    o << "--custom-literals <file>" << endl
-      << " Load custom XML string to C++ literal mappings\n"
-      << " from <file>."
-      << endl;
-
-    o << "--export-symbol <symbol>" << endl
-      << " Export symbol for Win32 DLL export/import control."
-      << endl;
-
-    o << "--export-xml-schema" << endl
-      << " Export/import types in the XML Schema namespace."
-      << endl;
-
-    o << "--export-maps" << endl
-      << " Export polymorphism support maps from Win32 DLL."
-      << endl;
-
-    o << "--import-maps" << endl
-      << " Import polymorphism support maps from Win32 DLL."
-      << endl;
-
-    o << "--show-anonymous" << endl
-      << " Show elements and attributes that are of anonymous\n"
-      << " types."
-      << endl;
-
-    o << "--show-sloc" << endl
-      << " Show the number of generated physical source lines\n"
-      << " of code (SLOC)."
-      << endl;
-
-    o << "--sloc-limit <num>" << endl
-      << " Check that the number of generated physical source\n"
-      << " lines of code (SLOC) does not exceed <num>."
-      << endl;
-
-    o << "--options-file <file>" << endl
-      << " Read additional options from <file>. Each option\n"
-      << " should appear on a separate line optionally\n"
-      << " followed by space and an argument."
-      << endl;
-
-    o << "--proprietary-license" << endl
-      << " Indicate that the generated code is licensed under\n"
-      << " a proprietary license instead of the GPL."
-      << endl;
+    CXX::Tree::options::print_usage (wcout);
+    CXX::options::print_usage (wcout);
   }
 
   Tree::CLI::OptionsSpec Tree::Generator::
@@ -852,7 +322,6 @@ namespace CXX
             AutoUnlinks& unlinks)
   {
     using std::ios_base;
-    namespace Indentation = BackendElements::Indentation;
 
     typedef cutl::re::regexsub Regex;
 
diff --git a/xsd/cxx/tree/options.cli b/xsd/cxx/tree/options.cli
new file mode 100644
index 0000000..58407fa
--- /dev/null
+++ b/xsd/cxx/tree/options.cli
@@ -0,0 +1,415 @@
+// file      : xsd/cxx/tree/options.cli
+// author    : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
+// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <vector>;
+include <string>;
+include <cstddef>; // std::size_t
+
+include <cult/types.hxx>; // NarrowString
+
+include <cxx/options.cli>;
+
+namespace CXX
+{
+  namespace Tree
+  {
+    class options: CXX::options
+    {
+      // Polymorphism.
+      //
+      bool --generate-polymorphic
+      {
+        "Generate polymorphism-aware code. Specify this option if you use
+         substitution groups or \cb{xsi:type}. Use the \cb{--polymorphic-type}
+         or \cb{--polymorphic-type-all} option to specify which type
+         hierarchies are polymorphic."
+      };
+
+      std::vector<Cult::Types::NarrowString> --polymorphic-type
+      {
+        "<type>",
+        "Indicate that <type> is a root of a polymorphic type hierarchy. The
+         compiler can often automatically determine which types are
+         polymorphic based on the substitution group declarations. However,
+         you may need to use this option if you are not using substitution
+         groups or if substitution groups are defined in another schema. You
+         need to specify this option when compiling every schema file that
+         references <type>. The <type> argument is an XML Schema type name
+         that can be optionally qualified with a namespace in the
+         \c{\i{namespace}\b{#}\i{name}} form."
+      };
+
+      bool --polymorphic-type-all
+      {
+        "Indicate that all types should be treated as polymorphic."
+      };
+
+
+      // Features.
+      //
+      bool --generate-serialization
+      {
+        "Generate serialization functions. Serialization functions convert
+         the object model back to XML."
+      };
+
+      bool --generate-inline
+      {
+        "Generate simple functions inline. This option triggers creation of
+         the inline file."
+      };
+
+      bool --generate-ostream
+      {
+        "Generate ostream insertion operators (\cb{operator<<}) for generated
+         types. This allows one to easily print a fragment or the whole object
+         model for debugging or logging."
+      };
+
+      bool --generate-doxygen
+      {
+        "Generate documentation comments suitable for extraction by the
+         Doxygen documentation system. Documentation from annotations is
+         added to the comments if present in the schema."
+      };
+
+      bool --generate-comparison
+      {
+        "Generate comparison operators (\cb{operator==} and \cb{operator!=})
+         for complex types. Comparison is performed member-wise."
+      };
+
+      bool --generate-default-ctor
+      {
+        "Generate default constructors even for types that have required
+         members. Required members of an instance constructed using such a
+         constructor are not initialized and accessing them results in
+         undefined behavior."
+      };
+
+      bool --generate-from-base-ctor
+      {
+        "Generate constructors that expect an instance of a base type
+         followed by all required members."
+      };
+
+      bool --suppress-assignment
+      {
+        "Suppress the generation of copy assignment operators for complex
+         types. If this option is specified, the copy assignment operators
+         for such types are declared private and left unimplemented."
+      };
+
+      bool --generate-detach
+      {
+        "Generate detach functions for required elements and attributes.
+         Detach functions for optional and sequence cardinalities are
+         provided by the respective containers. These functions, for
+         example, allow you to move sub-trees in the object model either
+         within the same tree or between different trees."
+      };
+
+      bool --generate-wildcard
+      {
+        "Generate accessors and modifiers as well as parsing and serialization
+         code for XML Schema wildcards (\cb{any} and \cb{anyAttribute}). XML
+         content matched by wildcards is presented as DOM fragments. Note
+         that you need to initialize the Xerces-C++ runtime if you are using
+         this option."
+      };
+
+      std::vector<Cult::Types::NarrowString> --generate-insertion
+      {
+        "<os>",
+        "Generate data representation stream insertion operators for the <os>
+         output stream type. Repeat this option to specify more than one
+         stream type. The ACE CDR stream (\cb{ACE_OutputCDR}) and RPC XDR
+         are recognized by the compiler and the necessary \cb{#include}
+         directives are automatically generated. For custom stream types use
+         the \cb{--hxx-prologue*} options to provide the necessary
+         declarations."
+      };
+
+      std::vector<Cult::Types::NarrowString> --generate-extraction
+      {
+        "<is>",
+        "Generate data representation stream extraction constructors for the
+         <is> input stream type. Repeat this option to specify more than one
+         stream type. The ACE CDR stream (\cb{ACE_InputCDR}) and RPC XDR are
+         recognized by the compiler and the necessary \cb{#include} directives
+         are automatically generated. For custom stream types use the
+         \cb{--hxx-prologue*} options to provide the necessary declarations."
+      };
+
+      bool --generate-forward
+      {
+        "Generate a separate header file with forward declarations for the
+         types being generated."
+      };
+
+      bool --suppress-parsing
+      {
+        "Suppress the generation of the parsing functions and constructors.
+         Use this option to reduce the generated code size when parsing from
+         XML is not needed."
+      };
+
+      bool --generate-element-type
+      {
+        "Generate types instead of parsing and serialization functions for
+         root elements. This is primarily useful to distinguish object models
+         with the same root type but with different root elements."
+      };
+
+      bool --generate-element-map
+      {
+        "Generate a root element map that allows uniform parsing and
+         serialization of multiple root elements. This option is only valid
+         together with \cb{--generate-element-type}."
+      };
+
+      bool --generate-intellisense
+      {
+        "Generate workarounds for IntelliSense bugs in Visual Studio 2005
+         (8.0). When this option is used, the resulting code is slightly
+         more verbose. IntelliSense in Visual Studio 2008 (9.0) and later
+         does not require these workarounds. Support for IntelliSense in
+         Visual Studio 2003 (7.1) is improved with this option but is
+         still incomplete."
+      };
+
+      bool --omit-default-attributes
+      {
+        "Omit attributes with default and fixed values from serialized XML
+         documents."
+      };
+
+      // Naming.
+      //
+      Cult::Types::NarrowString --type-naming = "knr"
+      {
+        "<style>",
+        "Specify the type naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{ucc},
+         and \cb{java}. See the NAMING CONVENTION section below for more
+         information."
+      };
+
+      Cult::Types::NarrowString --function-naming = "knr"
+      {
+        "<style>",
+        "Specify the function naming convention that should be used in the
+         generated code. Valid styles are \cb{knr} (default), \cb{lcc}, and
+         \cb{java}. See the NAMING CONVENTION section below for more
+         information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --type-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema type names to C++ type names. See the NAMING CONVENTION
+         section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes to C++ accessor function
+         names. See the NAMING CONVENTION section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --one-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality one to
+         C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --opt-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality optional
+         to C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --seq-accessor-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality sequence
+         to C++ accessor function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes to C++ modifier function
+         names. See the NAMING CONVENTION section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --one-modifier-regex
+
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality one to C++
+         modifier function names. See the NAMING CONVENTION section below
+         for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --opt-modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality optional
+         to C++ modifier function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --seq-modifier-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema names of elements/attributes with cardinality sequence
+         to C++ modifier function names. See the NAMING CONVENTION section
+         below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --parser-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ parsing function names. See the
+         NAMING CONVENTION section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --serializer-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ serialization function names. See
+         the NAMING CONVENTION section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --enumerator-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema enumeration values to C++ enumerator names. See the
+         NAMING CONVENTION section below for more information."
+      };
+
+      std::vector<Cult::Types::NarrowString> --element-type-regex
+      {
+        "<regex>",
+        "Add <regex> to the list of regular expressions used to translate
+         XML Schema element names to C++ element type names. See the NAMING
+         CONVENTION section below for more information."
+      };
+
+      bool --name-regex-trace
+      {
+        "Trace the process of applying regular expressions specified with
+         the name transformation options. Use this option to find out why
+         your regular expressions don't do what you expected them to do."
+      };
+
+      // Root element.
+      //
+      bool --root-element-first
+      {
+        "Treat only the first global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --root-element-last
+      {
+        "Treat only the last global element as a document root. By default
+         all global elements are considered document roots."
+      };
+
+      bool --root-element-all
+      {
+        "Treat all global elements as document roots. This is the default
+         behavior. By explicitly specifying this option you can suppress
+         the warning that is issued if more than one global element is
+         defined."
+      };
+
+      bool --root-element-none
+      {
+        "Do not treat any global elements as document roots. By default all
+         global elements are considered document roots."
+      };
+
+      std::vector<Cult::Types::NarrowString> --root-element
+      {
+        "<element>",
+        "Treat only <element> as a document root. Repeat this option to
+         specify more than one root element."
+      };
+
+      // Custom type.
+      //
+      std::vector<Cult::Types::NarrowString> --custom-type
+      {
+        "<map>",
+        "Use a custom C++ type instead of the generated class. The <map>
+         argument is in the form \c{\i{name}[\b{=}\i{type}[\b{/}\i{base}]]},
+         where \i{name} is a type name as defined in XML Schema and \i{type}
+         is a C++ type name that should be used instead. If \i{type} is not
+         present or empty then the custom type is assumed to have the same
+         name and be defined in the same namespace as the generated class
+         would have. If \i{base} is specified then the generated class is
+         still generated but with that name."
+      };
+
+      std::vector<Cult::Types::NarrowString> --custom-type-regex
+      {
+        "<regex>",
+        "Use custom C++ types instead of the generated classes. The <regex>
+         argument is in the form
+         \c{\b{/}\i{name-pat}\b{/}[\i{type-sub}\b{/}[\i{base-sub}\b{/}]]},
+         where \i{name-pat} is a regex pattern that will be matched against
+         type names as defined in XML Schema and \i{type-sub} is a C++ type
+         name substitution that should be used instead. If \i{type-sub} is
+         not present or its substitution results in an empty string then
+         the custom type is assumed to have the same name and be defined
+         in the same namespace as the generated class would have. If
+         \i{base-sub} is present and its substitution results in a
+         non-empty string then the generated class is still generated
+         but with the result of this substitution as its name. The pattern
+         and substitutions are in the Perl regular expression format.
+         See also the REGEX AND SHELL QUOTING section below."
+      };
+
+      // Parts.
+      //
+      std::size_t --parts = 1
+      {
+        "<num>",
+        "Split generated source code into <num> parts. This is useful when
+         translating large, monolithic schemas and a C++ compiler is not
+         able to compile the resulting source code at once (usually due
+         to insufficient memory)."
+      };
+
+      Cult::Types::NarrowString --parts-suffix = "-"
+      {
+        "<suffix>",
+        "Use <suffix> instead of the default '\cb{-}' to separate the file
+         name from the part number."
+      };
+    };
+  }
+}