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.

13 files changed, 1376 insertions, 3845 deletions

diff --git a/documentation/makefile b/documentation/makefile
index 5b2f0e8..1a72794 100644
--- a/documentation/makefile
+++ b/documentation/makefile
@@ -11,35 +11,148 @@ dist-win := $(out_base)/.dist-win
 install  := $(out_base)/.install
 cleandoc := $(out_base)/.cleandoc
 
-$(default): $(out_base)/cxx/
+# Import.
+#
+$(call import,\
+  $(scf_root)/import/cli/stub.make,\
+  cli: cli,cli-rules: cli_rules)
+
+# Build.
+#
+$(default):            \
+$(out_base)/cxx/       \
+$(out_base)/xsde.xhtml \
+$(out_base)/xsde.1
+
+# Man/html pages.
+#
+$(out_base)/xsde.xhtml $(out_base)/xsde.1: cli := $(cli)
+$(out_base)/xsde.xhtml $(out_base)/xsde.1: cli_options += -I $(src_root)/xsde
+
+$(out_base)/xsde.xhtml $(out_base)/xsde.1:  \
+$(src_root)/xsde/options.cli                \
+$(src_root)/xsde/cxx/options.cli            \
+$(src_root)/xsde/cxx/hybrid/options.cli     \
+$(src_root)/xsde/cxx/parser/options.cli     \
+$(src_root)/xsde/cxx/serializer/options.cli
+
+# Assemble the options from different files in a specific order.
+#
+
+# XHTML
+#
+$(out_base)/xsde.xhtml: $(src_base)/xsde-prologue.xhtml          \
+                        $(src_base)/xsde-epilogue.xhtml          \
+                        $(src_base)/xsde-hybrid-header.xhtml     \
+                        $(src_base)/xsde-parser-header.xhtml     \
+			$(src_base)/xsde-serializer-header.xhtml \
+                        | $(out_base)/.
+# Common options.
+#
+	$(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base --class CXX::options \
+--class options --html-prologue $(src_base)/xsde-prologue.xhtml \
+$$1 >$@, $(src_root)/xsde/cxx/options.cli)
+
+# C++/Hybrid options.
+#
+	$(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base \
+--html-prologue $(src_base)/xsde-hybrid-header.xhtml \
+$$1 >>$@, $(src_root)/xsde/cxx/hybrid/options.cli)
+
+# C++/Parser options.
+#
+	$(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base \
+--html-prologue $(src_base)/xsde-parser-header.xhtml \
+$$1 >>$@, $(src_root)/xsde/cxx/parser/options.cli)
+
+# C++/Serializer options.
+#
+	$(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base \
+--html-prologue $(src_base)/xsde-serializer-header.xhtml \
+--html-epilogue $(src_base)/xsde-epilogue.xhtml \
+$$1 >>$@, $(src_root)/xsde/cxx/serializer/options.cli)
+
+
+# MAN
+#
+$(out_base)/xsde.1: $(src_base)/xsde-prologue.1              \
+                        $(src_base)/xsde-epilogue.1          \
+                        $(src_base)/xsde-hybrid-header.1     \
+                        $(src_base)/xsde-parser-header.1     \
+			$(src_base)/xsde-serializer-header.1 \
+                        | $(out_base)/.
+# Common options.
+#
+	$(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base --class CXX::options \
+--class options --man-prologue $(src_base)/xsde-prologue.1 \
+$$1 >$@, $(src_root)/xsde/cxx/options.cli)
+
+# C++/Hybrid options.
+#
+	$(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base \
+--man-prologue $(src_base)/xsde-hybrid-header.1 \
+$$1 >>$@, $(src_root)/xsde/cxx/hybrid/options.cli)
+
+# C++/Parser options.
+#
+	$(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base \
+--man-prologue $(src_base)/xsde-parser-header.1 \
+$$1 >>$@, $(src_root)/xsde/cxx/parser/options.cli)
+
+# C++/Serializer options.
+#
+	$(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base \
+--man-prologue $(src_base)/xsde-serializer-header.1 \
+--man-epilogue $(src_base)/xsde-epilogue.1 \
+$$1 >>$@, $(src_root)/xsde/cxx/serializer/options.cli)
+
 
 # Dist.
 #
 dist-common := $(out_base)/.dist-common
 
-$(dist-common):
+$(dist-common): $(out_base)/xsde.xhtml \
+                $(out_base)/xsde.1
 	$(call install-data,$(src_base)/default.css,$(dist_prefix)/documentation/default.css)
-	$(call install-data,$(src_base)/xsde.xhtml,$(dist_prefix)/documentation/xsde.xhtml)
-	$(call install-data,$(src_base)/xsde.1,$(dist_prefix)/documentation/xsde.1)
+	$(call install-data,$(out_base)/xsde.xhtml,$(dist_prefix)/documentation/xsde.xhtml)
+	$(call install-data,$(out_base)/xsde.1,$(dist_prefix)/documentation/xsde.1)
 
 $(dist): $(dist-common) $(out_base)/cxx/.dist
 $(dist-win): $(dist-common) $(out_base)/cxx/.dist
 
-
 # Install.
 #
-$(install):
+$(install): $(out_base)/xsde.xhtml \
+            $(out_base)/xsde.1	
 	$(call install-dir,$(src_base)/cxx,$(install_doc_dir)/xsde/cxx)
 	$(call install-data,$(src_base)/default.css,$(install_doc_dir)/xsde/default.css)
-	$(call install-data,$(src_base)/xsde.xhtml,$(install_doc_dir)/xsde/xsde.xhtml)
-	$(call install-data,$(src_base)/xsde.1,$(install_man_dir)/man1/xsde.1)
-
+	$(call install-data,$(out_base)/xsde.xhtml,$(install_doc_dir)/xsde/xsde.xhtml)
+	$(call install-data,$(out_base)/xsde.1,$(install_man_dir)/man1/xsde.1)
 
 # Clean.
 #
 $(cleandoc): $(src_base)/cxx/.cleandoc
+	$(call message,rm $$1,rm -f $$1,$(out_base)/xsde.1)
+	$(call message,rm $$1,rm -f $$1,$(out_base)/xsde.xhtml)
 
+# Generated .gitignore.
+#
+ifeq ($(out_base),$(src_base))
+$(out_base)/xsde.xhtml $(out_base)/xsde.1: | $(out_base)/.gitignore
 
-$(call include,$(bld_root)/install.make)
+$(out_base)/.gitignore: files := xsde.1 xsde.xhtml
+$(clean): $(out_base)/.gitignore.clean
 
+$(call include,$(bld_root)/git/gitignore.make)
+endif
+
+$(call include,$(bld_root)/install.make)
 $(call import,$(src_base)/cxx/makefile)
diff --git a/documentation/xsde-epilogue.1 b/documentation/xsde-epilogue.1
new file mode 100644
index 0000000..3049ab0
--- /dev/null
+++ b/documentation/xsde-epilogue.1
@@ -0,0 +1,540 @@
+.\"
+.\" Type map
+.\"
+.SH TYPE MAP
+
+Type map files are used to define a mapping between XML Schema and
+C++ types. For C++/Parser, the compiler uses this information to
+determine the return types of
+.B post_*
+functions in parser skeletons corresponding to XML Schema types as
+well as argument types for callbacks corresponding to elements and
+attributes of these types. For C++/Serializer, type maps are used
+to determine the argument type of
+.B pre
+functions in serializer skeletons corresponding to XML Schema types
+as well as return types for callbacks corresponding to elements and
+attributes of these types.
+
+The compiler has a set of predefined mapping rules that map the
+built-in XML Schema types to suitable C++ types (discussed in
+the following sub-sections) and all other types to
+.BR void .
+By providing your own type maps you can override these predefined
+rules. The format of the type map file is presented below:
+
+
+.RS
+.B namespace
+.I schema-namespace
+[
+.I cxx-namespace
+]
+.br
+.B {
+.br
+  (
+.B include
+.IB file-name ;
+)*
+.br
+  ([
+.B type
+]
+.I schema-type cxx-ret-type
+[
+.I cxx-arg-type
+.RB ] ;
+)*
+.br
+.B }
+.br
+.RE
+
+Both
+.I schema-namespace
+and
+.I schema-type
+are regex patterns while
+.IR cxx-namespace ,
+.IR cxx-ret-type ,
+and
+.I cxx-arg-type
+are regex pattern substitutions. All names can be optionally enclosed
+in \fR" "\fR, for example, to include white-spaces.
+
+.I schema-namespace
+determines XML Schema namespace. Optional
+.I cxx-namespace
+is prefixed to every C++ type name in this namespace declaration.
+.I cxx-ret-type
+is a C++ type name that is used as a return type for the
+.B post_*
+function in C++/Parser or for element/attribute callbacks in C++/Serializer.
+Optional
+.I cxx-arg-type
+is an argument type for element/attribute callbacks in C++/Parser or for the
+.B pre
+function in C++/Serializer. If
+.I cxx-arg-type
+is not specified, it defaults to
+.I cxx-ret-type
+if
+.I cxx-ret-type
+ends with
+.B *
+or
+.B &
+(that is, it is a pointer or a reference) and
+.B const
+\fIcxx-ret-type\fB&\fR otherwise.
+.I file-name
+is a file name either in the \fR" "\fR or < > format and is added with the
+.B #include
+directive to the generated code.
+
+The \fB#\fR character starts a comment that ends with a new line or end of
+file. To specify a name that contains \fB#\fR enclose it in \fR" "\fR. For
+example:
+
+.RS
+namespace http://www.example.com/xmlns/my my
+.br
+{
+.br
+  include "my.hxx";
+.br
+
+  # Pass apples by value.
+  #
+  apple apple;
+.br
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+.br
+}
+.br
+.RE
+
+In the example above, for the
+.B http://www.example.com/xmlns/my#orange
+XML Schema type, the
+.B my::orange_t*
+C++ type will be used as both return and argument types.
+
+Several namespace declarations can be specified in a single file.
+The namespace declaration can also be completely omitted to map
+types in a schema without a namespace. For instance:
+
+.RS
+include "my.hxx";
+.br
+apple apple;
+.br
+
+namespace http://www.example.com/xmlns/my
+.br
+{
+.br
+  orange "const orange_t*";
+.br
+}
+.br
+.RE
+
+The compiler has a number of predefined mapping rules for the built-in
+XML Schema types that vary depending on the mapping used. They are
+described in the following subsections. The last predefined rule
+for all the mappings maps anything that wasn't mapped by previous rules to
+.BR void :
+
+.RS
+namespace .*
+.br
+{
+.br
+  .* void void;
+.br
+}
+.br
+.RE
+
+When you provide your own type maps with the
+.B --type-map
+option, they are evaluated first. This allows you to selectively override
+predefined rules.
+
+.\"
+.\" Predefined C++/Parser Type Maps
+.\"
+.SS Predefined C++/Parser Type Maps
+
+The C++/Parser mapping provides a number of predefined type map rules
+for the built-in XML Schema types. They can be presented as the
+following map files:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  boolean bool bool;
+.br
+
+  byte "signed char" "signed char";
+.br
+  unsignedByte "unsigned char" "unsigned char";
+.br
+
+  short short short;
+.br
+  unsignedShort "unsigned short" "unsigned short";
+.br
+
+  int int int;
+.br
+  unsignedInt "unsigned int" "unsigned int";
+.br
+
+  long "long long" "long long";
+.br
+  unsignedLong "unsigned long long" "unsigned long long";
+.br
+
+  integer long long;
+.br
+
+  negativeInteger long long;
+.br
+  nonPositiveInteger long long;
+.br
+
+  positiveInteger "unsigned long" "unsigned long";
+.br
+  nonNegativeInteger "unsigned long" "unsigned long";
+.br
+
+  float float float;
+.br
+  double double double;
+.br
+  decimal double double;
+.br
+
+  NMTOKENS xml_schema::string_sequence*;
+.br
+  IDREFS xml_schema::string_sequence*;
+.br
+
+  base64Binary xml_schema::buffer*;
+.br
+  hexBinary xml_schema::buffer*;
+.br
+
+  date xml_schema::date;
+.br
+  dateTime xml_schema::date_time;
+.br
+  duration xml_schema::duration;
+.br
+  gDay xml_schema::gday;
+.br
+  gMonth xml_schema::gmonth;
+.br
+  gMonthDay xml_schema::gmonth_day;
+.br
+  gYear xml_schema::gyear;
+.br
+  gYearMonth xml_schema::gyear_month;
+.br
+  time xml_schema::time;
+.br
+}
+.br
+.RE
+
+If the
+.B --no-stl
+option is not specified, the following mapping is used for the
+string-based XML Schema built-in types:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  include <string>;
+.br
+
+  string std::string;
+.br
+  normalizedString std::string;
+.br
+  token std::string;
+.br
+  Name std::string;
+.br
+  NMTOKEN std::string;
+.br
+  NCName std::string;
+.br
+  ID std::string;
+.br
+  IDREF std::string;
+.br
+  language std::string;
+.br
+  anyURI std::string;
+.br
+
+  QName xml_schema::qname;
+.br
+}
+.br
+.RE
+
+Otherwise, a C string-based mapping is used:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  string char*;
+.br
+  normalizedString char*;
+.br
+  token char*;
+.br
+  Name char*;
+.br
+  NMTOKEN char*;
+.br
+  NCName char*;
+.br
+  ID char*;
+.br
+  IDREF char*;
+.br
+  language char*;
+.br
+  anyURI char*;
+.br
+
+  QName xml_schema::qname*;
+.br
+}
+.br
+.RE
+
+.\"
+.\" Predefined C++/Serializer Type Maps
+.\"
+.SS Predefined C++/Serializer Type Maps
+
+The C++/Serializer mapping provides a number of predefined type map
+rules for the built-in XML Schema types. They can be presented as the
+following map files:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  boolean bool bool;
+.br
+
+  byte "signed char" "signed char";
+.br
+  unsignedByte "unsigned char" "unsigned char";
+.br
+
+  short short short;
+.br
+  unsignedShort "unsigned short" "unsigned short";
+.br
+
+  int int int;
+.br
+  unsignedInt "unsigned int" "unsigned int";
+.br
+
+  long "long long" "long long";
+.br
+  unsignedLong "unsigned long long" "unsigned long long";
+.br
+
+  integer long long;
+.br
+
+  negativeInteger long long;
+.br
+  nonPositiveInteger long long;
+.br
+
+  positiveInteger "unsigned long" "unsigned long";
+.br
+  nonNegativeInteger "unsigned long" "unsigned long";
+.br
+
+  float float float;
+.br
+  double double double;
+.br
+  decimal double double;
+.br
+
+  NMTOKENS "const xml_schema::string_sequence*";
+.br
+  IDREFS "const xml_schema::string_sequence*";
+.br
+
+  base64Binary "const xml_schema::buffer*";
+.br
+  hexBinary "const xml_schema::buffer*";
+.br
+
+  date xml_schema::date;
+.br
+  dateTime xml_schema::date_time;
+.br
+  duration xml_schema::duration;
+.br
+  gDay xml_schema::gday;
+.br
+  gMonth xml_schema::gmonth;
+.br
+  gMonthDay xml_schema::gmonth_day;
+.br
+  gYear xml_schema::gyear;
+.br
+  gYearMonth xml_schema::gyear_month;
+.br
+  time xml_schema::time;
+.br
+}
+.br
+.RE
+
+If the
+.B --no-stl
+option is not specified, the following mapping is used for the
+string-based XML Schema built-in types:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  include <string>;
+.br
+
+  string std::string;
+.br
+  normalizedString std::string;
+.br
+  token std::string;
+.br
+  Name std::string;
+.br
+  NMTOKEN std::string;
+.br
+  NCName std::string;
+.br
+  ID std::string;
+.br
+  IDREF std::string;
+.br
+  language std::string;
+.br
+  anyURI std::string;
+.br
+
+  QName xml_schema::qname;
+.br
+}
+.br
+.RE
+
+Otherwise, a C string-based mapping is used:
+
+.RS
+namespace http://www.w3.org/2001/XMLSchema
+.br
+{
+.br
+  string "const char*";
+.br
+  normalizedString "const char*";
+.br
+  token "const char*";
+.br
+  Name "const char*";
+.br
+  NMTOKEN "const char*";
+.br
+  NCName "const char*";
+.br
+  ID "const char*";
+.br
+  IDREF "const char*";
+.br
+  language "const char*";
+.br
+  anyURI "const char*";
+.br
+
+  QName "const xml_schema::qname*";
+.br
+}
+.br
+.RE
+
+.\"
+.\" REGEX AND SHELL QUOTING
+.\"
+.SH REGEX AND SHELL QUOTING
+When entering a regular expression argument in the shell command line
+it is often necessary to use quoting (enclosing the argument in " "
+or ' ') in order to prevent the shell from interpreting certain
+characters, for example, spaces as argument separators and $ as
+variable expansions.
+
+Unfortunately it is hard to achieve this in a manner that is portable
+across POSIX shells, such as those found on GNU/Linux and UNIX, and
+Windows shell. For example, if you use " " for quoting you will get
+a wrong result with POSIX shells if your expression contains $. The
+standard way of dealing with this on POSIX systems is to use ' '
+instead. Unfortunately, Windows shell does not remove ' '  from
+arguments when they are passed to applications. As a result you may
+have to use ' ' for POSIX and " " for Windows ($ is not treated as
+a special character on Windows).
+
+Alternatively, you can save regular expression options into a file,
+one option per line, and use this file with the
+.B --options-file
+option. With this approach you don't need to worry about shell quoting.
+
+.\"
+.\" DIAGNOSTICS
+.\"
+.SH DIAGNOSTICS
+If the input file is not a valid W3C XML Schema definition,
+.B xsde
+will issue diagnostic messages to
+.B STDERR
+and exit with non-zero exit code.
+
+.SH BUGS
+Send bug reports to the xsde-users@codesynthesis.com mailing list.
+
+.SH COPYRIGHT
+Copyright (c) 2005-2011 Code Synthesis Tools CC.
+
+Permission is granted to copy, distribute and/or modify this
+document under the terms of the GNU Free Documentation License,
+version 1.2; with no Invariant Sections, no Front-Cover Texts and
+no Back-Cover Texts. Copy of the license can be obtained from
+http://codesynthesis.com/licenses/fdl-1.2.txt
diff --git a/documentation/xsde-epilogue.xhtml b/documentation/xsde-epilogue.xhtml
new file mode 100644
index 0000000..93701c0
--- /dev/null
+++ b/documentation/xsde-epilogue.xhtml
@@ -0,0 +1,365 @@
+  <h1>TYPE MAP</h1>
+
+  <p>Type map files are used to define a mapping between XML Schema
+     and C++ types. For C++/Parser, the compiler uses
+     this information to determine the return types of
+     <code><b>post_*</b></code> functions in parser skeletons
+     corresponding to XML Schema types as well as argument types
+     for callbacks corresponding to elements and attributes of these
+     types. For C++/Serializer, type maps are used to determine
+     the argument type of <code><b>pre</b></code> functions in
+     serializer skeletons corresponding to XML Schema types as
+     well as return types for callbacks corresponding to elements
+     and attributes of these types.</p>
+
+  <p>The compiler has a set of predefined mapping rules that map
+     the built-in XML Schema types to suitable C++ types (discussed
+     in the following sub-sections) and all other types to
+     <code><b>void</b></code>. By providing your own type maps you
+     can override these predefined rules. The format of the type map
+     file is presented below:
+  </p>
+
+  <pre>
+namespace &lt;schema-namespace> [&lt;cxx-namespace>]
+{
+  (include &lt;file-name>;)*
+  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
+}
+  </pre>
+
+  <p>Both <code><i>&lt;schema-namespace></i></code> and
+     <code><i>&lt;schema-type></i></code> are regex patterns while
+     <code><i>&lt;cxx-namespace></i></code>,
+     <code><i>&lt;cxx-ret-type></i></code>, and
+     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
+     substitutions. All names can be optionally enclosed in
+     <code><b>"&nbsp;"</b></code>, for example, to include white-spaces.</p>
+
+  <p><code><i>&lt;schema-namespace></i></code> determines XML
+     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
+     is prefixed to every C++ type name in this namespace declaration.
+     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
+     used as a return type for the <code><b>post_*</b></code> function
+     in C++/Parser or for element/attribute callbacks in C++/Serializer.
+     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument type
+     for element/attribute callbacks in C++/Parser or for the
+     <code><b>pre</b></code> function in C++/Serializer. If
+     <code><i>&lt;cxx-arg-type></i></code> is not specified, it defaults
+     to <code><i>&lt;cxx-ret-type></i></code> if <code><i>&lt;cxx-ret-type></i></code>
+     ends with <code><b>*</b></code> or <code><b>&amp;</b></code> (that is,
+     it is a pointer or a reference) and
+     <code><b>const</b>&nbsp;<i>&lt;cxx-ret-type></i><b>&amp;</b></code>
+     otherwise.
+     <code><i>&lt;file-name></i></code> is a file name either in the
+     <code><b>"&nbsp;"</b></code> or <code><b>&lt;&nbsp;></b></code> format
+     and is added with the <code><b>#include</b></code> directive to
+     the generated code.</p>
+
+  <p>The <code><b>#</b></code> character starts a comment that ends
+     with a new line or end of file. To specify a name that contains
+     <code><b>#</b></code> enclose it in <code><b>"&nbsp;"</b></code>.
+     For example:</p>
+
+  <pre>
+namespace http://www.example.com/xmlns/my my
+{
+  include "my.hxx";
+
+  # Pass apples by value.
+  #
+  apple apple;
+
+  # Pass oranges as pointers.
+  #
+  orange orange_t*;
+}
+  </pre>
+
+  <p>In the example above, for the
+     <code><b>http://www.example.com/xmlns/my#orange</b></code>
+     XML Schema type, the <code><b>my::orange_t*</b></code> C++ type will
+     be used as both return and argument types.</p>
+
+  <p>Several namespace declarations can be specified in a single
+     file. The namespace declaration can also be completely
+     omitted to map types in a schema without a namespace. For
+     instance:</p>
+
+  <pre>
+include "my.hxx";
+apple apple;
+
+namespace http://www.example.com/xmlns/my
+{
+  orange "const orange_t*";
+}
+  </pre>
+
+  <p>The compiler has a number of predefined mapping rules
+     for the built-in XML Schema types that vary depending on
+     the mapping used. They are described in the following
+     subsections. The last predefined rule for all the mappings
+     maps anything that wasn't mapped by previous rules to
+     <code><b>void</b></code>:</p>
+
+  <pre>
+namespace .*
+{
+  .* void void;
+}
+  </pre>
+
+  <p>When you provide your own type maps with the
+     <code><b>--type-map</b></code> option, they are evaluated first.
+     This allows you to selectively override predefined rules.</p>
+
+
+  <h2>Predefined C++/Parser Type Maps</h2>
+
+  <p>The C++/Parser mapping provides a number of predefined type
+     map rules for the built-in XML Schema types. They can be
+     presented as the following map files:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer long long;
+
+  negativeInteger long long;
+  nonPositiveInteger long long;
+
+  positiveInteger "unsigned long" "unsigned long";
+  nonNegativeInteger "unsigned long" "unsigned long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  NMTOKENS xml_schema::string_sequence*;
+  IDREFS xml_schema::string_sequence*;
+
+  base64Binary xml_schema::buffer*;
+  hexBinary xml_schema::buffer*;
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+  </pre>
+
+  <p>If the <code><b>--no-stl</b></code> option is not specified,
+     the following mapping is used for the string-based XML Schema
+     built-in types:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  include &lt;string>;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  QName xml_schema::qname;
+}
+  </pre>
+
+  <p>Otherwise, a C string-based mapping is used:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  string char*;
+  normalizedString char*;
+  token char*;
+  Name char*;
+  NMTOKEN char*;
+  NCName char*;
+  ID char*;
+  IDREF char*;
+  language char*;
+  anyURI char*;
+
+  QName xml_schema::qname*;
+}
+  </pre>
+
+  <h2>Predefined C++/Serializer Type Maps</h2>
+
+  <p>The C++/Serializer mapping provides a number of predefined type
+     map rules for the built-in XML Schema types. They can be
+     presented as the following map files:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  boolean bool bool;
+
+  byte "signed char" "signed char";
+  unsignedByte "unsigned char" "unsigned char";
+
+  short short short;
+  unsignedShort "unsigned short" "unsigned short";
+
+  int int int;
+  unsignedInt "unsigned int" "unsigned int";
+
+  long "long long" "long long";
+  unsignedLong "unsigned long long" "unsigned long long";
+
+  integer long long;
+
+  negativeInteger long long;
+  nonPositiveInteger long long;
+
+  positiveInteger "unsigned long" "unsigned long";
+  nonNegativeInteger "unsigned long" "unsigned long";
+
+  float float float;
+  double double double;
+  decimal double double;
+
+  NMTOKENS "const xml_schema::string_sequence*";
+  IDREFS "const xml_schema::string_sequence*";
+
+  base64Binary "const xml_schema::buffer*";
+  hexBinary "const xml_schema::buffer*";
+
+  date xml_schema::date;
+  dateTime xml_schema::date_time;
+  duration xml_schema::duration;
+  gDay xml_schema::gday;
+  gMonth xml_schema::gmonth;
+  gMonthDay xml_schema::gmonth_day;
+  gYear xml_schema::gyear;
+  gYearMonth xml_schema::gyear_month;
+  time xml_schema::time;
+}
+  </pre>
+
+  <p>If the <code><b>--no-stl</b></code> option is not specified,
+     the following mapping is used for the string-based XML Schema
+     built-in types:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  include &lt;string>;
+
+  string std::string;
+  normalizedString std::string;
+  token std::string;
+  Name std::string;
+  NMTOKEN std::string;
+  NCName std::string;
+  ID std::string;
+  IDREF std::string;
+  language std::string;
+  anyURI std::string;
+
+  QName xml_schema::qname;
+}
+  </pre>
+
+  <p>Otherwise, a C string-based mapping is used:</p>
+
+  <pre>
+namespace http://www.w3.org/2001/XMLSchema
+{
+  string "const char*";
+  normalizedString "const char*";
+  token "const char*";
+  Name "const char*";
+  NMTOKEN "const char*";
+  NCName "const char*";
+  ID "const char*";
+  IDREF "const char*";
+  language "const char*";
+  anyURI "const char*";
+
+  QName "const xml_schema::qname*";
+}
+  </pre>
+
+  <h1>REGEX AND SHELL QUOTING</h1>
+
+  <p>When entering a regular expression argument in the shell
+     command line it is often necessary to use quoting (enclosing
+     the argument in <code><b>"&nbsp;"</b></code> or
+     <code><b>'&nbsp;'</b></code>) in order to prevent the shell
+     from interpreting certain characters, for example, spaces as
+     argument separators and <code><b>$</b></code> as variable
+     expansions.</p>
+
+  <p>Unfortunately it is hard to achieve this in a manner that is
+     portable across POSIX shells, such as those found on
+     GNU/Linux and UNIX, and Windows shell. For example, if you
+     use <code><b>"&nbsp;"</b></code> for quoting you will get a
+     wrong result with POSIX shells if your expression contains
+     <code><b>$</b></code>. The standard way of dealing with this
+     on POSIX systems is to use <code><b>'&nbsp;'</b></code> instead.
+     Unfortunately, Windows shell does not remove <code><b>'&nbsp;'</b></code>
+     from arguments when they are passed to applications. As a result you
+     may have to use <code><b>'&nbsp;'</b></code> for POSIX and
+     <code><b>"&nbsp;"</b></code> for Windows (<code><b>$</b></code> is
+     not treated as a special character on Windows).</p>
+
+  <p>Alternatively, you can save regular expression options into
+     a file, one option per line, and use this file with the
+     <code><b>--options-file</b></code> option. With this approach
+     you don't need to worry about shell quoting.</p>
+
+  <h1>DIAGNOSTICS</h1>
+
+  <p>If the input file is not a valid W3C XML Schema definition,
+    <code><b>xsde</b></code> will issue diagnostic messages to STDERR
+    and exit with non-zero exit code.</p>
+
+  <h1>BUGS</h1>
+
+  <p>Send bug reports to the
+     <a href="mailto:xsde-users@codesynthesis.com">xsde-users@codesynthesis.com</a> mailing list.</p>
+
+  </div>
+  <div id="footer">
+    &copy;2005-2011 <a href="http://codesynthesis.com">CODE SYNTHESIS TOOLS CC</a>
+
+    <div id="terms">
+      Permission is granted to copy, distribute and/or modify this
+      document under the terms of the
+      <a href="http://codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
+      Documentation License, version 1.2</a>; with no Invariant Sections,
+      no Front-Cover Texts and no Back-Cover Texts.
+    </div>
+  </div>
+</div>
+</body>
+</html>
diff --git a/documentation/xsde-hybrid-header.1 b/documentation/xsde-hybrid-header.1
new file mode 100644
index 0000000..2853956
--- /dev/null
+++ b/documentation/xsde-hybrid-header.1
@@ -0,0 +1,4 @@
+.\"
+.\" C++/Hybrid options.
+.\"
+.SS cxx-hybrid command options
diff --git a/documentation/xsde-hybrid-header.xhtml b/documentation/xsde-hybrid-header.xhtml
new file mode 100644
index 0000000..b208c2a
--- /dev/null
+++ b/documentation/xsde-hybrid-header.xhtml
@@ -0,0 +1 @@
+  <h2>CXX-HYBRID COMMAND OPTIONS</h2>
diff --git a/documentation/xsde-parser-header.1 b/documentation/xsde-parser-header.1
new file mode 100644
index 0000000..b9785f1
--- /dev/null
+++ b/documentation/xsde-parser-header.1
@@ -0,0 +1,4 @@
+.\"
+.\" C++/Parser options.
+.\"
+.SS cxx-parser command options
diff --git a/documentation/xsde-parser-header.xhtml b/documentation/xsde-parser-header.xhtml
new file mode 100644
index 0000000..94fa2c1
--- /dev/null
+++ b/documentation/xsde-parser-header.xhtml
@@ -0,0 +1 @@
+  <h2>CXX-PARSER COMMAND OPTIONS</h2>
diff --git a/documentation/xsde-prologue.1 b/documentation/xsde-prologue.1
new file mode 100644
index 0000000..e03f9e5
--- /dev/null
+++ b/documentation/xsde-prologue.1
@@ -0,0 +1,171 @@
+.\" Process this file with
+.\" groff -man -Tascii xsde.1
+.\"
+.TH XSD/e 1 "September 2011" "XSD/e 3.3.0"
+.SH NAME
+xsde \- W3C XML Schema to C++ Compiler for Embedded Systems
+.\"
+.\"
+.\"
+.\"--------------------------------------------------------------------
+.SH SYNOPSIS
+.\"--------------------------------------------------------------------
+.B xsde
+.I command
+.B [
+.I options
+.B ]
+.I file
+.B [
+.I file
+.B ...]
+.in
+.B xsde help
+.B [
+.I command
+.B ]
+.in
+.B xsde version
+.\"
+.\"
+.\"
+.\"--------------------------------------------------------------------
+.SH DESCRIPTION
+.\"--------------------------------------------------------------------
+.B xsde
+generates vocabulary-specific, statically-typed C++ mapping from W3C XML
+Schema definitions. Particular mapping to produce is selected by a
+.IR command .
+Each mapping has a number of mapping-specific
+.I options
+that should appear, if any, after the
+.IR command .
+Input files should be W3C XML Schema definitions. The exact set of the
+generated files depends on the selected mapping and options.
+.\"
+.\"
+.\"
+.\"--------------------------------------------------------------------
+.SH COMMANDS
+.\"--------------------------------------------------------------------
+.IP \fBcxx-hybrid\fR
+Generate the Embedded C++/Hybrid mapping. For each input file in the
+form
+.B name.xsd
+the following C++ files are generated:
+.B name.hxx
+(object model header file),
+.B name.ixx
+(object model inline file, generated only if the
+.B --generate-inline
+option is specified),
+.B name.cxx
+(object model source file), and
+.B name-fwd.hxx
+(object model forward declaration file, generated only if the
+.B --generate-forward
+option is specified).
+
+If the
+.B --generate-parser
+option is specified, the Embedded C++/Parser mapping is invoked and the
+.BR name-pskel.hxx ,
+.BR name-pskel.ixx ,
+and
+.B name-pskel.cxx
+parser skeleton files are generated, as described below. Additionally,
+the following parser implementation files are generated:
+.B name-pimpl.hxx
+(parser implementation header file) and
+.B name-pimpl.cxx
+(parser implementation source file).
+
+If the
+.B --generate-serializer
+option is specified, the Embedded C++/Serializer mapping is invoked and the
+.BR name-sskel.hxx ,
+.BR name-sskel.ixx ,
+and
+.B name-sskel.cxx
+serializer skeleton files are generated, as described below. Additionally,
+the following serializer implementation files are generated:
+.B name-simpl.hxx
+(serializer implementation header file) and
+.B name-simpl.cxx
+(serializer implementation source file).
+
+.IP \fBcxx-parser\fR
+Generate the Embedded C++/Parser mapping. For each input file in the form
+.B name.xsd
+the following C++ files are generated:
+.B name-pskel.hxx
+(parser skeleton header file),
+.B name-pskel.ixx
+(parser skeleton inline file, generated only if the
+.B --generate-inline
+option is specified), and
+.B name-pskel.cxx
+(parser skeleton source file). If the
+.B --generate-noop-impl
+or
+.B --generate-print-impl
+option is specified, the following additional sample implementation files
+are generated:
+.B name-pimpl.hxx
+(parser implementation header file) and
+.B name-pimpl.cxx
+(parser implementation source file). If the
+.B --generate-test-driver
+option is specified, the additional
+.B name-pdriver.cxx
+test driver file is generated.
+
+.IP \fBcxx-parser\fR
+Generate the Embedded C++/Serializer mapping. For each input file in the form
+.B name.xsd
+the following C++ files are generated:
+.B name-sskel.hxx
+(serializer skeleton header file),
+.B name-sskel.ixx
+(serializer skeleton inline file, generated only if the
+.B --generate-inline
+option is specified), and
+.B name-sskel.cxx
+(serializer skeleton source file). If the
+.B --generate-empty-impl
+option is specified, the following additional sample implementation files
+are generated:
+.B name-simpl.hxx
+(serializer implementation header file) and
+.B name-simpl.cxx
+(serializer implementation source file). If the
+.B --generate-test-driver
+option is specified, the additional
+.B name-sdriver.cxx
+test driver file is generated.
+
+.IP \fBhelp\fR
+Print usage information and exit. Use
+.PP
+.RS
+.RS 3
+.B xsde help
+.I command
+.RE
+.PP
+for command-specific help.
+.RE
+.IP \fBversion\fR
+Print version and exit.
+.\"--------------------------------------------------------------------
+.SH OPTIONS
+.\"--------------------------------------------------------------------
+Command-specific
+.IR options ,
+if any, should appear after the corresponding
+.IR command .
+
+.\"
+.\" Common options.
+.\"
+.SS common options
diff --git a/documentation/xsde-prologue.xhtml b/documentation/xsde-prologue.xhtml
new file mode 100644
index 0000000..c88f65b
--- /dev/null
+++ b/documentation/xsde-prologue.xhtml
@@ -0,0 +1,162 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+
+<head>
+  <title>XSD/e 3.3.0 Compiler Command Line Manual</title>
+
+  <meta name="copyright" content="&copy; 2005-2011 Code Synthesis Tools CC"/>
+  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,code,generator,manual,man,page"/>
+  <meta name="description" content="XSD/e Compiler Command Line Manual"/>
+
+  <link rel="stylesheet" type="text/css" href="default.css" />
+
+<style type="text/css">
+
+  #synopsis {
+    list-style-type:  none;
+  }
+
+  #synopsis li {
+    padding-top      : 0.0em;
+    padding-bottom   : 0.0em;
+  }
+
+  #commands dt {
+    padding-top      : 0.4em;
+  }
+
+  #commands dd {
+    padding-bottom   : 0.4em;
+    padding-left     : 2em;
+  }
+
+  .options dt {
+    padding-top      : 0.4em;
+  }
+
+  .options dd {
+    padding-top      : 0.1em;
+    padding-bottom   : 0.4em;
+    padding-left     : 1.4em;
+  }
+
+</style>
+</head>
+
+<body>
+<div id="container">
+  <div id="content">
+
+  <h1>NAME</h1>
+
+  <p>xsde - W3C XML Schema to C++ Compiler for Embedded Systems</p>
+
+  <h1>SYNOPSIS</h1>
+
+  <dl id="synopsis">
+    <dt><code><b>xsde</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
+    <dt><code><b>xsde help</b> [<i>command</i>]</code></dt>
+    <dt><code><b>xsde version</b></code></dt>
+  </dl>
+
+  <h1>DESCRIPTION</h1>
+
+  <p><code><b>xsde</b></code> generates vocabulary-specific, statically-typed
+  C++ mapping from W3C XML Schema definitions. Particular mapping to
+  produce is selected by a <code><i>command</i></code>. Each mapping has
+  a number of mapping-specific <code><i>options</i></code> that should
+  appear, if any, after the <code><i>command</i></code>. Input files should
+  be W3C XML Schema definitions. The exact set of the generated files
+  depends on the selected mapping and options.</p>
+
+  <h1>COMMANDS</h1>
+
+  <dl id="commands">
+    <dt><code><b>cxx-hybrid</b></code></dt>
+    <dd>Generate the Embedded C++/Hybrid mapping. For each input file in the
+        form <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name.hxx</b></code> (object model header file),
+        <code><b>name.ixx</b></code> (object model inline file, generated only
+          if the <code><b>--generate-inline</b></code> option is specified),
+	<code><b>name.cxx</b></code> (object model source file), and
+        <code><b>name-fwd.hxx</b></code> (object model forward declaration
+          file, generated only if the <code><b>--generate-forward</b></code>
+          option is specified).
+
+        <p>If the <code><b>--generate-parser</b></code> option is specified,
+        the Embedded C++/Parser mapping is invoked and the
+        <code><b>name-pskel.hxx</b></code>,
+        <code><b>name-pskel.ixx</b></code>, and
+	<code><b>name-pskel.cxx</b></code> parser skeleton files are
+        generated, as described below. Additionally, the following parser
+        implementation files are generated:
+        <code><b>name-pimpl.hxx</b></code> (parser implementation header
+        file) and
+        <code><b>name-pimpl.cxx</b></code> (parser implementation source
+        file).</p>
+
+        <p>If the <code><b>--generate-serializer</b></code> option is
+        specified, the Embedded C++/Serializer mapping is invoked and the
+        <code><b>name-sskel.hxx</b></code>,
+        <code><b>name-sskel.ixx</b></code>, and
+	<code><b>name-sskel.cxx</b></code> serializer skeleton files are
+        generated, as described below. Additionally, the following serializer
+        implementation files are generated:
+        <code><b>name-simpl.hxx</b></code> (serializer implementation header
+        file) and
+        <code><b>name-simpl.cxx</b></code> (serializer implementation source
+        file).</p>
+    </dd>
+
+    <dt><code><b>cxx-parser</b></code></dt>
+    <dd>Generate the Embedded C++/Parser mapping. For each input file in the
+        form <code><b>name.xsd</b></code> the following C++ files are generated:
+        <code><b>name-pskel.hxx</b></code> (parser skeleton header file),
+        <code><b>name-pskel.ixx</b></code> (parser skeleton inline file,
+          generated only if the <code><b>--generate-inline</b></code>
+          option is specified), and
+	<code><b>name-pskel.cxx</b></code> (parser skeleton source file).
+        If the <code><b>--generate-noop-impl</b></code> or
+        <code><b>--generate-print-impl</b></code> option is specified,
+        the following additional sample implementation files are generated:
+        <code><b>name-pimpl.hxx</b></code> (parser implementation header
+        file) and
+        <code><b>name-pimpl.cxx</b></code> (parser implementation source
+        file). If the <code><b>--generate-test-driver</b></code> option
+        is specified, the additional <code><b>name-pdriver.cxx</b></code>
+        test driver file is generated.</dd>
+
+    <dt><code><b>cxx-serializer</b></code></dt>
+    <dd>Generate the Embedded C++/Serializer mapping. For each input file
+        in the form <code><b>name.xsd</b></code> the following C++ files
+        are generated: <code><b>name-sskel.hxx</b></code> (serializer
+        skeleton header file), <code><b>name-sskel.ixx</b></code> (serializer
+        skeleton inline file, generated only if the
+        <code><b>--generate-inline</b></code> option is specified), and
+	<code><b>name-sskel.cxx</b></code> (serializer skeleton source file).
+        If the <code><b>--generate-empty-impl</b></code> option is specified,
+        the following additional sample implementation files are generated:
+        <code><b>name-simpl.hxx</b></code> (serializer implementation header
+        file) and <code><b>name-simpl.cxx</b></code> (serializer
+        implementation source file). If the <code><b>--generate-test-driver</b></code>
+        option is specified, the additional <code><b>name-sdriver.cxx</b></code>
+        test driver file is generated.
+    </dd>
+
+    <dt><code><b>help</b></code></dt>
+    <dd>Print usage information and exit. Use
+      <p><code><b>xsde help</b> <i>command</i></code></p>
+      for command-specific help.
+    </dd>
+
+    <dt><code><b>version</b></code></dt>
+    <dd>Print version and exit.</dd>
+  </dl>
+
+  <h1>OPTIONS</h1>
+
+  <p>Command-specific <code><i>options</i></code>, if any, should appear
+  after the corresponding <code><i>command</i></code>.</p>
+
+  <h2>COMMON OPTIONS</h2>
diff --git a/documentation/xsde-serializer-header.1 b/documentation/xsde-serializer-header.1
new file mode 100644
index 0000000..e977500
--- /dev/null
+++ b/documentation/xsde-serializer-header.1
@@ -0,0 +1,4 @@
+.\"
+.\" C++/Serializer options.
+.\"
+.SS cxx-serializer command options
diff --git a/documentation/xsde-serializer-header.xhtml b/documentation/xsde-serializer-header.xhtml
new file mode 100644
index 0000000..78988bd
--- /dev/null
+++ b/documentation/xsde-serializer-header.xhtml
@@ -0,0 +1 @@
+  <h2>CXX-SERIALIZER COMMAND OPTIONS</h2>
diff --git a/documentation/xsde.1 b/documentation/xsde.1
deleted file mode 100644
index eee915e..0000000
--- a/documentation/xsde.1
+++ /dev/null
@@ -1,2110 +0,0 @@
-.\" Process this file with
-.\" groff -man -Tascii xsde.1
-.\"
-.TH XSD/e 1 "September 2011" "XSD/e 3.3.0"
-.SH NAME
-xsde \- W3C XML Schema to C++ Compiler for Embedded Systems
-.\"
-.\"
-.\"
-.\"--------------------------------------------------------------------
-.SH SYNOPSIS
-.\"--------------------------------------------------------------------
-.B xsde
-.I command
-.B [
-.I options
-.B ]
-.I file
-.B [
-.I file
-.B ...]
-.in
-.B xsde help
-.B [
-.I command
-.B ]
-.in
-.B xsde version
-.\"
-.\"
-.\"
-.\"--------------------------------------------------------------------
-.SH DESCRIPTION
-.\"--------------------------------------------------------------------
-.B xsde
-generates vocabulary-specific, statically-typed C++ mapping from W3C XML
-Schema definitions. Particular mapping to produce is selected by a
-.IR command .
-Each mapping has a number of mapping-specific
-.I options
-that should appear, if any, after the
-.IR command .
-Input files should be W3C XML Schema definitions. The exact set of the
-generated files depends on the selected mapping and options.
-.\"
-.\"
-.\"
-.\"--------------------------------------------------------------------
-.SH COMMANDS
-.\"--------------------------------------------------------------------
-.IP \fBcxx-hybrid\fR
-Generate the Embedded C++/Hybrid mapping. For each input file in the
-form
-.B name.xsd
-the following C++ files are generated:
-.B name.hxx
-(object model header file),
-.B name.ixx
-(object model inline file, generated only if the
-.B --generate-inline
-option is specified),
-.B name.cxx
-(object model source file), and
-.B name-fwd.hxx
-(object model forward declaration file, generated only if the
-.B --generate-forward
-option is specified).
-
-If the
-.B --generate-parser
-option is specified, the Embedded C++/Parser mapping is invoked and the
-.BR name-pskel.hxx ,
-.BR name-pskel.ixx ,
-and
-.B name-pskel.cxx
-parser skeleton files are generated, as described below. Additionally,
-the following parser implementation files are generated:
-.B name-pimpl.hxx
-(parser implementation header file) and
-.B name-pimpl.cxx
-(parser implementation source file).
-
-If the
-.B --generate-serializer
-option is specified, the Embedded C++/Serializer mapping is invoked and the
-.BR name-sskel.hxx ,
-.BR name-sskel.ixx ,
-and
-.B name-sskel.cxx
-serializer skeleton files are generated, as described below. Additionally,
-the following serializer implementation files are generated:
-.B name-simpl.hxx
-(serializer implementation header file) and
-.B name-simpl.cxx
-(serializer implementation source file).
-
-.IP \fBcxx-parser\fR
-Generate the Embedded C++/Parser mapping. For each input file in the form
-.B name.xsd
-the following C++ files are generated:
-.B name-pskel.hxx
-(parser skeleton header file),
-.B name-pskel.ixx
-(parser skeleton inline file, generated only if the
-.B --generate-inline
-option is specified), and
-.B name-pskel.cxx
-(parser skeleton source file). If the
-.B --generate-noop-impl
-or
-.B --generate-print-impl
-option is specified, the following additional sample implementation files
-are generated:
-.B name-pimpl.hxx
-(parser implementation header file) and
-.B name-pimpl.cxx
-(parser implementation source file). If the
-.B --generate-test-driver
-option is specified, the additional
-.B name-pdriver.cxx
-test driver file is generated.
-
-.IP \fBcxx-parser\fR
-Generate the Embedded C++/Serializer mapping. For each input file in the form
-.B name.xsd
-the following C++ files are generated:
-.B name-sskel.hxx
-(serializer skeleton header file),
-.B name-sskel.ixx
-(serializer skeleton inline file, generated only if the
-.B --generate-inline
-option is specified), and
-.B name-sskel.cxx
-(serializer skeleton source file). If the
-.B --generate-empty-impl
-option is specified, the following additional sample implementation files
-are generated:
-.B name-simpl.hxx
-(serializer implementation header file) and
-.B name-simpl.cxx
-(serializer implementation source file). If the
-.B --generate-test-driver
-option is specified, the additional
-.B name-sdriver.cxx
-test driver file is generated.
-
-.IP \fBhelp\fR
-Print usage information and exit. Use
-.PP
-.RS
-.RS 3
-.B xsde help
-.I command
-.RE
-.PP
-for command-specific help.
-.RE
-.IP \fBversion\fR
-Print version and exit.
-.\"--------------------------------------------------------------------
-.SH OPTIONS
-.\"--------------------------------------------------------------------
-Command-specific
-.IR options ,
-if any, should appear after the corresponding
-.IR command .
-
-.\"
-.\" Common options
-.\"
-.SS common options
-
-.IP "\fB\--output-dir \fIdir\fR"
-Write generated files to
-.I dir
-instead of the current directory.
-
-.IP "\fB\--char-encoding \fIenc\fR"
-Specify the application character encoding. Valid values are
-.B utf8
-(default) and
-.BR iso8859-1 .
-Note that this encoding is not the same as the XML document encoding
-that is being parsed or serialized. Rather, it is the encoding that
-is used inside the application. When an XML document is parsed, the
-character data is automatically converted to the application encoding.
-Similarly, when an XML document is serialized, the data in the
-application encoding is automatically converted to the resulting
-document encoding.
-
-.IP "\fB\--no-stl\fR"
-Generate code that does not use the Standard Template Library (STL).
-
-.IP "\fB\--no-iostream\fR"
-Generate code that does not use the standard input/output stream
-library (iostream).
-
-.IP "\fB\--no-exceptions\fR"
-Generate code that does not use C++ exceptions.
-
-.IP "\fB\--no-long-long\fR"
-Generate code that does not use the
-.B long long
-and
-.B unsigned long long
-types. The 64 bit
-.B long
-and
-.B unsignedLong
-built-in XML Schema types are then mapped to
-.B long
-and
-.B unsigned
-.BR long .
-
-.IP "\fB\--custom-allocator\fR"
-Generate code that performs memory management using custom allocator
-functions provided by your application instead of the standard operator
-new/delete.
-
-.IP "\fB\--generate-inline\fR"
-Generate simple functions inline. This option triggers creation of the
-inline file.
-
-.IP "\fB\--namespace-map \fIxns\fB=\fIcns"
-Map XML Schema namespace
-.I xns
-to C++ namespace
-.IR cns .
-Repeat this option to specify mapping for more than one XML Schema namespace.
-For example, the following option:
-
-.B --namespace-map http://example.com/foo/bar=foo::bar
-
-will map the
-.B http://example.com/foo/bar
-XML Schema namespace to the
-.B foo::bar
-C++ namespace.
-.
-.IP "\fB\--namespace-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema namespace
-names to C++ namespace names.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported.
-
-All the regular expressions are pushed into a stack with the last specified
-expression considered first. The first match that succeeds is used. Regular
-expressions are applied to a string in the form
-
-.I filename namespace
-
-For example, if you have file
-.B hello.xsd
-with namespace
-.B http://example.com/hello
-and you run
-.B xsd
-on this file, then the string in question will be:
-
-.B hello.xsd. http://example.com/hello
-
-For the built-in XML Schema namespace the string is:
-
-.B XMLSchema.xsd http://www.w3.org/2001/XMLSchema
-
-The following three steps are performed for each regular expression until
-the match is found:
-.RS
-.RS 3
-.TP 3
-1.
-The expression is applied and if the result is empty the next expression
-is considered.
-.TP 3
-2.
-All
-.B /
-are replaced with
-.BR :: .
-.TP 3
-3.
-The result is verified to be a valid C++ scope name (e.g.,
-.BR foo::bar ).
-If this test succeeds, the result is used as a C++ namespace name.
-.RE
-.PP
-As an example, the following expression maps XML Schema namespaces in the
-form
-.B http://example.com/foo/bar
-to C++ namespaces in the form
-.BR foo::bar :
-.PP
-.B "%.* http://example.com/(.+)%$1%"
-
-See also the REGEX AND SHELL QUOTING section below.
-.RE
-
-.IP "\fB\--namespace-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --namespace-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-\"
-\" Reserved names.
-\"
-
-.IP "\fB\--reserved-name \fIname\fR[\fB=\fIrep\fR]"
-Add
-.I name
-to the list of names that should not be used as identifiers. The name
-can optionally be followed by
-.B =
-and the replacement name that should be used instead. All the C++ keywords
-are already in this list.
-
-.IP "\fB\--include-with-brackets\fR"
-Use angle brackets (<>) instead of quotes ("") in generated
-.B #include
-directives.
-
-.IP "\fB\--include-prefix \fIprefix\fR"
-Add
-.I prefix
-to generated
-.B #include
-directive paths.
-
-For example, if you had the following import element in your schema
-
-.B <import namespace="..." schemaLocation="base.xsd"/>
-
-and compiled this fragment with
-.B --include-prefix schemas/\fR,
-then the include directive in the generated code would be:
-
-.B #include "schemas/base.hxx"
-
-.IP "\fB\--include-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to transform
-.B #include
-directive paths.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported.
-
-All the regular expressions are pushed into a stack with the last specified
-expression considered first. The first match that succeeds is used.
-
-As an example, the following expression transforms paths in the form
-.B schemas/foo/bar
-to paths in the form
-.BR generated/foo/bar :
-
-.B "%schemas/(.+)%generated/$1%"
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--include-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --include-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-.IP "\fB\--guard-prefix \fIprefix\fR"
-Add
-.I prefix
-to generated header inclusion guards. The prefix is transformed to upper
-case and characters that are illegal in a preprocessor macro name are
-replaced with underscores. If this option is not specified then the
-directory part of the input schema file is used as a prefix.
-
-.IP "\fB\--hxx-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B .hxx
-to construct the name of the header file. Note that this suffix is also
-used to construct names for included/imported schemas.
-.IP "\fB\--ixx-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B .ixx
-to construct the name of the inline file.
-.IP "\fB\--cxx-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B .cxx
-to construct the name of the source file.
-.IP "\fB\--fwd-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B -fwd.hxx
-to construct the name of the forward declaration file (C++/Hybrid
-mapping only).
-
-.IP "\fB\--hxx-regex \fIregex\fR"
-Use the provided expression to construct the name of the header file.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-This expression is also used to construct names for included/imported schemas.
-
-For the C++/Hybrid mapping, the
-.I regex
-argument can be optionally prefixed with a file key in the form
-.IB key = regex\fR.
-The valid values for
-.I key
-are
-.B pskel
-(parser skeleton files),
-.B pimpl
-(parser implementation files),
-.B sskel
-(serializer skeleton files),
-.B simpl
-(serializer implementation files), and
-.B *
-(all files). If
-.I key
-is empty or not present then the expression is used for the object model
-files only.
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--ixx-regex \fIregex\fR"
-Use the provided expression to construct the name of the inline file.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-For the C++/Hybrid mapping, the
-.I regex
-argument can be optionally prefixed with a file key. See the
-.B --hxx-regex
-option for details.
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--cxx-regex \fIregex\fR"
-Use the provided expression to construct the name of the source file.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-For the C++/Hybrid mapping, the
-.I regex
-argument can be optionally prefixed with a file key. See the
-.B --hxx-regex
-option for details.
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--fwd-regex \fIregex\fR"
-Use the provided expression to construct the name of the forward
-declaration file (C++/Hybrid mapping only).
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--hxx-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the header file.
-
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key in the form
-.IB key = text\fR.
-The valid values for
-.I key
-are
-.B pskel
-(parser skeleton files),
-.B pimpl
-(parser implementation files),
-.B sskel
-(serializer skeleton files),
-.B simpl
-(serializer implementation files), and
-.B *
-(all files). If
-.I key
-is empty or not present then the text is used for the object model files only.
-
-.IP "\fB\--ixx-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the inline file.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--cxx-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the source file.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--fwd-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the forward declaration file (C++/Hybrid mapping only).
-
-.IP "\fB\--prologue \fItext\fR"
-Insert
-.I text
-at the beginning of each generated file for which there is no file-specific
-prologue.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--hxx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the header file.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--ixx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the inline file.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--cxx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the source file.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--fwd-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the forward declaration file (C++/Hybrid mapping only).
-
-.IP "\fB\--epilogue \fItext\fR"
-Insert
-.I text
-at the end of each generated file for which there is no file-specific
-epilogue.
-For the C++/Hybrid mapping, the
-.I text
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue
-option for details.
-
-.IP "\fB\--hxx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the header file.
-
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key in the form
-.IB key = file\fR.
-The valid values for
-.I key
-are
-.B pskel
-(parser skeleton files),
-.B pimpl
-(parser implementation files),
-.B sskel
-(serializer skeleton files),
-.B simpl
-(serializer implementation files), and
-.B *
-(all files). If
-.I key
-is empty or not present then the file is used for the object model files only.
-
-.IP "\fB\--ixx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the inline file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--cxx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the source file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--fwd-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the forward declaration file (C++/Hybrid mapping only).
-
-.IP "\fB\--prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of each generated file for which there is no file-specific
-prologue file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--hxx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the header file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--ixx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the inline file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--cxx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the source file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--fwd-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the forward declaration file (C++/Hybrid mapping only).
-
-.IP "\fB\--epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of each generated file for which there is no file-specific
-epilogue file.
-For the C++/Hybrid mapping, the
-.I file
-argument can be optionally prefixed with a file key. See the
-.B --hxx-prologue-file
-option for details.
-
-.IP "\fB\--disable-warning \fIwarn\fR"
-Disable printing warning with id
-.IR warn .
-If
-.B all
-is specified for the warning id then all the warnings are disabled.
-
-.IP "\fB\--show-sloc\fR"
-Show the number of generated physical source lines of code (SLOC).
-
-.IP "\fB\--sloc-limit \fInum\fR"
-Check that the number of generated physical source lines of code (SLOC)
-does not exceed
-.I num.
-
-.IP "\fB\--options-file \fIfile\fR"
-Read additional options from
-.IR file .
-Each option should appear on a separate line optionally followed by
-space and an argument. Empty lines and lines starting with
-.B #
-are ignored. The semantics of providing options in a file is equivalent
-to providing the same set of options in the same order in the command
-line at the point where the
-.B --options-file
-option is specified except that shell escaping and quoting is not
-required. Repeat this option to specify more than one options files.
-
-.IP "\fB\--proprietary-license\fR"
-Indicate that the generated code is licensed under a proprietary license
-instead of the GPL.
-
-.IP "\fB\--preserve-anonymous\fR"
-Preserve anonymous types. By default anonymous types are
-automatically named with names derived from the enclosing
-elements/attributes. Because mappings implemented by this
-compiler require all types to be named, this option is only
-useful if you want to make sure your schemas don't have
-anonymous types.
-
-.IP "\fB\--show-anonymous\fR"
-Show elements and attributes that are of anonymous types. This option
-only makes sense together with the
-.B --preserve-anonymous
-option.
-
-.IP "\fB\--anonymous-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to derive names for anonymous
-types from the enclosing attributes/elements.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported.
-
-All the regular expressions are pushed into a stack with the last
-specified expression considered first. The first match that
-succeeds is used. Regular expressions are applied to a string
-in the form
-
-.I filename namespace xpath
-
-For instance:
-
-.B hello.xsd http://example.com/hello element
-
-.B hello.xsd http://example.com/hello type/element
-
-As an example, the following expression makes all the derived
-names start with capital letters. This could be useful when
-your naming convention requires type names to start with
-capital letters:
-
-.B %.* .* (.+/)*(.+)%\\\\u$2%
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--anonymous-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --anonymous-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-.IP "\fB\--location-map \fIol\fB=\fInl"
-Map the original schema location
-.I ol
-that is specified in the XML Schema include or import elements to new
-schema location
-.IR nl .
-Repeat this option to map more than one schema location. For example,
-the following option maps the
-.B http://example.com/foo.xsd
-URL to the
-.B foo.xsd
-local file.
-
-.B --location-map http://example.com/foo.xsd=foo.xsd
-
-.IP "\fB\--location-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to map schema locations that are
-specified in the XML Schema include or import elements.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported. All the regular expressions are pushed into a stack with the
-last specified expression considered first. The first match that succeeds
-is used.
-
-For example, the following expression maps URL locations in the form
-.B http://example.com/foo/bar.xsd
-to local files in the form
-.BR bar.xsd :
-
-.B %http://.+/(.+)%$1%
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--location-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --location-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-.IP "\fB\--file-per-type\fR"
-Generate a separate set of C++ files for each type defined in XML Schema.
-Note that in this mode you only need to compile the root schema(s) and the
-code will be generated for all included and imported schemas. This
-compilation mode is primarily useful when some of your schemas cannot be
-compiled separately or have cyclic dependencies which involve type
-inheritance. Other options related to this mode are:
-.BR --type-file-regex ,
-.BR --schema-file-regex,
-and
-.BR --file-list .
-
-.IP "\fB\--type-file-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate type names to file
-names when the
-.B --file-per-type
-option is specified.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported. All the regular expressions are pushed into a stack with
-the last specified expression considered first. The first match that
-succeeds is used. Regular expressions are applied to a string
-in the form
-
-.I namespace type-name
-
-For example, the following expression maps type
-.B foo
-that is defined in the
-.B http://example.com/bar
-namespace to file name
-.BR bar-foo :
-
-.B %http://example.com/(.+) (.+)%$1-$2%
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--type-file-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --type-file-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-.IP "\fB\--schema-file-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate schema file names
-when the
-.B --file-per-type
-option is specified.
-.I regex
-is a perl-like regular expression in the form
-.BI / pattern / replacement /\fR.
-Any character can be used as a delimiter instead of
-.BR / .
-Escaping of the delimiter character in
-.I pattern
-or
-.I replacement
-is not supported. All the regular expressions are pushed into a stack
-with the last specified expression considered first. The first match
-that succeeds is used. Regular expressions are applied to the absolute
-filesystem path of a schema file and the result, including the directory
-part, if any, is used to derive the
-.B #include
-directive paths as well as the generated C++ file paths. This option, along
-with
-.B --type-file-regex
-are primarily used to place the generated files into subdirectories or to
-resolve file name conflicts.
-
-For example, the following expression maps schema files in the
-.B foo/1.0.0/
-subdirectory to the files in the
-.B foo/
-subdirectory. As a result, the
-.B #include
-directive paths for such schemas will be in the
-.B foo/schema.hxx
-form and the generated C++ files will be placed into the
-.B foo/
-subdirectory:
-
-.B %.*/foo/1.0.0/(.+)%foo/$1%
-
-See also the REGEX AND SHELL QUOTING section below.
-
-.IP "\fB\--schema-file-regex-trace\fR"
-Trace the process of applying regular expressions specified with
-the
-.B --schema-file-regex
-option. Use this option to find out why your regular expressions
-don't do what you expected them to do.
-
-.IP "\fB\--fat-type-file\fR"
-Generate code corresponding to global elements into type files
-instead of schema files when the
-.B --type-file-regex
-option is specified. This option is primarily useful when trying
-to minimize the amount of object code that is linked to an executable
-by packaging compiled generated code into a static (archive) library.
-
-.IP "\fB\--file-list \fIfile\fR"
-Write a list of generated C++ files to
-.IR file .
-This option is primarily useful in the file-per-type compilation mode
-.RB ( --file-per-type )
-to create a list of generated C++ files, for example, as a makefile fragment.
-
-.IP "\fB\--file-list-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the file list. As a convenience, all occurrences of the
-\\n character sequence in
-.I text
-are replaced with new lines. This option can, for example, be used to assign
-the generated file list to a makefile variable.
-
-.IP "\fB\--file-list-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the file list. As a convenience, all occurrences of the
-\\n character sequence in
-.I text
-are replaced with new lines.
-
-.IP "\fB\--file-list-delim \fItext\fR"
-Delimit file names written to the file list with
-.I text
-instead of new lines. As a convenience, all occurrences of the \\n character
-sequence in
-.I text
-are replaced with new lines.
-
-.\"
-.\" C++/Hybrid options
-.\"
-.SS cxx-hybrid command options
-
-.IP "\fB\--generate-parser\fR"
-Generate XML parsing code.
-
-.IP "\fB\--generate-serializer\fR"
-Generate XML serialization code.
-
-.IP "\fB\--generate-aggregate\fR"
-Generate parser/serializer aggregates for root elements and/or
-types. See also the
-.B --root-element-*
-and
-.B --root-type
-options.
-
-.IP "\fB\--suppress-validation\fR"
-Suppress the generation of validation code in parser and serializer.
-
-.IP "\fB\--suppress-parser-val\fR"
-Suppress the generation of validation code in parser.
-
-.IP "\fB\--suppress-serializer-val\fR"
-Suppress the generation of validation code in serializer.
-
-.IP "\fB\--omit-default-attributes\fR"
-Omit attributes with default and fixed values from serialized XML
-documents.
-
-.IP "\fB\--suppress-enum\fR"
-Suppress the generation of the XML Schema enumeration to C++ enum mapping.
-
-.IP "\fB\--generate-clone\fR"
-Generate clone functions for variable-length types. These functions allow
-you to make dynamically-allocated copies of variable-length objects.
-
-.IP "\fB\--generate-detach\fR"
-Generate detach functions for elements and attributes of variable-length
-types. These functions, for example, allow you to move sub-trees in the
-object model either within the same tree or between different trees.
-
-.IP "\fB\--generate-insertion \fIos\fR"
-Generate data representation stream insertion operators for the
-.I os
-output stream type. Repeat this option to specify more than one stream
-type. The special
-.B CDR
-and
-.B XDR
-arguments are recognized as ACE CDR and Sun RPC XDR stream types and the
-corresponding stream wrappers provided by the XSD/e runtime are automatically
-used. For custom stream types use the
-.B --hxx-prologue*
-options to include the necessary declarations.
-
-.IP "\fB\--generate-extraction \fIis\fR"
-Generate data representation stream extraction operators for the
-.I is
-input stream type. Repeat this option to specify more than one stream
-type. The special
-.B CDR
-and
-.B XDR
-arguments are recognized as ACE CDR and Sun RPC XDR stream types and the
-corresponding stream wrappers provided by the XSD/e runtime are automatically
-used. For custom stream types use the
-.B --hxx-prologue*
-options to include the necessary declarations.
-
-.IP "\fB\--generate-forward\fR"
-Generate forward declaration file.
-
-.IP "\fB\--generate-xml-schema\fR"
-Generate C++ header files as if the schema being compiled defines
-the XML Schema namespace. In particular, the resulting files will
-have definitions for all object model types, parser skeletons and
-implementations, as well as serializer skeletons and implementations
-corresponding to the XML Schema built-in types. The schema file
-provided to the compiler need not exist and is only used to derive
-the names of the resulting header files. Use the
-.B --extern-xml-schema
-option to include these file in the generated files for other schemas.
-
-.IP "\fB\--extern-xml-schema \fIfile\fR"
-Include header files derived from
-.I file
-instead of generating the XML Schema namespace mapping inline. The
-provided file need not exist and is only used to derive the names
-of the included header files. Use the
-.B --generate-xml-schema
-option to generate these header files.
-
-.IP "\fB\--suppress-reset\fR"
-Suppress the generation of parser and serializer reset code.
-Reset support allows you to reuse parsers and serializers
-after an error.
-
-.IP "\fB\--generate-polymorphic\fR"
-Generate polymorphism-aware code. Specify this option if you use substitution
-groups or
-.BR xsi:type .
-Use the
-.B --polymorphic-type
-option to specify which type hierarchies are polymorphic.
-
-.IP "\fB\--runtime-polymorphic\fR"
-Generate non-polymorphic code that uses the runtime library configured with
-polymorphism support.
-
-.IP "\fB\--polymorphic-type \fItype\fR"
-Indicate that
-.I 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
-.IR type .
-
-.IP "\fB\--generate-typeinfo\fR"
-Generate custom type information querying functions for polymorphic
-object model types. These functions can be used instead of the standard
-C++ RTTI mechanism to determine object's type at runtime.
-
-.IP "\fB\--polymorphic-schema \fIfile\fR"
-Indicate that
-.I file
-contains derivations of polymorphic types that are not otherwise visible
-from the schema being compiled. This option is used to make sure that
-during the generation of parser and serializer aggregates the compiler
-is aware of all possible derivations of polymorphic types. Repeat this
-option to specify more than one schema file.
-
-.IP "\fB\--reuse-style-mixin\fR"
-Generate code that supports the mixin base parser/serializer
-implementation reuse style. Note that this reuse style
-relies on virtual inheritance and may result in a substantial
-object code size increase for large vocabularies. By default
-the tiein reuse style is used.
-
-.IP "\fB\--custom-data \fItype\fR"
-Add the ability to store custom data to the C++ class generated
-for XML Schema type
-.IR type .
-To add custom data to a nested compositor class use the qualified
-name starting from the XML Schema type containing the compositor,
-for example,
-.BR foo::sequence::choise1 .
-
-.IP "\fB\--custom-type \fIname\fR[\fB=\fR[\fIflags\fR][\fB/\fR[\fIbase\fR][\fB/\fR[\fItype\fR][\fB/\fIinclude\fR]]]]"
-Use a custom type implementation instead of the generated version. The
-.I name
-component is the XML Schema type name being customized. Optional
-.I flags
-allow you to specify whether the custom type is fixed or variable-length. The
-.B f
-flag indicates the type is fixed-length and the
-.B v
-flag indicates the type is variable-length. If omitted, the default rules
-are used to determine the type length. Optional
-.I type
-is a C++ type name that should be used instead. If specified, the object
-model type is defined as a
-.B typedef
-alias for this C++ type. Optional
-.I base
-is a C++ name that should be given to the generated version. It is normally
-used as a base for the custom implementation. Optional
-.I include
-is the header file that defines the custom implementation. It is
-.BR #include 'ed
-into the generated code immediately after (if
-.I base
-is specified) or instead of the generated version.
-
-.IP "\fB\--custom-parser \fIname\fR[\fB=\fR[\fIbase\fR][\fB/\fIinclude\fR]]"
-Use a custom parser implementation instead of the generated version.
-The
-.I name
-component is the XML Schema type name being customized. Optional
-.I base
-is a C++ name that should be given to the generated version. It is
-normally used as a base for the custom implementation. Optional
-.I include
-is the header file that defines the custom implementation. It is
-.BR #include 'ed
-into the generated code immediately after (if
-.I base
-is specified) or instead of the generated version.
-
-.IP "\fB\--custom-serializer \fIname\fR[\fB=\fR[\fIbase\fR][\fB/\fIinclude\fR]]"
-Use a custom serializer implementation instead of the generated version.
-The
-.I name
-component is the XML Schema type name being customized. Optional
-.I base
-is a C++ name that should be given to the generated version. It is
-normally used as a base for the custom implementation. Optional
-.I include
-is the header file that defines the custom implementation. It is
-.BR #include 'ed
-into the generated code immediately after (if
-.I base
-is specified) or instead of the generated version.
-
-.IP "\fB\--root-element-first\fR"
-Treat only the first global element as a document root. This
-determines for which elements parser and serializer aggregates
-are generated. By default all global elements are considered
-document roots. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--root-element-last\fR"
-Treat only the last global element as a document root. This
-determines for which elements parser and serializer aggregates
-are generated. By default all global elements are considered
-document roots. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--root-element-all\fR"
-Treat all global elements as document roots (the default
-behavior). This determines for which elements parser and
-serializer aggregates are generated. By explicitly specifying
-this option you can suppress the warning that is issued if
-more than one global element is defined. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--root-element-none\fR"
-Do not treat any global elements as document roots. This
-determines for which elements parser and serializer aggregates
-are generated. By default all global elements are considered
-document roots. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--root-element \fIelement\fR"
-Treat only
-.I element
-as a document root. This
-determines for which elements parser and serializer aggregates
-are generated. Repeat this option to specify more than one root
-element. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--root-type \fItype\fR"
-Generate parser/serializer aggregate for
-.IR type .
-Repeat this option to specify more than one type. See also the
-.B --generate-aggregate
-option.
-
-.IP "\fB\--pskel-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _pskel
-to construct the names of generated parser skeletons.
-
-.IP "\fB\--sskel-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _sskel
-to construct the names of generated serializer skeletons.
-
-.IP "\fB\--pskel-file-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B -pskel
-to construct the names of generated parser skeleton files.
-
-.IP "\fB\--sskel-file-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B -sskel
-to construct the names of generated serializer skeleton files.
-
-.IP "\fB\--pimpl-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _pimpl
-to construct the names of generated parser implementations.
-
-.IP "\fB\--simpl-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _simpl
-to construct the names of generated serializer implementations.
-
-.IP "\fB\--pimpl-file-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B -pimpl
-to construct the names of generated parser implementation files.
-
-.IP "\fB\--simpl-file-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B -simpl
-to construct the names of generated serializer implementation files.
-
-.IP "\fB\--paggr-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _paggs
-to construct the names of generated parser aggregates.
-
-.IP "\fB\--saggr-type-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default
-.B _saggr
-to construct the names of generated serializer aggregates.
-
-.\"
-.\" C++/Parser options
-.\"
-.SS cxx-parser command options
-
-.IP "\fB\--type-map \fImapfile\fR"
-Read XML Schema to C++ type mapping information from
-.I mapfile
-Repeat this option to specify several type maps. Type maps are
-considered in order of appearance and the first match is used.
-By default all user-defined types are mapped to
-.BR void .
-See the TYPE MAP section below for more information.
-
-.IP "\fB\--reuse-style-mixin\fR"
-Generate code that supports the mixin base parser implementation reuse
-style. Note that this reuse style relies on virtual inheritance and may
-result in a substantial object code size increase for large vocabularies.
-By default support for the tiein style is generated.
-
-.IP "\fB\--reuse-style-none\fR"
-Do not generate any support for base parser implementation reuse. By
-default support for the tiein style is generated.
-
-.IP "\fB\--suppress-validation\fR"
-Suppress the generation of validation code.
-
-.IP "\fB\--generate-polymorphic\fR"
-Generate polymorphism-aware code. Specify this option if you use substitution
-groups or
-.BR xsi:type .
-
-.IP "\fB\--runtime-polymorphic\fR"
-Generate non-polymorphic code that uses the runtime library configured with
-polymorphism support.
-
-.IP "\fB\--suppress-reset\fR"
-Suppress the generation of parser reset code. Reset support allows you to reuse
-parsers after an error.
-
-.IP "\fB\--generate-noop-impl\fR"
-Generate a sample parser implementation that does nothing (no operation).
-The sample implementation can then be filled with the application-specific
-code. For an input file in the form
-.B name.xsd
-this option triggers the generation of the two additional C++ files in the form:
-.B name-pimpl.hxx
-(parser implementation header file) and
-.B name-pimpl.cxx
-(parser implementation source file).
-
-.IP "\fB\--generate-print-impl\fR"
-Generate a sample parser implementation that prints the XML data to STDOUT.
-For an input file in the form
-.B name.xsd
-this option triggers the generation of the two additional C++ files in the form:
-.B name-pimpl.hxx
-(parser implementation header file) and
-.B name-pimpl.cxx
-(parser implementation source file).
-
-.IP "\fB\--generate-test-driver\fR"
-Generate a test driver for the sample parser implementation. For an input
-file in the form
-.B name.xsd
-this option triggers the generation of an additional C++ file in the form
-.BR name-pdriver.cxx .
-
-.IP "\fB\--force-overwrite\fR"
-Force overwriting of the existing implementation and test driver files.
-Use this option only if you do not mind loosing the changes you have made
-in the sample implementation or test driver files.
-
-.IP "\fB\--root-element-first\fR"
-Indicate that the first global element is the document root. This information
-is used to generate the test driver for the sample implementation.
-
-.IP "\fB\--root-element-last\fR"
-Indicate that the last global element is the document root. This information
-is used to generate the test driver for the sample implementation.
-
-.IP "\fB\--root-element \fIelement\fR"
-Indicate that
-.I element
-is the document root. This information is used to generate the test driver
-for the sample implementation.
-
-.IP "\fB\--generate-xml-schema\fR"
-Generate a C++ header file as if the schema being compiled defines the
-XML Schema namespace. In particular, the resulting file will have
-definitions for all parser skeletons and implementations corresponding
-to the XML Schema built-in types. The schema file provided to the compiler
-need not exist and is only used to derive the name of the resulting header
-file. Use the
-.B --extern-xml-schema
-option to include this file in the generated files for other schemas.
-
-.IP "\fB\--extern-xml-schema \fIfile\fR"
-Include a header file derived from
-.I file
-instead of generating the XML Schema namespace mapping inline. The provided
-file need not exist and is only used to derive the name of the included
-header file. Use the
-.B --generate-xml-schema
-option to generate this header file.
-
-.IP "\fB\--skel-type-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B _pskel
-to construct the names of generated parser skeletons.
-
-.IP "\fB\--skel-file-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B -pskel
-to construct the names of generated parser skeleton files.
-
-.IP "\fB\--impl-type-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B _pimpl
-to construct the names of parser implementations for the built-in XML
-Schema types and sample parser implementations.
-
-.IP "\fB\--impl-file-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B -pimpl
-to construct the names of generated sample parser implementation files.
-
-.\"
-.\" C++/Serializer options
-.\"
-.SS cxx-serializer command options
-
-.IP "\fB\--type-map \fImapfile\fR"
-Read XML Schema to C++ type mapping information from
-.I mapfile
-Repeat this option to specify several type maps. Type maps are
-considered in order of appearance and the first match is used.
-By default all user-defined types are mapped to
-.BR void .
-See the TYPE MAP section below for more information.
-
-.IP "\fB\--reuse-style-mixin\fR"
-Generate code that supports the mixin base serializer implementation reuse
-style. Note that this reuse style relies on virtual inheritance and may
-result in a substantial object code size increase for large vocabularies.
-By default support for the tiein style is generated.
-
-.IP "\fB\--reuse-style-none\fR"
-Do not generate any support for base serializer implementation reuse. By
-default support for the tiein style is generated.
-
-.IP "\fB\--suppress-validation\fR"
-Suppress the generation of validation code.
-
-.IP "\fB\--generate-polymorphic\fR"
-Generate polymorphism-aware code. Specify this option if you use substitution
-groups or
-.BR xsi:type .
-
-.IP "\fB\--runtime-polymorphic\fR"
-Generate non-polymorphic code that uses the runtime library configured with
-polymorphism support.
-
-.IP "\fB\--suppress-reset\fR"
-Suppress the generation of serializer reset code. Reset support allows you to
-reuse serializers after an error.
-
-.IP "\fB\--generate-empty-impl\fR"
-Generate a sample serializer implementation with empty function bodies
-which can then be filled with the application-specific code. For an input
-file in the form
-.B name.xsd
-this option triggers the generation of the two additional C++ files in the form:
-.B name-simpl.hxx
-(serializer implementation header file) and
-.B name-simpl.cxx
-(serializer implementation source file).
-
-.IP "\fB\--generate-test-driver\fR"
-Generate a test driver for the sample serializer implementation. For an input
-file in the form
-.B name.xsd
-this option triggers the generation of an additional C++ file in the form
-.BR name-sdriver.cxx .
-
-.IP "\fB\--force-overwrite\fR"
-Force overwriting of the existing implementation and test driver files.
-Use this option only if you do not mind loosing the changes you have made
-in the sample implementation or test driver files.
-
-.IP "\fB\--root-element-first\fR"
-Indicate that the first global element is the document root. This information
-is used to generate the test driver for the sample implementation.
-
-.IP "\fB\--root-element-last\fR"
-Indicate that the last global element is the document root. This information
-is used to generate the test driver for the sample implementation.
-
-.IP "\fB\--root-element \fIelement\fR"
-Indicate that
-.I element
-is the document root. This information is used to generate the test driver
-for the sample implementation.
-
-.IP "\fB\--generate-xml-schema\fR"
-Generate a C++ header file as if the schema being compiled defines the
-XML Schema namespace. In particular, the resulting file will have
-definitions for all serializer skeletons and implementations corresponding
-to the XML Schema built-in types. The schema file provided to the compiler
-need not exist and is only used to derive the name of the resulting header
-file. Use the
-.B --extern-xml-schema
-option to include this file in the generated files for other schemas.
-
-.IP "\fB\--extern-xml-schema \fIfile\fR"
-Include a header file derived from
-.I file
-instead of generating the XML Schema namespace mapping inline. The provided
-file need not exist and is only used to derive the name of the included
-header file. Use the
-.B --generate-xml-schema
-option to generate this header file.
-
-.IP "\fB\--skel-type-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B _sskel
-to construct the names of generated serializer skeletons.
-
-.IP "\fB\--skel-file-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B -sskel
-to construct the names of generated serializer skeleton files.
-
-.IP "\fB\--impl-type-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B _simpl
-to construct the names of serializer implementations for the built-in XML
-Schema types and sample serializer implementations.
-
-.IP "\fB\--impl-file-suffix \fIsuffix\fR"
-Use the provided
-.I suffix
-instead of the default
-.B -simpl
-to construct the names of generated sample serializer implementation files.
-
-.\"
-.\" Type map
-.\"
-.SH TYPE MAP
-
-Type map files are used to define a mapping between XML Schema and
-C++ types. For C++/Parser, the compiler uses this information to
-determine the return types of
-.B post_*
-functions in parser skeletons corresponding to XML Schema types as
-well as argument types for callbacks corresponding to elements and
-attributes of these types. For C++/Serializer, type maps are used
-to determine the argument type of
-.B pre
-functions in serializer skeletons corresponding to XML Schema types
-as well as return types for callbacks corresponding to elements and
-attributes of these types.
-
-The compiler has a set of predefined mapping rules that map the
-built-in XML Schema types to suitable C++ types (discussed in
-the following sub-sections) and all other types to
-.BR void .
-By providing your own type maps you can override these predefined
-rules. The format of the type map file is presented below:
-
-
-.RS
-.B namespace
-.I schema-namespace
-[
-.I cxx-namespace
-]
-.br
-.B {
-.br
-  (
-.B include
-.IB file-name ;
-)*
-.br
-  ([
-.B type
-]
-.I schema-type cxx-ret-type
-[
-.I cxx-arg-type
-.RB ] ;
-)*
-.br
-.B }
-.br
-.RE
-
-Both
-.I schema-namespace
-and
-.I schema-type
-are regex patterns while
-.IR cxx-namespace ,
-.IR cxx-ret-type ,
-and
-.I cxx-arg-type
-are regex pattern substitutions. All names can be optionally enclosed
-in \fR" "\fR, for example, to include white-spaces.
-
-.I schema-namespace
-determines XML Schema namespace. Optional
-.I cxx-namespace
-is prefixed to every C++ type name in this namespace declaration.
-.I cxx-ret-type
-is a C++ type name that is used as a return type for the
-.B post_*
-function in C++/Parser or for element/attribute callbacks in C++/Serializer.
-Optional
-.I cxx-arg-type
-is an argument type for element/attribute callbacks in C++/Parser or for the
-.B pre
-function in C++/Serializer. If
-.I cxx-arg-type
-is not specified, it defaults to
-.I cxx-ret-type
-if
-.I cxx-ret-type
-ends with
-.B *
-or
-.B &
-(that is, it is a pointer or a reference) and
-.B const
-\fIcxx-ret-type\fB&\fR otherwise.
-.I file-name
-is a file name either in the \fR" "\fR or < > format and is added with the
-.B #include
-directive to the generated code.
-
-The \fB#\fR character starts a comment that ends with a new line or end of
-file. To specify a name that contains \fB#\fR enclose it in \fR" "\fR. For
-example:
-
-.RS
-namespace http://www.example.com/xmlns/my my
-.br
-{
-.br
-  include "my.hxx";
-.br
-
-  # Pass apples by value.
-  #
-  apple apple;
-.br
-
-  # Pass oranges as pointers.
-  #
-  orange orange_t*;
-.br
-}
-.br
-.RE
-
-In the example above, for the
-.B http://www.example.com/xmlns/my#orange
-XML Schema type, the
-.B my::orange_t*
-C++ type will be used as both return and argument types.
-
-Several namespace declarations can be specified in a single file.
-The namespace declaration can also be completely omitted to map
-types in a schema without a namespace. For instance:
-
-.RS
-include "my.hxx";
-.br
-apple apple;
-.br
-
-namespace http://www.example.com/xmlns/my
-.br
-{
-.br
-  orange "const orange_t*";
-.br
-}
-.br
-.RE
-
-The compiler has a number of predefined mapping rules for the built-in
-XML Schema types that vary depending on the mapping used. They are
-described in the following subsections. The last predefined rule
-for all the mappings maps anything that wasn't mapped by previous rules to
-.BR void :
-
-.RS
-namespace .*
-.br
-{
-.br
-  .* void void;
-.br
-}
-.br
-.RE
-
-When you provide your own type maps with the
-.B --type-map
-option, they are evaluated first. This allows you to selectively override
-predefined rules.
-
-.\"
-.\" Predefined C++/Parser Type Maps
-.\"
-.SS Predefined C++/Parser Type Maps
-
-The C++/Parser mapping provides a number of predefined type map rules
-for the built-in XML Schema types. They can be presented as the
-following map files:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  boolean bool bool;
-.br
-
-  byte "signed char" "signed char";
-.br
-  unsignedByte "unsigned char" "unsigned char";
-.br
-
-  short short short;
-.br
-  unsignedShort "unsigned short" "unsigned short";
-.br
-
-  int int int;
-.br
-  unsignedInt "unsigned int" "unsigned int";
-.br
-
-  long "long long" "long long";
-.br
-  unsignedLong "unsigned long long" "unsigned long long";
-.br
-
-  integer long long;
-.br
-
-  negativeInteger long long;
-.br
-  nonPositiveInteger long long;
-.br
-
-  positiveInteger "unsigned long" "unsigned long";
-.br
-  nonNegativeInteger "unsigned long" "unsigned long";
-.br
-
-  float float float;
-.br
-  double double double;
-.br
-  decimal double double;
-.br
-
-  NMTOKENS xml_schema::string_sequence*;
-.br
-  IDREFS xml_schema::string_sequence*;
-.br
-
-  base64Binary xml_schema::buffer*;
-.br
-  hexBinary xml_schema::buffer*;
-.br
-
-  date xml_schema::date;
-.br
-  dateTime xml_schema::date_time;
-.br
-  duration xml_schema::duration;
-.br
-  gDay xml_schema::gday;
-.br
-  gMonth xml_schema::gmonth;
-.br
-  gMonthDay xml_schema::gmonth_day;
-.br
-  gYear xml_schema::gyear;
-.br
-  gYearMonth xml_schema::gyear_month;
-.br
-  time xml_schema::time;
-.br
-}
-.br
-.RE
-
-If the
-.B --no-stl
-option is not specified, the following mapping is used for the
-string-based XML Schema built-in types:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  include <string>;
-.br
-
-  string std::string;
-.br
-  normalizedString std::string;
-.br
-  token std::string;
-.br
-  Name std::string;
-.br
-  NMTOKEN std::string;
-.br
-  NCName std::string;
-.br
-  ID std::string;
-.br
-  IDREF std::string;
-.br
-  language std::string;
-.br
-  anyURI std::string;
-.br
-
-  QName xml_schema::qname;
-.br
-}
-.br
-.RE
-
-Otherwise, a C string-based mapping is used:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  string char*;
-.br
-  normalizedString char*;
-.br
-  token char*;
-.br
-  Name char*;
-.br
-  NMTOKEN char*;
-.br
-  NCName char*;
-.br
-  ID char*;
-.br
-  IDREF char*;
-.br
-  language char*;
-.br
-  anyURI char*;
-.br
-
-  QName xml_schema::qname*;
-.br
-}
-.br
-.RE
-
-.\"
-.\" Predefined C++/Serializer Type Maps
-.\"
-.SS Predefined C++/Serializer Type Maps
-
-The C++/Serializer mapping provides a number of predefined type map
-rules for the built-in XML Schema types. They can be presented as the
-following map files:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  boolean bool bool;
-.br
-
-  byte "signed char" "signed char";
-.br
-  unsignedByte "unsigned char" "unsigned char";
-.br
-
-  short short short;
-.br
-  unsignedShort "unsigned short" "unsigned short";
-.br
-
-  int int int;
-.br
-  unsignedInt "unsigned int" "unsigned int";
-.br
-
-  long "long long" "long long";
-.br
-  unsignedLong "unsigned long long" "unsigned long long";
-.br
-
-  integer long long;
-.br
-
-  negativeInteger long long;
-.br
-  nonPositiveInteger long long;
-.br
-
-  positiveInteger "unsigned long" "unsigned long";
-.br
-  nonNegativeInteger "unsigned long" "unsigned long";
-.br
-
-  float float float;
-.br
-  double double double;
-.br
-  decimal double double;
-.br
-
-  NMTOKENS "const xml_schema::string_sequence*";
-.br
-  IDREFS "const xml_schema::string_sequence*";
-.br
-
-  base64Binary "const xml_schema::buffer*";
-.br
-  hexBinary "const xml_schema::buffer*";
-.br
-
-  date xml_schema::date;
-.br
-  dateTime xml_schema::date_time;
-.br
-  duration xml_schema::duration;
-.br
-  gDay xml_schema::gday;
-.br
-  gMonth xml_schema::gmonth;
-.br
-  gMonthDay xml_schema::gmonth_day;
-.br
-  gYear xml_schema::gyear;
-.br
-  gYearMonth xml_schema::gyear_month;
-.br
-  time xml_schema::time;
-.br
-}
-.br
-.RE
-
-If the
-.B --no-stl
-option is not specified, the following mapping is used for the
-string-based XML Schema built-in types:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  include <string>;
-.br
-
-  string std::string;
-.br
-  normalizedString std::string;
-.br
-  token std::string;
-.br
-  Name std::string;
-.br
-  NMTOKEN std::string;
-.br
-  NCName std::string;
-.br
-  ID std::string;
-.br
-  IDREF std::string;
-.br
-  language std::string;
-.br
-  anyURI std::string;
-.br
-
-  QName xml_schema::qname;
-.br
-}
-.br
-.RE
-
-Otherwise, a C string-based mapping is used:
-
-.RS
-namespace http://www.w3.org/2001/XMLSchema
-.br
-{
-.br
-  string "const char*";
-.br
-  normalizedString "const char*";
-.br
-  token "const char*";
-.br
-  Name "const char*";
-.br
-  NMTOKEN "const char*";
-.br
-  NCName "const char*";
-.br
-  ID "const char*";
-.br
-  IDREF "const char*";
-.br
-  language "const char*";
-.br
-  anyURI "const char*";
-.br
-
-  QName "const xml_schema::qname*";
-.br
-}
-.br
-.RE
-
-.\"
-.\" REGEX AND SHELL QUOTING
-.\"
-.SH REGEX AND SHELL QUOTING
-When entering a regular expression argument in the shell command line
-it is often necessary to use quoting (enclosing the argument in " "
-or ' ') in order to prevent the shell from interpreting certain
-characters, for example, spaces as argument separators and $ as
-variable expansions.
-
-Unfortunately it is hard to achieve this in a manner that is portable
-across POSIX shells, such as those found on GNU/Linux and UNIX, and
-Windows shell. For example, if you use " " for quoting you will get
-a wrong result with POSIX shells if your expression contains $. The
-standard way of dealing with this on POSIX systems is to use ' '
-instead. Unfortunately, Windows shell does not remove ' '  from
-arguments when they are passed to applications. As a result you may
-have to use ' ' for POSIX and " " for Windows ($ is not treated as
-a special character on Windows).
-
-Alternatively, you can save regular expression options into a file,
-one option per line, and use this file with the
-.B --options-file
-option. With this approach you don't need to worry about shell quoting.
-
-.\"
-.\" DIAGNOSTICS
-.\"
-.SH DIAGNOSTICS
-If the input file is not a valid W3C XML Schema definition,
-.B xsde
-will issue diagnostic messages to
-.B STDERR
-and exit with non-zero exit code.
-
-.SH BUGS
-Send bug reports to the xsde-users@codesynthesis.com mailing list.
-
-.SH COPYRIGHT
-Copyright (c) 2005-2011 Code Synthesis Tools CC.
-
-Permission is granted to copy, distribute and/or modify this
-document under the terms of the GNU Free Documentation License,
-version 1.2; with no Invariant Sections, no Front-Cover Texts and
-no Back-Cover Texts. Copy of the license can be obtained from
-http://codesynthesis.com/licenses/fdl-1.2.txt
diff --git a/documentation/xsde.xhtml b/documentation/xsde.xhtml
deleted file mode 100644
index f0b0c76..0000000
--- a/documentation/xsde.xhtml
+++ /dev/null
@@ -1,1725 +0,0 @@
-<?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
-
-<head>
-  <title>XSD/e 3.3.0 Compiler Command Line Manual</title>
-
-  <meta name="copyright" content="&copy; 2005-2011 Code Synthesis Tools CC"/>
-  <meta name="keywords" content="xsd,xml,schema,c++,mapping,data,binding,code,generator,manual,man,page"/>
-  <meta name="description" content="XSD/e Compiler Command Line Manual"/>
-
-  <link rel="stylesheet" type="text/css" href="default.css" />
-
-<style type="text/css">
-
-  #synopsis {
-    list-style-type:  none;
-  }
-
-  #synopsis li {
-    padding-top      : 0.0em;
-    padding-bottom   : 0.0em;
-  }
-
-  #commands dt {
-    padding-top      : 0.4em;
-  }
-
-  #commands dd {
-    padding-bottom   : 0.4em;
-    padding-left     : 2em;
-  }
-
-  .options dt {
-    padding-top      : 0.4em;
-  }
-
-  .options dd {
-    padding-top      : 0.1em;
-    padding-bottom   : 0.4em;
-    padding-left     : 1.4em;
-  }
-
-</style>
-</head>
-
-<body>
-<div id="container">
-  <div id="content">
-
-  <h1>NAME</h1>
-
-  <p>xsde - W3C XML Schema to C++ Compiler for Embedded Systems</p>
-
-  <h1>SYNOPSIS</h1>
-
-  <dl id="synopsis">
-    <dt><code><b>xsde</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
-    <dt><code><b>xsde help</b> [<i>command</i>]</code></dt>
-    <dt><code><b>xsde version</b></code></dt>
-  </dl>
-
-  <h1>DESCRIPTION</h1>
-
-  <p><code><b>xsde</b></code> generates vocabulary-specific, statically-typed
-  C++ mapping from W3C XML Schema definitions. Particular mapping to
-  produce is selected by a <code><i>command</i></code>. Each mapping has
-  a number of mapping-specific <code><i>options</i></code> that should
-  appear, if any, after the <code><i>command</i></code>. Input files should
-  be W3C XML Schema definitions. The exact set of the generated files
-  depends on the selected mapping and options.</p>
-
-  <h1>COMMANDS</h1>
-
-  <dl id="commands">
-    <dt><code><b>cxx-hybrid</b></code></dt>
-    <dd>Generate the Embedded C++/Hybrid mapping. For each input file in the
-        form <code><b>name.xsd</b></code> the following C++ files are generated:
-        <code><b>name.hxx</b></code> (object model header file),
-        <code><b>name.ixx</b></code> (object model inline file, generated only
-          if the <code><b>--generate-inline</b></code> option is specified),
-	<code><b>name.cxx</b></code> (object model source file), and
-        <code><b>name-fwd.hxx</b></code> (object model forward declaration
-          file, generated only if the <code><b>--generate-forward</b></code>
-          option is specified).
-
-        <p>If the <code><b>--generate-parser</b></code> option is specified,
-        the Embedded C++/Parser mapping is invoked and the
-        <code><b>name-pskel.hxx</b></code>,
-        <code><b>name-pskel.ixx</b></code>, and
-	<code><b>name-pskel.cxx</b></code> parser skeleton files are
-        generated, as described below. Additionally, the following parser
-        implementation files are generated:
-        <code><b>name-pimpl.hxx</b></code> (parser implementation header
-        file) and
-        <code><b>name-pimpl.cxx</b></code> (parser implementation source
-        file).</p>
-
-        <p>If the <code><b>--generate-serializer</b></code> option is
-        specified, the Embedded C++/Serializer mapping is invoked and the
-        <code><b>name-sskel.hxx</b></code>,
-        <code><b>name-sskel.ixx</b></code>, and
-	<code><b>name-sskel.cxx</b></code> serializer skeleton files are
-        generated, as described below. Additionally, the following serializer
-        implementation files are generated:
-        <code><b>name-simpl.hxx</b></code> (serializer implementation header
-        file) and
-        <code><b>name-simpl.cxx</b></code> (serializer implementation source
-        file).</p>
-    </dd>
-
-    <dt><code><b>cxx-parser</b></code></dt>
-    <dd>Generate the Embedded C++/Parser mapping. For each input file in the
-        form <code><b>name.xsd</b></code> the following C++ files are generated:
-        <code><b>name-pskel.hxx</b></code> (parser skeleton header file),
-        <code><b>name-pskel.ixx</b></code> (parser skeleton inline file,
-          generated only if the <code><b>--generate-inline</b></code>
-          option is specified), and
-	<code><b>name-pskel.cxx</b></code> (parser skeleton source file).
-        If the <code><b>--generate-noop-impl</b></code> or
-        <code><b>--generate-print-impl</b></code> option is specified,
-        the following additional sample implementation files are generated:
-        <code><b>name-pimpl.hxx</b></code> (parser implementation header
-        file) and
-        <code><b>name-pimpl.cxx</b></code> (parser implementation source
-        file). If the <code><b>--generate-test-driver</b></code> option
-        is specified, the additional <code><b>name-pdriver.cxx</b></code>
-        test driver file is generated.</dd>
-
-    <dt><code><b>cxx-serializer</b></code></dt>
-    <dd>Generate the Embedded C++/Serializer mapping. For each input file
-        in the form <code><b>name.xsd</b></code> the following C++ files
-        are generated: <code><b>name-sskel.hxx</b></code> (serializer
-        skeleton header file), <code><b>name-sskel.ixx</b></code> (serializer
-        skeleton inline file, generated only if the
-        <code><b>--generate-inline</b></code> option is specified), and
-	<code><b>name-sskel.cxx</b></code> (serializer skeleton source file).
-        If the <code><b>--generate-empty-impl</b></code> option is specified,
-        the following additional sample implementation files are generated:
-        <code><b>name-simpl.hxx</b></code> (serializer implementation header
-        file) and <code><b>name-simpl.cxx</b></code> (serializer
-        implementation source file). If the <code><b>--generate-test-driver</b></code>
-        option is specified, the additional <code><b>name-sdriver.cxx</b></code>
-        test driver file is generated.
-    </dd>
-
-    <dt><code><b>help</b></code></dt>
-    <dd>Print usage information and exit. Use
-      <p><code><b>xsde help</b> <i>command</i></code></p>
-      for command-specific help.
-    </dd>
-
-    <dt><code><b>version</b></code></dt>
-    <dd>Print version and exit.</dd>
-  </dl>
-
-  <h1>OPTIONS</h1>
-
-  <p>Command-specific <code><i>options</i></code>, if any, should appear
-  after the corresponding <code><i>command</i></code>.</p>
-
-  <h2>COMMON OPTIONS</h2>
-
-  <dl class="options">
-    <dt><code><b>--output-dir</b> <i>dir</i></code></dt>
-    <dd>Write generated files to <code><i>dir</i></code> instead of
-      the current directory.</dd>
-
-    <dt><code><b>--char-encoding</b> <i>enc</i></code></dt>
-    <dd>Specify the application character encoding. Valid values are
-        <code><b>utf8</b></code> (default) and <code><b>iso8859-1</b></code>.
-        Note that this encoding is not the same as the XML document encoding
-        that is being parsed or serialized. Rather, it is the encoding that
-        is used inside the application. When an XML document is parsed, the
-        character data is automatically converted to the application encoding.
-        Similarly, when an XML document is serialized, the data in the
-        application encoding is automatically converted to the resulting
-        document encoding.</dd>
-
-    <dt><code><b>--no-stl</b></code></dt>
-    <dd>Generate code that does not use the Standard Template Library
-        (STL).</dd>
-
-    <dt><code><b>--no-iostream</b></code></dt>
-    <dd>Generate code that does not use the standard input/output
-        stream library (iostream).</dd>
-
-    <dt><code><b>--no-exceptions</b></code></dt>
-    <dd>Generate code that does not use C++ exceptions.</dd>
-
-    <dt><code><b>--no-long-long</b></code></dt>
-    <dd>Generate code that does not use the <code><b>long long</b></code>
-        and <code><b>unsigned long long</b></code> types. The
-        64 bit <code><b>long</b></code> and <code><b>unsignedLong</b></code>
-        built-in XML Schema types are then mapped to <code><b>long</b></code>
-        and <code><b>unsigned long</b></code>.</dd>
-
-    <dt><code><b>--custom-allocator</b></code></dt>
-    <dd>Generate code that performs memory management using custom allocator
-        functions provided by your application instead of the standard
-        operator new/delete.</dd>
-
-    <dt><code><b>--generate-inline</b></code></dt>
-    <dd>Generate simple functions inline. This option triggers creation
-      of the inline file.</dd>
-
-    <dt><code><b>--namespace-map</b> <i>xns</i><b>=</b><i>cns</i></code></dt>
-    <dd>Map XML Schema namespace <i>xns</i> to C++ namespace <i>cns</i>.
-        Repeat this option to specify mapping for more than one XML Schema
-        namespace. For example, the following option:
-
-        <p><code><b>--namespace-map http://example.com/foo/bar=foo::bar</b></code></p>
-
-        <p>will map the <code><b>http://example.com/foo/bar</b></code>
-           XML Schema namespace to the <code><b>foo::bar</b></code> C++
-           namespace.</p>
-    </dd>
-
-    <dt><code><b>--namespace-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to translate XML Schema namespace names to C++ namespace
-      names. <code><i>regex</i></code> is a perl-like regular expression in
-      the form <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported.
-
-      <p>All the regular expressions are pushed into a stack with the last
-        specified expression considered first. The first match that
-        succeeds is used. Regular expressions are applied to a string
-        in the form</p>
-
-      <p><code><i>filename</i> <i>namespace</i></code></p>
-
-      <p>For example, if you have file <code><b>hello.xsd</b></code>
-        with namespace <code><b>http://example.com/hello</b></code> and you run
-        <code><b>xsd</b></code> on this file, then the string in question
-        will be:</p>
-
-      <p><code><b>hello.xsd. http://example.com/hello</b></code></p>
-
-      <p>For the built-in XML Schema namespace the string is:</p>
-
-      <p><code><b>XMLSchema.xsd http://www.w3.org/2001/XMLSchema</b></code></p>
-
-      <p>The following three steps are performed for each regular expression
-        until the match is found:</p>
-
-      <ol>
-        <li>The expression is applied and if the result is empty the
-          next expression is considered.</li>
-
-        <li>All <code><b>/</b></code> are replaced with
-          <code><b>::</b></code>.</li>
-
-        <li>The result is verified to be a valid C++ scope name (e.g.,
-          <code><b>foo::bar</b></code>). If this test succeeds, the
-          result is used as a C++ namespace name.</li>
-      </ol>
-
-      <p>As an example, the following expression maps XML  Schema
-        namespaces  in  the  form
-        <code><b>http://example.com/foo/bar</b></code> to C++
-        namespaces in the form <code><b>foo::bar</b></code>:</p>
-
-      <p><code><b>%.* http://example.com/(.+)%$1%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--namespace-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--namespace-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <!-- Reserved names -->
-
-    <dt><code><b>--reserved-name</b> <i>name</i>[<b>=</b><i>rep</i>]</code></dt>
-    <dd>Add <code><i>name</i></code> to the list of names that should not
-        be used as identifiers. The name can optionally be followed by
-        <code><b>=</b></code> and the replacement name that should be
-        used instead. All the C++ keywords are already in this list.
-    </dd>
-
-    <dt><code><b>--include-with-brackets</b></code></dt>
-    <dd>Use angle brackets (&lt;&gt;) instead of quotes ("") in
-        generated <code><b>#include</b></code> directives.
-    </dd>
-
-    <dt><code><b>--include-prefix</b> <i>prefix</i></code></dt>
-    <dd>Add <code><i>prefix</i></code> to generated <code><b>#include</b></code>
-        directive paths.
-
-        <p>For example, if you had the following import element in your
-           schema</p>
-
-        <p><code><b>&lt;import namespace="..." schemaLocation="base.xsd"/&gt;</b></code></p>
-
-        <p>and compiled this fragment with <code><b>--include-prefix schemas/</b></code>,
-           then the include directive in the generated code would be:</p>
-
-        <p><code><b>#include "schemas/base.hxx"</b></code></p>
-    </dd>
-
-    <dt><code><b>--include-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to transform <code><b>#include</b></code> directive paths.
-      <code><i>regex</i></code> is a perl-like regular expression in
-      the form <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported.
-
-      <p>All the regular expressions are pushed into a stack with the last
-        specified expression considered first. The first match that
-        succeeds is used.</p>
-
-      <p>As an example, the following expression transforms paths
-        in the form <code><b>schemas/foo/bar</b></code> to paths
-        in the form <code><b>generated/foo/bar</b></code>:</p>
-
-      <p><code><b>%schemas/(.+)%generated/$1%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--include-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--include-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <dt><code><b>--guard-prefix</b> <i>prefix</i></code></dt>
-    <dd>Add <code><i>prefix</i></code> to generated header inclusion guards.
-        The prefix is transformed to upper case and characters that are
-        illegal in a preprocessor macro name are replaced with underscores.
-        If this option is not specified then the directory part of the
-        input schema file is used as a prefix.
-    </dd>
-
-    <dt><code><b>--hxx-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the default
-      <code><b>.hxx</b></code> to construct the name of the header file.
-      Note that this suffix is also used to construct names for
-      included/imported schemas.
-    </dd>
-
-    <dt><code><b>--ixx-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the default
-      <code><b>.ixx</b></code> to construct the name of the inline file.
-    </dd>
-
-    <dt><code><b>--cxx-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the default
-      <code><b>.cxx</b></code> to construct the name of the source file.
-    </dd>
-
-    <dt><code><b>--fwd-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the default
-      <code><b>-fwd.hxx</b></code> to construct the name of the forward
-      declaration file (C++/Hybrid mapping only).
-    </dd>
-
-    <dt><code><b>--hxx-regex</b> <i>regex</i></code></dt>
-    <dd>Use the provided expression to construct the name of the header
-      file. <code><i>regex</i></code> is a perl-like regular expression
-      in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      This expression is also used to construct names for included/imported
-      schemas.
-
-      <p>
-      For the C++/Hybrid mapping, the <code><i>regex</i></code> argument
-      can be optionally prefixed with a file key in the form
-      <code><i>key</i>=<i>regex</i></code>. The valid values for
-      <code><i>key</i></code> are <code><b>pskel</b></code> (parser
-      skeleton files), <code><b>pimpl</b></code> (parser implementation
-      files), <code><b>sskel</b></code> (serializer skeleton files),
-      <code><b>simpl</b></code> (serializer implementation files),
-      and <code><b>*</b></code> (all files). If <code><i>key</i></code>
-      is empty or not present then the expression is used for the
-      object model files only.
-      </p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--ixx-regex</b> <i>regex</i></code></dt>
-    <dd>Use the provided expression to construct the name of the inline
-      file. <code><i>regex</i></code> is a perl-like regular expression
-      in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      For the C++/Hybrid mapping, the <code><i>regex</i></code> argument
-      can be optionally prefixed with a file key. See the
-      <code><b>--hxx-regex</b></code> option for details.
-      See also the REGEX AND SHELL QUOTING section below.
-    </dd>
-
-    <dt><code><b>--cxx-regex</b> <i>regex</i></code></dt>
-    <dd>Use the provided expression to construct the name of the source
-      file. <code><i>regex</i></code> is a perl-like regular expression
-      in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      For the C++/Hybrid mapping, the <code><i>regex</i></code> argument
-      can be optionally prefixed with a file key. See the
-      <code><b>--hxx-regex</b></code> option for details.
-      See also the REGEX AND SHELL QUOTING section below.
-    </dd>
-
-    <dt><code><b>--fwd-regex</b> <i>regex</i></code></dt>
-    <dd>Use the provided expression to construct the name of the forward
-      declaration file (C++/Hybrid mapping only). <code><i>regex</i></code>
-      is a perl-like regular expression in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      See also the REGEX AND SHELL QUOTING section below.
-    </dd>
-
-    <!-- prologue options -->
-
-    <dt><code><b>--hxx-prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of the header file.
-
-      <p>
-      For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-      can be optionally prefixed with a file key in the form
-      <code><i>key</i>=<i>text</i></code>. The valid values for
-      <code><i>key</i></code> are <code><b>pskel</b></code> (parser
-      skeleton files), <code><b>pimpl</b></code> (parser implementation
-      files), <code><b>sskel</b></code> (serializer skeleton files),
-      <code><b>simpl</b></code> (serializer implementation files),
-      and <code><b>*</b></code> (all files). If <code><i>key</i></code>
-      is empty or not present then the text is used for the
-      object model files only.
-      </p>
-
-    </dd>
-
-    <dt><code><b>--ixx-prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of the inline file.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--cxx-prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of the source file.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--fwd-prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of the forward
-        declaration file (C++/Hybrid mapping only).
-    </dd>
-
-    <dt><code><b>--prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of each generated
-        file for which there is no file-specific prologue.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <!-- epilogue options -->
-
-    <dt><code><b>--hxx-epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of the header file.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--ixx-epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of the inline file.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--cxx-epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of the source file.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--fwd-epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of the forward
-        declaration file (C++/Hybrid mapping only).
-    </dd>
-
-    <dt><code><b>--epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of each generated
-        file for which there is no file-specific epilogue.
-        For the C++/Hybrid mapping, the <code><i>text</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue</b></code> option for details.
-    </dd>
-
-    <!-- prologue file options -->
-
-    <dt><code><b>--hxx-prologue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the beginning
-      of the header file.
-
-      <p>
-      For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-      can be optionally prefixed with a file key in the form
-      <code><i>key</i>=<i>file</i></code>. The valid values for
-      <code><i>key</i></code> are <code><b>pskel</b></code> (parser
-      skeleton files), <code><b>pimpl</b></code> (parser implementation
-      files), <code><b>sskel</b></code> (serializer skeleton files),
-      <code><b>simpl</b></code> (serializer implementation files),
-      and <code><b>*</b></code> (all files). If <code><i>key</i></code>
-      is empty or not present then the file is used for the
-      object model files only.
-      </p>
-    </dd>
-
-    <dt><code><b>--ixx-prologue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the beginning
-        of the inline file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--cxx-prologue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the beginning
-        of the source file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--fwd-prologue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the beginning
-        of the forward declaration file (C++/Hybrid mapping only).
-    </dd>
-
-    <dt><code><b>--prologue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the beginning
-        of each generated file for which there is no file-specific prologue
-        file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <!-- epilogue file options -->
-
-    <dt><code><b>--hxx-epilogue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the end of the
-        header file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--ixx-epilogue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the end of the
-        inline file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--cxx-epilogue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the end of the
-        source file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-    <dt><code><b>--fwd-epilogue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the end of the
-      forward declaration file (C++/Hybrid mapping only).
-    </dd>
-
-    <dt><code><b>--epilogue-file</b> <i>file</i></code></dt>
-    <dd>Insert the content of the <code><i>file</i></code> at the end of each
-        generated file for which there is no file-specific epilogue file.
-        For the C++/Hybrid mapping, the <code><i>file</i></code> argument
-        can be optionally prefixed with a file key. See the
-        <code><b>--hxx-prologue-file</b></code> option for details.
-    </dd>
-
-
-    <dt><code><b>--disable-warning</b> <i>warn</i></code></dt>
-    <dd>Disable printing warning with id <i>warn</i>. If <code><b>all</b></code>
-        is specified for the warning id then all the warnings are disabled.
-    </dd>
-
-    <!-- misc options -->
-
-    <dt><code><b>--show-sloc</b></code></dt>
-    <dd>Show the number of generated physical source lines of code (SLOC).
-    </dd>
-
-    <dt><code><b>--sloc-limit</b> <i>num</i></code></dt>
-    <dd>Check that the number of generated physical source lines of code
-        (SLOC) does not exceed <code><i>num</i></code>.
-    </dd>
-
-    <dt><code><b>--options-file</b> <i>file</i></code></dt>
-    <dd>Read additional options from <code><i>file</i></code>. Each option
-        should appear on a separate line optionally followed by space and
-        an argument. Empty lines and lines starting with <code><b>#</b></code>
-        are ignored. The semantics of providing options in a
-        file is equivalent to providing the same set of options in
-        the same order in the command line at the point where the
-        <code><b>--options-file</b></code> option is specified
-        except that shell escaping and quoting is not required.
-        Repeat this option to specify more than one options files.
-    </dd>
-
-    <dt><code><b>--proprietary-license</b></code></dt>
-    <dd>Indicate that the generated code is licensed under a proprietary
-        license instead of the GPL.
-    </dd>
-
-    <!-- Anonymous options. -->
-
-    <dt><code><b>--preserve-anonymous</b></code></dt>
-    <dd>Preserve anonymous types. By default anonymous types are
-        automatically named with names derived from the enclosing
-        elements/attributes. Because mappings implemented by this
-        compiler require all types to be named, this option is only
-        useful if you want to make sure your schemas don't have
-        anonymous types.
-    </dd>
-
-    <dt><code><b>--show-anonymous</b></code></dt>
-    <dd>Show elements and attributes that are of anonymous types.
-        This option only makes sense together with the
-        <code><b>--preserve-anonymous</b></code> option.
-    </dd>
-
-    <dt><code><b>--anonymous-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to derive names for anonymous types from the enclosing
-      attributes/elements. <code><i>regex</i></code> is a perl-like regular
-      expression in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported.
-
-      <p>All the regular expressions are pushed into a stack with the last
-        specified expression considered first. The first match that
-        succeeds is used. Regular expressions are applied to a string
-        in the form</p>
-
-      <p><code><i>filename</i> <i>namespace</i> <i>xpath</i></code></p>
-
-      <p>For instance:</p>
-
-      <p><code><b>hello.xsd http://example.com/hello element</b></code></p>
-      <p><code><b>hello.xsd http://example.com/hello type/element</b></code></p>
-
-      <p>As an example, the following expression makes all the derived
-         names start with capital letters. This could be useful when
-         your naming convention requires type names to start with
-         capital letters:</p>
-
-      <p><code><b>%.* .* (.+/)*(.+)%\u$2%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--anonymous-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--anonymous-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <!-- Location mapping options. -->
-
-    <dt><code><b>--location-map</b> <i>ol</i><b>=</b><i>nl</i></code></dt>
-    <dd>Map the original schema location <i>ol</i> that is specified in
-        the XML Schema include or import elements to new schema
-        location <i>nl</i>. Repeat this option to map more than one
-        schema location. For example, the following option maps the
-        <code><b>http://example.com/foo.xsd</b></code> URL to the
-        <code><b>foo.xsd</b></code> local file.
-
-        <p><code><b>--location-map http://example.com/foo.xsd=foo.xsd</b></code></p>
-    </dd>
-
-    <dt><code><b>--location-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to map schema locations that are specified in the XML Schema
-      include or import elements. <code><i>regex</i></code> is a perl-like
-      regular expression in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported. All the regular
-      expressions are pushed into a stack with the last specified
-      expression considered first. The first match that succeeds is used.
-
-      <p>For example, the following expression maps URL locations in the form
-        <code><b>http://example.com/foo/bar.xsd</b></code> to local files
-        in the form <code><b>bar.xsd</b></code>:</p>
-
-      <p><code><b>%http://.+/(.+)%$1%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--location-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--location-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <!-- File-per-type compilation mode options. -->
-
-    <dt><code><b>--file-per-type</b></code></dt>
-    <dd>Generate a separate set of C++ files for each type defined in XML
-        Schema. Note that in this mode you only need to compile the root
-        schema(s) and the code will be generated for all included and
-        imported schemas. This compilation mode is primarily useful when
-        some of your schemas cannot be compiled separately or have cyclic
-        dependencies which involve type inheritance. Other options related
-        to this mode are:
-        <code><b>--type-file-regex</b></code>,
-        <code><b>--schema-file-regex</b></code>, and
-	<code><b>--file-list</b></code>.
-    </dd>
-
-
-    <dt><code><b>--type-file-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to translate type names to file names when the
-      <code><b>--file-per-type</b></code> option is specified.
-      <code><i>regex</i></code> is a perl-like regular expression in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported. All the regular
-      expressions are pushed into a stack with the last specified
-      expression considered first. The first match that succeeds is used.
-      Regular expressions are applied to a string in the form
-
-      <p><code><i>namespace</i> <i>type-name</i></code></p>
-
-      <p>For example, the following expression maps type <code><b>foo</b></code>
-         that is defined in the <code><b>http://example.com/bar</b></code>
-         namespace to file name <code><b>bar-foo</b></code>:</p>
-
-      <p><code><b>%http://example.com/(.+) (.+)%$1-$2%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--type-file-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--type-file-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <dt><code><b>--schema-file-regex</b> <i>regex</i></code></dt>
-    <dd>Add <code><i>regex</i></code> to the list of regular expressions
-      used to translate schema file names when the
-      <code><b>--file-per-type</b></code> option is specified.
-      <code><i>regex</i></code> is a perl-like regular expression in the form
-      <code><b>/</b><i>pattern</i><b>/</b><i>replacement</i><b>/</b></code>.
-      Any character can be used as a delimiter instead of <code><b>/</b></code>.
-      Escaping of the delimiter character in <code><i>pattern</i></code> or
-      <code><i>replacement</i></code> is not supported. All the regular
-      expressions are pushed into a stack with the last specified
-      expression considered first. The first match that succeeds is used.
-      Regular expressions are applied to the absolute filesystem path
-      of a schema file and the result, including the directory part,
-      if any, is used to derive the <code><b>#include</b></code> directive
-      paths as well as the generated C++ file paths. This option, along
-      with <code><b>--type-file-regex</b></code> are primarily used to
-      place the generated files into subdirectories or to resolve file
-      name conflicts.
-
-      <p>For example, the following expression maps schema files in the
-         <code><b>foo/1.0.0/</b></code> subdirectory to the files in
-         the <code><b>foo/</b></code> subdirectory. As a result, the
-         <code><b>#include</b></code> directive paths for such schemas
-         will be in the <code><b>foo/schema.hxx</b></code> form and
-         the generated C++ files will be placed into the
-         <code><b>foo/</b></code> subdirectory:</p>
-
-      <p><code><b>%.*/foo/1.0.0/(.+)%foo/$1%</b></code></p>
-
-      <p>See also the REGEX AND SHELL QUOTING section below.</p>
-    </dd>
-
-    <dt><code><b>--schema-file-regex-trace</b></code></dt>
-    <dd>Trace the process of applying regular expressions specified with
-        the <code><b>--schema-file-regex</b></code> option. Use this option
-        to find out why your regular expressions don't do what you expected
-        them to do.
-    </dd>
-
-    <dt><code><b>--fat-type-file</b></code></dt>
-    <dd>Generate code corresponding to global elements into type files
-        instead of schema files when the <code><b>--type-file-regex</b></code>
-        option is specified. This option is primarily useful when trying
-        to minimize the amount of object code that is linked to an executable
-        by packaging compiled generated code into a static (archive) library.
-    </dd>
-
-    <!-- File list options. -->
-
-    <dt><code><b>--file-list</b> <i>file</i></code></dt>
-    <dd>Write a list of generated C++ files to <code><i>file</i></code>.
-        This option is primarily useful in the file-per-type compilation
-        mode (<code><b>--file-per-type</b></code>) to create a list of
-        generated C++ files, for example, as a makefile fragment.
-    </dd>
-
-    <dt><code><b>--file-list-prologue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the beginning of the file list.
-        As a convenience, all occurrences of the \n character sequence in
-        <code><i>text</i></code> are replaced with new lines. This option
-        can, for example, be used to assign the generated file list to a
-        makefile variable.
-    </dd>
-
-    <dt><code><b>--file-list-epilogue</b> <i>text</i></code></dt>
-    <dd>Insert <code><i>text</i></code> at the end of the file list.
-        As a convenience, all occurrences of the \n character sequence in
-        <code><i>text</i></code> are replaced with new lines.
-    </dd>
-
-    <dt><code><b>--file-list-delim</b> <i>text</i></code></dt>
-    <dd>Delimit file names written to the file list with
-        <code><i>text</i></code>  instead of new lines. As a convenience,
-        all occurrences of the \n character sequence in
-        <code><i>text</i></code> are replaced with new lines.
-    </dd>
-
-  </dl>
-
-  <h2>CXX-HYBRID COMMAND OPTIONS</h2>
-
-  <dl class="options">
-    <dt><code><b>--generate-parser</b></code></dt>
-    <dd>Generate XML parsing code.</dd>
-
-    <dt><code><b>--generate-serializer</b></code></dt>
-    <dd>Generate XML serialization code.</dd>
-
-    <dt><code><b>--generate-aggregate</b></code></dt>
-    <dd>Generate parser/serializer aggregates for root elements and/or
-        types. See also the <code><b>--root-element-*</b></code> and
-        <code><b>--root-type</b></code> options.</dd>
-
-    <dt><code><b>--suppress-validation</b></code></dt>
-    <dd>Suppress the generation of validation code in parser and serializer.</dd>
-
-    <dt><code><b>--suppress-parser-val</b></code></dt>
-    <dd>Suppress the generation of validation code in parser.</dd>
-
-    <dt><code><b>--suppress-serializer-val</b></code></dt>
-    <dd>Suppress the generation of validation code in serializer.</dd>
-
-    <dt><code><b>--omit-default-attributes</b></code></dt>
-    <dd>Omit attributes with default and fixed values from serialized
-        XML documents.</dd>
-
-    <dt><code><b>--suppress-enum</b></code></dt>
-    <dd>Suppress the generation of the XML Schema enumeration to C++
-        enum mapping.</dd>
-
-    <dt><code><b>--generate-clone</b></code></dt>
-    <dd>Generate clone functions for variable-length types. These
-        functions allow you to make dynamically-allocated copies of
-        variable-length objects.</dd>
-
-    <dt><code><b>--generate-detach</b></code></dt>
-    <dd>Generate detach functions for elements and attributes of
-        variable-length types. These functions, for example, allow
-        you to move sub-trees in the object model either within the
-        same tree or between different trees.</dd>
-
-    <dt><code><b>--generate-insertion</b> <i>os</i></code></dt>
-    <dd>Generate data representation stream insertion operators for
-        the <code><i>os</i></code> output stream type. Repeat this
-        option to specify more than one stream type. The special
-        <code><b>CDR</b></code> and <code><b>XDR</b></code> arguments
-        are recognized as ACE CDR and Sun RPC XDR stream types and
-        the corresponding stream wrappers provided by the XSD/e runtime
-        are automatically used. For custom stream types use the
-        <code><b>--hxx-prologue*</b></code> options to include the
-        necessary declarations.</dd>
-
-    <dt><code><b>--generate-extraction</b> <i>is</i></code></dt>
-    <dd>Generate data representation stream extraction operators for
-        the <code><i>is</i></code> input stream type. Repeat this
-        option to specify more than one stream type. The special
-        <code><b>CDR</b></code> and <code><b>XDR</b></code> arguments
-        are recognized as ACE CDR and Sun RPC XDR stream types and
-        the corresponding stream wrappers provided by the XSD/e runtime
-        are automatically used. For custom stream types use the
-        <code><b>--hxx-prologue*</b></code> options to include the
-        necessary declarations.</dd>
-
-    <dt><code><b>--generate-forward</b></code></dt>
-    <dd>Generate forward declaration file.</dd>
-
-    <dt><code><b>--generate-xml-schema</b></code></dt>
-    <dd>Generate C++ header files as if the schema being compiled defines
-        the XML Schema namespace. In particular, the resulting files will
-        have definitions for all object model types, parser skeletons and
-        implementations, as well as serializer skeletons and implementations
-        corresponding to the XML Schema built-in types. The schema file
-        provided to the compiler need not exist and is only used to derive
-        the names of the resulting header files. Use the
-        <code><b>--extern-xml-schema</b></code> option to include these file
-        in the generated files for other schemas.</dd>
-
-    <dt><code><b>--extern-xml-schema</b> <i>file</i></code></dt>
-    <dd>Include header files derived from <i>file</i> instead of
-        generating the XML Schema namespace mapping inline. The provided
-        file need not exist and is only used to derive the names of the
-        included header files. Use the <code><b>--generate-xml-schema</b></code>
-        option to generate these header files.</dd>
-
-    <dt><code><b>--suppress-reset</b></code></dt>
-    <dd>Suppress the generation of parser and serializer reset code.
-        Reset support allows you to reuse parsers and serializers
-        after an error.</dd>
-
-    <dt><code><b>--generate-polymorphic</b></code></dt>
-    <dd>Generate polymorphism-aware code. Specify this option if you use
-        substitution groups or <code><b>xsi:type</b></code>. Use the
-        <code><b>--polymorphic-type</b></code> option to specify which
-        type hierarchies are polymorphic.</dd>
-
-    <dt><code><b>--runtime-polymorphic</b></code></dt>
-    <dd>Generate non-polymorphic code that uses the runtime library
-        configured with polymorphism support.</dd>
-
-    <dt><code><b>--polymorphic-type</b></code> <i>type</i></dt>
-    <dd>Indicate that <code><i>type</i></code> 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 <code><i>type</i></code>.</dd>
-
-    <dt><code><b>--generate-typeinfo</b></code></dt>
-    <dd>Generate custom type information querying functions for
-        polymorphic object model types. These functions can be used
-        instead of the standard C++ RTTI mechanism to determine
-        object's type at runtime.</dd>
-
-    <dt><code><b>--polymorphic-schema</b></code> <i>file</i></dt>
-    <dd>Indicate that <code><i>file</i></code> contains derivations of
-        polymorphic types that are not otherwise visible from the schema
-        being compiled. This option is used to make sure that during the
-        generation of parser and serializer aggregates the compiler is
-        aware of all possible derivations of polymorphic types. Repeat
-        this option to specify more than one schema file.</dd>
-
-    <dt><code><b>--reuse-style-mixin</b></code></dt>
-    <dd>Generate code that supports the mixin base parser/serializer
-        implementation reuse style. Note that this reuse style
-        relies on virtual inheritance and may result in a substantial
-        object code size increase for large vocabularies. By default
-        the tiein reuse style is used.</dd>
-
-    <dt><code><b>--custom-data</b></code> <i>type</i></dt>
-    <dd>Add the ability to store custom data to the C++ class generated
-        for XML Schema type <code><i>type</i></code>. To add custom
-        data to a nested compositor class use the qualified name
-        starting from the XML Schema type containing the compositor,
-        for example, <code><b>foo::sequence::choise1</b></code>.</dd>
-
-    <dt><code><b>--custom-type</b>
-    <i>name</i>[<b>=</b>[<i>flags</i>][<b>/</b>[<i>type</i>][<b>/</b>[<i>base</i>][<b>/</b><i>include</i>]]]]</code></dt>
-    <dd>Use a custom type implementation instead of the generated version.
-        The <code><i>name</i></code> component is the XML Schema type name
-        being customized. Optional <code><i>flags</i></code> allow you to
-        specify whether the custom type is fixed or variable-length. The
-        <code><b>f</b></code> flag indicates the type is fixed-length and
-        the <code><b>v</b></code> flag indicates the type is variable-length.
-        If omitted, the default rules are used to determine the type length.
-        Optional <code><i>type</i></code> is a C++ type name that should
-        be used instead. If specified, the object model type is defined
-        as a <code><b>typedef</b></code> alias for this C++ type. Optional
-        <code><i>base</i></code> is a C++ name that should be given to the
-        generated version. It is normally used as a base for the custom
-        implementation. Optional <code><i>include</i></code> is the header
-        file that defines the custom implementation. It is
-        <code><b>#include</b></code>'ed into the generated code immediately
-        after (if <code><i>base</i></code> is specified) or instead of the
-        generated version.</dd>
-
-    <dt><code><b>--custom-parser</b>
-    <i>name</i>[<b>=</b>[<i>base</i>][<b>/</b><i>include</i>]]</code></dt>
-    <dd>Use a custom parser implementation instead of the generated version.
-        The <code><i>name</i></code> component is the XML Schema type name
-        being customized. Optional <code><i>base</i></code> is a C++ name
-        that should be given to the generated version. It is normally used
-        as a base for the custom implementation. Optional
-        <code><i>include</i></code> is the header file that defines the
-        custom implementation. It is <code><b>#include</b></code>'ed
-        into the generated code immediately after (if <code><i>base</i></code>
-        is specified) or instead of the generated version.</dd>
-
-    <dt><code><b>--custom-serializer</b>
-    <i>name</i>[<b>=</b>[<i>base</i>][<b>/</b><i>include</i>]]</code></dt>
-    <dd>Use a custom serializer implementation instead of the generated version.
-        The <code><i>name</i></code> component is the XML Schema type name
-        being customized. Optional <code><i>base</i></code> is a C++ name
-        that should be given to the generated version. It is normally used
-        as a base for the custom implementation. Optional
-        <code><i>include</i></code> is the header file that defines the
-        custom implementation. It is <code><b>#include</b></code>'ed
-        into the generated code immediately after (if <code><i>base</i></code>
-        is specified) or instead of the generated version.</dd>
-
-    <!-- Root element/type. -->
-
-    <dt><code><b>--root-element-first</b></code></dt>
-    <dd>Treat only the first global element as a document root. This
-        determines for which elements parser and serializer aggregates
-        are generated. By default all global elements are considered
-        document roots. See also the <code><b>--generate-aggregate</b></code>
-        option.
-    </dd>
-
-    <dt><code><b>--root-element-last</b></code></dt>
-    <dd>Treat only the last global element as a document root. This
-        determines for which elements parser and serializer aggregates
-        are generated. By default all global elements are considered
-        document roots. See also the <code><b>--generate-aggregate</b></code>
-        option.
-    </dd>
-
-    <dt><code><b>--root-element-all</b></code></dt>
-    <dd>Treat all global elements as document roots (the default
-        behavior). This determines for which elements parser and
-        serializer aggregates are generated. By explicitly specifying
-        this option you can suppress the warning that is issued if
-        more than one global element is defined. See also the
-        <code><b>--generate-aggregate</b></code> option.
-    </dd>
-
-    <dt><code><b>--root-element-none</b></code></dt>
-    <dd>Do not treat any global elements as document roots. This
-        determines for which elements parser and serializer aggregates
-        are generated. By default all global elements are considered
-        document roots. See also the <code><b>--generate-aggregate</b></code>
-        option.
-    </dd>
-
-    <dt><code><b>--root-element</b> <i>element</i></code></dt>
-    <dd>Treat only <code><i>element</i></code> as a document root. This
-        determines for which elements parser and serializer aggregates
-        are generated. Repeat this option to specify more than one root
-        element. See also the <code><b>--generate-aggregate</b></code> option.
-    </dd>
-
-    <dt><code><b>--root-type</b> <i>type</i></code></dt>
-    <dd>Generate parser/serializer aggregate for <code><i>type</i></code>.
-        Repeat this option to specify more than one type. See also the
-        <code><b>--generate-aggregate</b></code> option.</dd>
-
-    <dt><code><b>--pskel-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_pskel</b></code> to construct the names of generated parser
-        skeletons.</dd>
-
-    <dt><code><b>--sskel-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_sskel</b></code> to construct the names of generated
-        serializer skeletons.</dd>
-
-    <dt><code><b>--pskel-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>-pskel</b></code> to construct the names of generated
-        parser skeleton files.</dd>
-
-    <dt><code><b>--sskel-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>-sskel</b></code> to construct the names of generated
-        serializer skeleton files.</dd>
-
-    <dt><code><b>--pimpl-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_pimpl</b></code> to construct the names of generated
-        parser implementations.</dd>
-
-    <dt><code><b>--simpl-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_simpl</b></code> to construct the names of generated
-        serializer implementations.</dd>
-
-    <dt><code><b>--pimpl-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>-pimpl</b></code> to construct the names of generated
-        parser implementation files.</dd>
-
-    <dt><code><b>--simpl-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>-simpl</b></code> to construct the names of generated
-        serializer implementation files.</dd>
-
-    <dt><code><b>--paggr-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_paggs</b></code> to construct the names of generated
-        parser aggregates.</dd>
-
-    <dt><code><b>--saggr-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use <code><i>suffix</i></code> instead of the default
-        <code><b>_saggr</b></code> to construct the names of generated
-        serializer aggregates.</dd>
-  </dl>
-
-  <h2>CXX-PARSER COMMAND OPTIONS</h2>
-
-  <dl class="options">
-    <dt><code><b>--type-map</b> <i>mapfile</i></code></dt>
-    <dd>Read XML Schema to C++ type mapping information from
-        <code><i>mapfile</i></code>. Repeat this option to specify
-        several type maps. Type maps are considered in order of
-        appearance and the first match is used. By default all
-        user-defined types are mapped to <code><b>void</b></code>.
-        See the TYPE MAP section below for more information.</dd>
-
-    <dt><code><b>--reuse-style-mixin</b></code></dt>
-    <dd>Generate code that supports the mixin base parser
-        implementation reuse style. Note that this reuse style
-        relies on virtual inheritance and may result in a substantial
-        object code size increase for large vocabularies. By default
-        support for the tiein style is generated.</dd>
-
-    <dt><code><b>--reuse-style-none</b></code></dt>
-    <dd>Do not generate any support for base parser implementation
-        reuse. By default support for the tiein style is generated.</dd>
-
-    <dt><code><b>--suppress-validation</b></code></dt>
-    <dd>Suppress the generation of validation code.</dd>
-
-    <dt><code><b>--generate-polymorphic</b></code></dt>
-    <dd>Generate polymorphism-aware code. Specify this option if you use
-        substitution groups or <code><b>xsi:type</b></code>.</dd>
-
-    <dt><code><b>--runtime-polymorphic</b></code></dt>
-    <dd>Generate non-polymorphic code that uses the runtime library
-        configured with polymorphism support.</dd>
-
-    <dt><code><b>--suppress-reset</b></code></dt>
-    <dd>Suppress the generation of parser reset code. Reset
-        support allows you to reuse parsers after an error.</dd>
-
-    <dt><code><b>--generate-noop-impl</b></code></dt>
-    <dd>Generate a sample parser implementation that does nothing (no
-        operation). The sample implementation can then be filled with
-        the application-specific code. For an input file in the form
-        <code><b>name.xsd</b></code> this option triggers the generation
-        of the two additional C++ files in the form:
-        <code><b>name-pimpl.hxx</b></code> (parser implementation header
-        file) and <code><b>name-pimpl.cxx</b></code> (parser implementation
-        source file).</dd>
-
-    <dt><code><b>--generate-print-impl</b></code></dt>
-    <dd>Generate a sample parser implementation that prints the XML data
-        to STDOUT. For an input file in the form <code><b>name.xsd</b></code>
-        this option triggers the generation of the two additional C++ files
-        in the form: <code><b>name-pimpl.hxx</b></code> (parser implementation
-        header file) and <code><b>name-pimpl.cxx</b></code> (parser
-        implementation source file).</dd>
-
-    <dt><code><b>--generate-test-driver</b></code></dt>
-    <dd>Generate a test driver for the sample parser implementation. For an
-        input file in the form <code><b>name.xsd</b></code> this option
-        triggers the generation of an additional C++ file in the form
-        <code><b>name-pdriver.cxx</b></code>.</dd>
-
-    <dt><code><b>--force-overwrite</b></code></dt>
-    <dd>Force overwriting of the existing implementation and test driver
-        files. Use this option only if you do not mind loosing the changes
-        you have made in the sample implementation or test driver files.</dd>
-
-    <dt><code><b>--root-element-first</b></code></dt>
-    <dd>Indicate that the first global element is the document root. This
-        information is used to generate the test driver for the sample
-        implementation.</dd>
-
-    <dt><code><b>--root-element-last</b></code></dt>
-    <dd>Indicate that the last global element is the document root. This
-        information is used to generate the test driver for the sample
-        implementation.</dd>
-
-    <dt><code><b>--root-element <i>element</i></b></code></dt>
-    <dd>Indicate that <code><i>element</i></code> is the document root.
-        This information is used to generate the test driver for the
-        sample implementation.</dd>
-
-    <dt><code><b>--generate-xml-schema</b></code></dt>
-    <dd>Generate a C++ header file as if the schema being compiled defines
-        the XML Schema namespace. In particular, the resulting file will
-        have definitions for all parser skeletons and implementations
-        corresponding to the XML Schema built-in types. The schema file
-        provided to the compiler need not exist and is only used to derive
-        the name of the resulting header file. Use the
-        <code><b>--extern-xml-schema</b></code> option to include this file
-        in the generated files for other schemas.</dd>
-
-    <dt><code><b>--extern-xml-schema</b> <i>file</i></code></dt>
-    <dd>Include a header file derived from <i>file</i> instead of
-        generating the XML Schema namespace mapping inline. The provided
-        file need not exist and is only used to derive the name of the
-        included header file. Use the <code><b>--generate-xml-schema</b></code>
-        option to generate this header file.</dd>
-
-    <dt><code><b>--skel-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>_pskel</b></code> to construct the names
-        of generated parser skeletons.</dd>
-
-    <dt><code><b>--skel-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>-pskel</b></code> to construct the names of
-        generated parser skeleton files.</dd>
-
-    <dt><code><b>--impl-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>_pimpl</b></code> to construct the names of
-        parser implementations for the built-in XML Schema types
-        and sample parser implementations.</dd>
-
-    <dt><code><b>--impl-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>-pimpl</b></code> to construct the names of
-        generated sample parser implementation files.</dd>
-  </dl>
-
-  <h2>CXX-SERIALIZER COMMAND OPTIONS</h2>
-
-  <dl class="options">
-    <dt><code><b>--type-map</b> <i>mapfile</i></code></dt>
-    <dd>Read XML Schema to C++ type mapping information from
-        <code><i>mapfile</i></code>. Repeat this option to specify
-        several type maps. Type maps are considered in order of
-        appearance and the first match is used. By default all
-        user-defined types are mapped to <code><b>void</b></code>.
-        See the TYPE MAP section below for more information.</dd>
-
-    <dt><code><b>--reuse-style-mixin</b></code></dt>
-    <dd>Generate code that supports the mixin base serializer
-        implementation reuse style. Note that this reuse style
-        relies on virtual inheritance and may result in a substantial
-        object code size increase for large vocabularies. By default
-        support for the tiein style is generated.</dd>
-
-    <dt><code><b>--reuse-style-none</b></code></dt>
-    <dd>Do not generate any support for base serializer implementation
-        reuse. By default support for the tiein style is generated.</dd>
-
-    <dt><code><b>--suppress-validation</b></code></dt>
-    <dd>Suppress the generation of validation code.</dd>
-
-    <dt><code><b>--generate-polymorphic</b></code></dt>
-    <dd>Generate polymorphism-aware code. Specify this option if you use
-        substitution groups or <code><b>xsi:type</b></code>.</dd>
-
-    <dt><code><b>--runtime-polymorphic</b></code></dt>
-    <dd>Generate non-polymorphic code that uses the runtime library
-        configured with polymorphism support.</dd>
-
-    <dt><code><b>--suppress-reset</b></code></dt>
-    <dd>Suppress the generation of serializer reset code. Reset
-        support allows you to reuse serializers after an error.</dd>
-
-    <dt><code><b>--generate-empty-impl</b></code></dt>
-    <dd>Generate a sample serializer implementation with empty function
-        bodies which can then be filled with the application-specific code.
-        For an input file in the form <code><b>name.xsd</b></code> this
-        option triggers the generation of the two additional C++ files in the
-        form: <code><b>name-simpl.hxx</b></code> (serializer implementation
-        header file) and <code><b>name-simpl.cxx</b></code> (serializer
-        implementation source file).</dd>
-
-    <dt><code><b>--generate-test-driver</b></code></dt>
-    <dd>Generate a test driver for the sample serializer implementation. For
-        an input file in the form <code><b>name.xsd</b></code> this option
-        triggers the generation of an additional C++ file in the form
-        <code><b>name-sdriver.cxx</b></code>.</dd>
-
-    <dt><code><b>--force-overwrite</b></code></dt>
-    <dd>Force overwriting of the existing implementation and test driver
-        files. Use this option only if you do not mind loosing the changes
-        you have made in the sample implementation or test driver files.</dd>
-
-    <dt><code><b>--root-element-first</b></code></dt>
-    <dd>Indicate that the first global element is the document root. This
-        information is used to generate the test driver for the sample
-        implementation.</dd>
-
-    <dt><code><b>--root-element-last</b></code></dt>
-    <dd>Indicate that the last global element is the document root. This
-        information is used to generate the test driver for the sample
-        implementation.</dd>
-
-    <dt><code><b>--root-element <i>element</i></b></code></dt>
-    <dd>Indicate that <code><i>element</i></code> is the document root.
-        This information is used to generate the test driver for the
-        sample implementation.</dd>
-
-    <dt><code><b>--generate-xml-schema</b></code></dt>
-    <dd>Generate a C++ header file as if the schema being compiled defines
-        the XML Schema namespace. In particular, the resulting file will
-        have definitions for all serializer skeletons and implementations
-        corresponding to the XML Schema built-in types. The schema file
-        provided to the compiler need not exist and is only used to derive
-        the name of the resulting header file. Use the
-        <code><b>--extern-xml-schema</b></code> option to include this file
-        in the generated files for other schemas.</dd>
-
-    <dt><code><b>--extern-xml-schema</b> <i>file</i></code></dt>
-    <dd>Include a header file derived from <i>file</i> instead of
-        generating the XML Schema namespace mapping inline. The provided
-        file need not exist and is only used to derive the name of the
-        included header file. Use the <code><b>--generate-xml-schema</b></code>
-        option to generate this header file.</dd>
-
-    <dt><code><b>--skel-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>_sskel</b></code> to construct the names
-        of generated serializer skeletons.</dd>
-
-    <dt><code><b>--skel-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>-sskel</b></code> to construct the names of
-        generated serializer skeleton files.</dd>
-
-    <dt><code><b>--impl-type-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>_simpl</b></code> to construct the names of
-        serializer implementations for the built-in XML Schema types
-        and sample serializer implementations.</dd>
-
-    <dt><code><b>--impl-file-suffix</b> <i>suffix</i></code></dt>
-    <dd>Use the provided <code><i>suffix</i></code> instead of the
-        default <code><b>-simpl</b></code> to construct the names of
-        generated sample serializer implementation files.</dd>
-  </dl>
-
-
-  <h1>TYPE MAP</h1>
-
-  <p>Type map files are used to define a mapping between XML Schema
-     and C++ types. For C++/Parser, the compiler uses
-     this information to determine the return types of
-     <code><b>post_*</b></code> functions in parser skeletons
-     corresponding to XML Schema types as well as argument types
-     for callbacks corresponding to elements and attributes of these
-     types. For C++/Serializer, type maps are used to determine
-     the argument type of <code><b>pre</b></code> functions in
-     serializer skeletons corresponding to XML Schema types as
-     well as return types for callbacks corresponding to elements
-     and attributes of these types.</p>
-
-  <p>The compiler has a set of predefined mapping rules that map
-     the built-in XML Schema types to suitable C++ types (discussed
-     in the following sub-sections) and all other types to
-     <code><b>void</b></code>. By providing your own type maps you
-     can override these predefined rules. The format of the type map
-     file is presented below:
-  </p>
-
-  <pre>
-namespace &lt;schema-namespace> [&lt;cxx-namespace>]
-{
-  (include &lt;file-name>;)*
-  ([type] &lt;schema-type> &lt;cxx-ret-type> [&lt;cxx-arg-type>];)*
-}
-  </pre>
-
-  <p>Both <code><i>&lt;schema-namespace></i></code> and
-     <code><i>&lt;schema-type></i></code> are regex patterns while
-     <code><i>&lt;cxx-namespace></i></code>,
-     <code><i>&lt;cxx-ret-type></i></code>, and
-     <code><i>&lt;cxx-arg-type></i></code> are regex pattern
-     substitutions. All names can be optionally enclosed in
-     <code><b>"&nbsp;"</b></code>, for example, to include white-spaces.</p>
-
-  <p><code><i>&lt;schema-namespace></i></code> determines XML
-     Schema namespace. Optional <code><i>&lt;cxx-namespace></i></code>
-     is prefixed to every C++ type name in this namespace declaration.
-     <code><i>&lt;cxx-ret-type></i></code> is a C++ type name that is
-     used as a return type for the <code><b>post_*</b></code> function
-     in C++/Parser or for element/attribute callbacks in C++/Serializer.
-     Optional <code><i>&lt;cxx-arg-type></i></code> is an argument type
-     for element/attribute callbacks in C++/Parser or for the
-     <code><b>pre</b></code> function in C++/Serializer. If
-     <code><i>&lt;cxx-arg-type></i></code> is not specified, it defaults
-     to <code><i>&lt;cxx-ret-type></i></code> if <code><i>&lt;cxx-ret-type></i></code>
-     ends with <code><b>*</b></code> or <code><b>&amp;</b></code> (that is,
-     it is a pointer or a reference) and
-     <code><b>const</b>&nbsp;<i>&lt;cxx-ret-type></i><b>&amp;</b></code>
-     otherwise.
-     <code><i>&lt;file-name></i></code> is a file name either in the
-     <code><b>"&nbsp;"</b></code> or <code><b>&lt;&nbsp;></b></code> format
-     and is added with the <code><b>#include</b></code> directive to
-     the generated code.</p>
-
-  <p>The <code><b>#</b></code> character starts a comment that ends
-     with a new line or end of file. To specify a name that contains
-     <code><b>#</b></code> enclose it in <code><b>"&nbsp;"</b></code>.
-     For example:</p>
-
-  <pre>
-namespace http://www.example.com/xmlns/my my
-{
-  include "my.hxx";
-
-  # Pass apples by value.
-  #
-  apple apple;
-
-  # Pass oranges as pointers.
-  #
-  orange orange_t*;
-}
-  </pre>
-
-  <p>In the example above, for the
-     <code><b>http://www.example.com/xmlns/my#orange</b></code>
-     XML Schema type, the <code><b>my::orange_t*</b></code> C++ type will
-     be used as both return and argument types.</p>
-
-  <p>Several namespace declarations can be specified in a single
-     file. The namespace declaration can also be completely
-     omitted to map types in a schema without a namespace. For
-     instance:</p>
-
-  <pre>
-include "my.hxx";
-apple apple;
-
-namespace http://www.example.com/xmlns/my
-{
-  orange "const orange_t*";
-}
-  </pre>
-
-  <p>The compiler has a number of predefined mapping rules
-     for the built-in XML Schema types that vary depending on
-     the mapping used. They are described in the following
-     subsections. The last predefined rule for all the mappings
-     maps anything that wasn't mapped by previous rules to
-     <code><b>void</b></code>:</p>
-
-  <pre>
-namespace .*
-{
-  .* void void;
-}
-  </pre>
-
-  <p>When you provide your own type maps with the
-     <code><b>--type-map</b></code> option, they are evaluated first.
-     This allows you to selectively override predefined rules.</p>
-
-
-  <h2>Predefined C++/Parser Type Maps</h2>
-
-  <p>The C++/Parser mapping provides a number of predefined type
-     map rules for the built-in XML Schema types. They can be
-     presented as the following map files:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  boolean bool bool;
-
-  byte "signed char" "signed char";
-  unsignedByte "unsigned char" "unsigned char";
-
-  short short short;
-  unsignedShort "unsigned short" "unsigned short";
-
-  int int int;
-  unsignedInt "unsigned int" "unsigned int";
-
-  long "long long" "long long";
-  unsignedLong "unsigned long long" "unsigned long long";
-
-  integer long long;
-
-  negativeInteger long long;
-  nonPositiveInteger long long;
-
-  positiveInteger "unsigned long" "unsigned long";
-  nonNegativeInteger "unsigned long" "unsigned long";
-
-  float float float;
-  double double double;
-  decimal double double;
-
-  NMTOKENS xml_schema::string_sequence*;
-  IDREFS xml_schema::string_sequence*;
-
-  base64Binary xml_schema::buffer*;
-  hexBinary xml_schema::buffer*;
-
-  date xml_schema::date;
-  dateTime xml_schema::date_time;
-  duration xml_schema::duration;
-  gDay xml_schema::gday;
-  gMonth xml_schema::gmonth;
-  gMonthDay xml_schema::gmonth_day;
-  gYear xml_schema::gyear;
-  gYearMonth xml_schema::gyear_month;
-  time xml_schema::time;
-}
-  </pre>
-
-  <p>If the <code><b>--no-stl</b></code> option is not specified,
-     the following mapping is used for the string-based XML Schema
-     built-in types:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  include &lt;string>;
-
-  string std::string;
-  normalizedString std::string;
-  token std::string;
-  Name std::string;
-  NMTOKEN std::string;
-  NCName std::string;
-  ID std::string;
-  IDREF std::string;
-  language std::string;
-  anyURI std::string;
-
-  QName xml_schema::qname;
-}
-  </pre>
-
-  <p>Otherwise, a C string-based mapping is used:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  string char*;
-  normalizedString char*;
-  token char*;
-  Name char*;
-  NMTOKEN char*;
-  NCName char*;
-  ID char*;
-  IDREF char*;
-  language char*;
-  anyURI char*;
-
-  QName xml_schema::qname*;
-}
-  </pre>
-
-  <h2>Predefined C++/Serializer Type Maps</h2>
-
-  <p>The C++/Serializer mapping provides a number of predefined type
-     map rules for the built-in XML Schema types. They can be
-     presented as the following map files:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  boolean bool bool;
-
-  byte "signed char" "signed char";
-  unsignedByte "unsigned char" "unsigned char";
-
-  short short short;
-  unsignedShort "unsigned short" "unsigned short";
-
-  int int int;
-  unsignedInt "unsigned int" "unsigned int";
-
-  long "long long" "long long";
-  unsignedLong "unsigned long long" "unsigned long long";
-
-  integer long long;
-
-  negativeInteger long long;
-  nonPositiveInteger long long;
-
-  positiveInteger "unsigned long" "unsigned long";
-  nonNegativeInteger "unsigned long" "unsigned long";
-
-  float float float;
-  double double double;
-  decimal double double;
-
-  NMTOKENS "const xml_schema::string_sequence*";
-  IDREFS "const xml_schema::string_sequence*";
-
-  base64Binary "const xml_schema::buffer*";
-  hexBinary "const xml_schema::buffer*";
-
-  date xml_schema::date;
-  dateTime xml_schema::date_time;
-  duration xml_schema::duration;
-  gDay xml_schema::gday;
-  gMonth xml_schema::gmonth;
-  gMonthDay xml_schema::gmonth_day;
-  gYear xml_schema::gyear;
-  gYearMonth xml_schema::gyear_month;
-  time xml_schema::time;
-}
-  </pre>
-
-  <p>If the <code><b>--no-stl</b></code> option is not specified,
-     the following mapping is used for the string-based XML Schema
-     built-in types:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  include &lt;string>;
-
-  string std::string;
-  normalizedString std::string;
-  token std::string;
-  Name std::string;
-  NMTOKEN std::string;
-  NCName std::string;
-  ID std::string;
-  IDREF std::string;
-  language std::string;
-  anyURI std::string;
-
-  QName xml_schema::qname;
-}
-  </pre>
-
-  <p>Otherwise, a C string-based mapping is used:</p>
-
-  <pre>
-namespace http://www.w3.org/2001/XMLSchema
-{
-  string "const char*";
-  normalizedString "const char*";
-  token "const char*";
-  Name "const char*";
-  NMTOKEN "const char*";
-  NCName "const char*";
-  ID "const char*";
-  IDREF "const char*";
-  language "const char*";
-  anyURI "const char*";
-
-  QName "const xml_schema::qname*";
-}
-  </pre>
-
-  <h1>REGEX AND SHELL QUOTING</h1>
-
-  <p>When entering a regular expression argument in the shell
-     command line it is often necessary to use quoting (enclosing
-     the argument in <code><b>"&nbsp;"</b></code> or
-     <code><b>'&nbsp;'</b></code>) in order to prevent the shell
-     from interpreting certain characters, for example, spaces as
-     argument separators and <code><b>$</b></code> as variable
-     expansions.</p>
-
-  <p>Unfortunately it is hard to achieve this in a manner that is
-     portable across POSIX shells, such as those found on
-     GNU/Linux and UNIX, and Windows shell. For example, if you
-     use <code><b>"&nbsp;"</b></code> for quoting you will get a
-     wrong result with POSIX shells if your expression contains
-     <code><b>$</b></code>. The standard way of dealing with this
-     on POSIX systems is to use <code><b>'&nbsp;'</b></code> instead.
-     Unfortunately, Windows shell does not remove <code><b>'&nbsp;'</b></code>
-     from arguments when they are passed to applications. As a result you
-     may have to use <code><b>'&nbsp;'</b></code> for POSIX and
-     <code><b>"&nbsp;"</b></code> for Windows (<code><b>$</b></code> is
-     not treated as a special character on Windows).</p>
-
-  <p>Alternatively, you can save regular expression options into
-     a file, one option per line, and use this file with the
-     <code><b>--options-file</b></code> option. With this approach
-     you don't need to worry about shell quoting.</p>
-
-  <h1>DIAGNOSTICS</h1>
-
-  <p>If the input file is not a valid W3C XML Schema definition,
-    <code><b>xsde</b></code> will issue diagnostic messages to STDERR
-    and exit with non-zero exit code.</p>
-
-  <h1>BUGS</h1>
-
-  <p>Send bug reports to the
-     <a href="mailto:xsde-users@codesynthesis.com">xsde-users@codesynthesis.com</a> mailing list.</p>
-
-  </div>
-  <div id="footer">
-    &copy;2005-2011 <a href="http://codesynthesis.com">CODE SYNTHESIS TOOLS CC</a>
-
-    <div id="terms">
-      Permission is granted to copy, distribute and/or modify this
-      document under the terms of the
-      <a href="http://codesynthesis.com/licenses/fdl-1.2.txt">GNU Free
-      Documentation License, version 1.2</a>; with no Invariant Sections,
-      no Front-Cover Texts and no Back-Cover Texts.
-    </div>
-  </div>
-</div>
-</body>
-</html>