From 5e527213a2430bb3018e5eebd909aef294edf9b5 Mon Sep 17 00:00:00 2001
From: Karen Arutyunov <karen@codesynthesis.com>
Date: Fri, 18 Dec 2020 18:48:46 +0300
Subject: Switch to build2

---
 xsd/cxx/tree/options.cli | 479 -----------------------------------------------
 1 file changed, 479 deletions(-)
 delete mode 100644 xsd/cxx/tree/options.cli

(limited to 'xsd/cxx/tree/options.cli')

diff --git a/xsd/cxx/tree/options.cli b/xsd/cxx/tree/options.cli
deleted file mode 100644
index 08c9be3..0000000
--- a/xsd/cxx/tree/options.cli
+++ /dev/null
@@ -1,479 +0,0 @@
-// file      : xsd/cxx/tree/options.cli
-// license   : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-include <cstddef>; // std::size_t
-
-include <types.hxx>; // NarrowString, NarrowStrings
-
-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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      unsigned long --polymorphic-plate = 0
-      {
-        "<num>",
-        "Specify the polymorphic map plate the generated code should register
-         on. This functionality is primarily useful to segregate multiple
-         schemas that define the same polymorphic types."
-      };
-
-      // Ordered content.
-      //
-      NarrowStrings --ordered-type
-      {
-        "<type>",
-        "Indicate that element order in <type> is significant. An example
-         would be a complex type with unbounded choice as a content model
-         where the element order in XML has application-specific semantics.
-         For ordered types the compiler generates a special container data
-         member and a corresponding set of accessors and modifiers that are
-         used to capture the order of elements and, for mixed content, of
-         text.
-
-         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.
-         Note also that you will need to specify this option when compiling
-         every schema file that has other ordered types derived from this
-         type."
-      };
-
-      bool --ordered-type-derived
-      {
-        "Automatically treat types derived from ordered bases as also
-         ordered. This is primarily useful if you would like to be able
-         to iterate over the complete content using the content order
-         container."
-      };
-
-      bool --ordered-type-mixed
-      {
-        "Automatically treat complex types with mixed content as ordered."
-      };
-
-      bool --ordered-type-all
-      {
-        "Indicate that element order in all types is significant."
-      };
-
-      NarrowString --order-container
-      {
-        "<type>",
-        "Specify a custom class template that should be used as a container
-         for the content order in ordered types instead of the default
-         \cb{std::vector}. See \cb{--ordered-type} for more information on
-         ordered type. This option is primarily useful if you need to
-         perform more complex lookups in the content order container, for
-         example by element id. In this case, a container like Boost
-         multi-index may be more convenient. Note that if using a custom
-         container, you will also most likely need to include the relevant
-         headers using the \cb{--hxx-prologue*} options."
-      };
-
-      // Features.
-      //
-      bool --generate-serialization
-      {
-        "Generate serialization functions. Serialization functions convert
-         the object model back to XML."
-      };
-
-      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."
-      };
-
-      bool --generate-any-type
-      {
-        "Extract and store content of the XML Schema \cb{anyType} type as a
-         DOM fragment. Note that you need to initialize the Xerces-C++ runtime
-         if you are using this option."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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.
-      //
-      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."
-      };
-
-      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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --const-regex
-      {
-        "<regex>",
-        "Add <regex> to the list of regular expressions used to translate
-         XML Schema-derived names to C++ constant names. See the NAMING
-         CONVENTION section below for more information."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --root-element
-      {
-        "<element>",
-        "Treat only <element> as a document root. Repeat this option to
-         specify more than one root element."
-      };
-
-      // Custom type.
-      //
-      NarrowStrings --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."
-      };
-
-      NarrowStrings --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)."
-      };
-
-      NarrowString --parts-suffix = "-"
-      {
-        "<suffix>",
-        "Use <suffix> instead of the default '\cb{-}' to separate the file
-         name from the part number."
-      };
-    };
-  }
-}
-- 
cgit v1.1