aboutsummaryrefslogtreecommitdiff
path: root/xsd/cxx/tree/options.cli
diff options
context:
space:
mode:
Diffstat (limited to 'xsd/cxx/tree/options.cli')
-rw-r--r--xsd/cxx/tree/options.cli415
1 files changed, 415 insertions, 0 deletions
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."
+ };
+ };
+ }
+}