aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--build/import/cli/LICENSE21
-rw-r--r--build/import/cli/cli-cxx.make48
-rw-r--r--build/import/cli/configuration-rules.make14
-rwxr-xr-xbuild/import/cli/configure54
-rw-r--r--build/import/cli/stub.make29
-rw-r--r--build/import/libbackend-elements/LICENSE340
-rw-r--r--build/import/libbackend-elements/configuration-rules.make15
-rwxr-xr-xbuild/import/libbackend-elements/configure55
-rw-r--r--build/import/libbackend-elements/stub.make32
-rw-r--r--documentation/makefile115
-rw-r--r--documentation/xsd-epilogue.1561
-rw-r--r--documentation/xsd-epilogue.xhtml417
-rw-r--r--documentation/xsd-parser-header.14
-rw-r--r--documentation/xsd-parser-header.xhtml1
-rw-r--r--documentation/xsd-prologue.1119
-rw-r--r--documentation/xsd-prologue.xhtml120
-rw-r--r--documentation/xsd-tree-header.14
-rw-r--r--documentation/xsd-tree-header.xhtml1
-rw-r--r--documentation/xsd.11906
-rw-r--r--documentation/xsd.xhtml1613
-rw-r--r--xsd/cxx/options.cli463
-rw-r--r--xsd/cxx/parser/generator.cxx337
-rw-r--r--xsd/cxx/parser/options.cli157
-rw-r--r--xsd/cxx/tree/generator.cxx537
-rw-r--r--xsd/cxx/tree/options.cli415
-rw-r--r--xsd/makefile62
-rw-r--r--xsd/options.cli315
-rw-r--r--xsd/usage.hxx226
-rw-r--r--xsd/xsd.cxx117
29 files changed, 2909 insertions, 5189 deletions
diff --git a/build/import/cli/LICENSE b/build/import/cli/LICENSE
new file mode 100644
index 0000000..57ee246
--- /dev/null
+++ b/build/import/cli/LICENSE
@@ -0,0 +1,21 @@
+Copyright (c) 2009-2012 Code Synthesis Tools CC.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/build/import/cli/cli-cxx.make b/build/import/cli/cli-cxx.make
new file mode 100644
index 0000000..cd009d9
--- /dev/null
+++ b/build/import/cli/cli-cxx.make
@@ -0,0 +1,48 @@
+# file : build/import/cli/cli-cxx.make
+# copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+# license : MIT; see accompanying LICENSE file
+
+# Here we are operating in the importing project's space, not in
+# cli's.
+#
+
+# Get the C++ file extensions.
+#
+$(call include,$(bld_root)/cxx/configuration-static.make)
+
+cli_pattern := \
+$(out_base)/%.$(cxx_s_suffix) \
+$(out_base)/%.$(cxx_h_suffix) \
+$(out_base)/%.$(cxx_i_suffix)
+
+$(cli_pattern): cli_options := \
+--hxx-suffix .$(cxx_h_suffix) \
+--ixx-suffix .$(cxx_i_suffix) \
+--cxx-suffix .$(cxx_s_suffix)
+
+.PRECIOUS: $(cli_pattern)
+
+ifeq ($(out_base),$(src_base))
+
+$(cli_pattern): $(src_base)/%.cli
+ $(call message,cli $<,$(cli) $(cli_options) --output-dir $(dir $@) $<)
+
+else
+
+$(cli_pattern): $(src_base)/%.cli | $$(dir $$@).
+ $(call message,cli $<,$(cli) $(cli_options) --output-dir $(dir $@) $<)
+
+$(cli_pattern): $(out_base)/%.cli | $$(dir $$@).
+ $(call message,cli $<,$(cli) $(cli_options) --output-dir $(dir $@) $<)
+endif
+
+.PHONY: $(out_base)/%.cxx.cli.clean
+
+$(out_base)/%.cxx.cli.clean: cxx_s_suffix := $(cxx_s_suffix)
+$(out_base)/%.cxx.cli.clean: cxx_h_suffix := $(cxx_h_suffix)
+$(out_base)/%.cxx.cli.clean: cxx_i_suffix := $(cxx_i_suffix)
+
+$(out_base)/%.cxx.cli.clean:
+ $(call message,rm $$1,rm -f $$1,$(@:.cxx.cli.clean=.$(cxx_s_suffix)))
+ $(call message,rm $$1,rm -f $$1,$(@:.cxx.cli.clean=.$(cxx_h_suffix)))
+ $(call message,rm $$1,rm -f $$1,$(@:.cxx.cli.clean=.$(cxx_i_suffix)))
diff --git a/build/import/cli/configuration-rules.make b/build/import/cli/configuration-rules.make
new file mode 100644
index 0000000..5fb2485
--- /dev/null
+++ b/build/import/cli/configuration-rules.make
@@ -0,0 +1,14 @@
+# file : build/import/cli/configuration-rules.make
+# copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+# license : MIT; see accompanying LICENSE file
+
+$(dcf_root)/import/cli/configuration-dynamic.make: | $(dcf_root)/import/cli/.
+ $(call message,,$(scf_root)/import/cli/configure $@)
+
+ifndef %foreign%
+
+$(dcf_root)/.disfigure::
+ $(call message,rm $(dcf_root)/import/cli/configuration-dynamic.make,\
+rm -f $(dcf_root)/import/cli/configuration-dynamic.make)
+
+endif
diff --git a/build/import/cli/configure b/build/import/cli/configure
new file mode 100755
index 0000000..ae1e512
--- /dev/null
+++ b/build/import/cli/configure
@@ -0,0 +1,54 @@
+#! /usr/bin/env bash
+
+# file : build/import/cli/configure
+# copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+# license : MIT; see accompanying LICENSE file
+
+
+# $1 - out file
+#
+# bld_root - build root
+# project_name - project name
+#
+
+source $bld_root/dialog.bash
+
+
+$echo
+$echo "Configuring external dependency on 'cli' for '$project_name'."
+$echo
+
+$echo
+$echo "Would you like to configure dependency on the installed "
+$echo "version of 'cli' as opposed to the development build?"
+$echo
+
+installed=`read_y_n y`
+
+path=
+
+if [ "$installed" = "n" ]; then
+
+$echo
+$echo "Please enter the src_root for 'cli'."
+$echo
+
+src_root=`read_path --directory --exist`
+
+$echo
+$echo "Please enter the out_root for 'cli'."
+$eche
+
+out_root=`read_path --directory $src_root`
+
+fi
+
+echo cli_installed := $installed >$1
+
+if [ "$installed" = "n" ]; then
+
+echo src_root := $src_root >>$1
+echo scf_root := \$\(src_root\)/build >>$1
+echo out_root := $out_root >>$1
+
+fi
diff --git a/build/import/cli/stub.make b/build/import/cli/stub.make
new file mode 100644
index 0000000..3704723
--- /dev/null
+++ b/build/import/cli/stub.make
@@ -0,0 +1,29 @@
+# file : build/import/cli/stub.make
+# copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
+# license : MIT; see accompanying LICENSE file
+
+$(call include-once,$(scf_root)/import/cli/configuration-rules.make,$(dcf_root))
+
+cli_installed :=
+
+$(call -include,$(dcf_root)/import/cli/configuration-dynamic.make)
+
+ifdef cli_installed
+
+ifeq ($(cli_installed),y)
+
+$(call export,cli: cli,cli-rules: $(scf_root)/import/cli/cli-cxx.make)
+
+else
+
+# Include export stub.
+#
+$(call include,$(scf_root)/export/cli/stub.make)
+
+endif
+
+else
+
+.NOTPARALLEL:
+
+endif
diff --git a/build/import/libbackend-elements/LICENSE b/build/import/libbackend-elements/LICENSE
deleted file mode 100644
index 3912109..0000000
--- a/build/import/libbackend-elements/LICENSE
+++ /dev/null
@@ -1,340 +0,0 @@
- GNU GENERAL PUBLIC LICENSE
- Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
- 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users. This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it. (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.) You can apply it to
-your programs, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
- For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have. You must make sure that they, too, receive or can get the
-source code. And you must show them these terms so they know their
-rights.
-
- We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
- Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software. If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary. To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
- The precise terms and conditions for copying, distribution and
-modification follow.
-
- GNU GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License. The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language. (Hereinafter, translation is included without limitation in
-the term "modification".) Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
- 1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
- 2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) You must cause the modified files to carry prominent notices
- stating that you changed the files and the date of any change.
-
- b) You must cause any work that you distribute or publish, that in
- whole or in part contains or is derived from the Program or any
- part thereof, to be licensed as a whole at no charge to all third
- parties under the terms of this License.
-
- c) If the modified program normally reads commands interactively
- when run, you must cause it, when started running for such
- interactive use in the most ordinary way, to print or display an
- announcement including an appropriate copyright notice and a
- notice that there is no warranty (or else, saying that you provide
- a warranty) and that users may redistribute the program under
- these conditions, and telling the user how to view a copy of this
- License. (Exception: if the Program itself is interactive but
- does not normally print such an announcement, your work based on
- the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
- a) Accompany it with the complete corresponding machine-readable
- source code, which must be distributed under the terms of Sections
- 1 and 2 above on a medium customarily used for software interchange; or,
-
- b) Accompany it with a written offer, valid for at least three
- years, to give any third party, for a charge no more than your
- cost of physically performing source distribution, a complete
- machine-readable copy of the corresponding source code, to be
- distributed under the terms of Sections 1 and 2 above on a medium
- customarily used for software interchange; or,
-
- c) Accompany it with the information you received as to the offer
- to distribute corresponding source code. (This alternative is
- allowed only for noncommercial distribution and only if you
- received the program in object code or executable form with such
- an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it. For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable. However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License. Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
- 5. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Program or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
- 6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
- 7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License. If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all. For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded. In such case, this License incorporates
-the limitation as if written in the body of this License.
-
- 9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time. Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number. If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation. If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
- 10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission. For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this. Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
- NO WARRANTY
-
- 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
- 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
- END OF TERMS AND CONDITIONS
-
- How to Apply These Terms to Your New Programs
-
- If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
- To do so, attach the following notices to the program. It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
- <one line to give the program's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
- Gnomovision version 69, Copyright (C) year name of author
- Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
- This is free software, and you are welcome to redistribute it
- under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License. Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the program
- `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
- <signature of Ty Coon>, 1 April 1989
- Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs. If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library. If this is what you want to do, use the GNU Library General
-Public License instead of this License.
diff --git a/build/import/libbackend-elements/configuration-rules.make b/build/import/libbackend-elements/configuration-rules.make
deleted file mode 100644
index 1766f03..0000000
--- a/build/import/libbackend-elements/configuration-rules.make
+++ /dev/null
@@ -1,15 +0,0 @@
-# file : build/import/libbackend-elements/configuration-rules.make
-# author : Boris Kolpackov <boris@kolpackov.net>
-# copyright : Copyright (c) 2005-2009 Boris Kolpackov
-# license : GNU GPL v2; see accompanying LICENSE file
-
-$(dcf_root)/import/libbackend-elements/configuration-dynamic.make: | $(dcf_root)/import/libbackend-elements/.
- $(call message,,$(scf_root)/import/libbackend-elements/configure $@)
-
-ifndef %foreign%
-
-disfigure::
- $(call message,rm $(dcf_root)/import/libbackend-elements/configuration-dynamic.make,\
-rm -f $(dcf_root)/import/libbackend-elements/configuration-dynamic.make)
-
-endif
diff --git a/build/import/libbackend-elements/configure b/build/import/libbackend-elements/configure
deleted file mode 100755
index db3e44d..0000000
--- a/build/import/libbackend-elements/configure
+++ /dev/null
@@ -1,55 +0,0 @@
-#! /usr/bin/env bash
-
-# file : build/import/libbackend-elements/configure
-# author : Boris Kolpackov <boris@kolpackov.net>
-# copyright : Copyright (c) 2005-2009 Boris Kolpackov
-# license : GNU GPL v2; see accompanying LICENSE file
-
-
-# $1 - out file
-#
-# bld_root - build root
-# project_name - project name
-#
-
-source $bld_root/dialog.bash
-
-
-$echo
-$echo "Configuring external dependency on 'libbackend-elements' for '$project_name'."
-$echo
-
-$echo
-$echo "Would you like to configure dependency on the installed version"
-$echo "of 'libbackend-elements' as opposed to the development build?"
-$echo
-
-installed=`read_y_n y`
-
-path=
-
-if [ "$installed" = "n" ]; then
-
-$echo
-$echo "Please enter the src_root for 'libbackend-elements'."
-$echo
-
-src_root=`read_path --directory --exist`
-
-$echo
-$echo "Please enter the out_root for 'libbackend-elements'."
-$echo
-
-out_root=`read_path --directory $src_root`
-
-fi
-
-echo libbackend_elements_installed := $installed >$1
-
-if [ "$installed" = "n" ]; then
-
-echo src_root := $src_root >>$1
-echo scf_root := \$\(src_root\)/build >>$1
-echo out_root := $out_root >>$1
-
-fi
diff --git a/build/import/libbackend-elements/stub.make b/build/import/libbackend-elements/stub.make
deleted file mode 100644
index b171c30..0000000
--- a/build/import/libbackend-elements/stub.make
+++ /dev/null
@@ -1,32 +0,0 @@
-# file : build/import/libbackend-elements/stub.make
-# author : Boris Kolpackov <boris@kolpackov.net>
-# copyright : Copyright (c) 2005-2009 Boris Kolpackov
-# license : GNU GPL v2; see accompanying LICENSE file
-
-$(call include-once,$(scf_root)/import/libbackend-elements/configuration-rules.make,$(dcf_root))
-
-libbackend_elements_installed :=
-
-$(call -include,$(dcf_root)/import/libbackend-elements/configuration-dynamic.make)
-
-ifdef libbackend_elements_installed
-
-ifeq ($(libbackend_elements_installed),y)
-
-#-lbackend-elements
-
-$(call export,l: -lcult -lboost_regex,cpp_options: )
-
-else
-
-# Include export stub.
-#
-$(call include,$(scf_root)/export/libbackend-elements/stub.make)
-
-endif
-
-else
-
-.NOTPARALLEL:
-
-endif
diff --git a/documentation/makefile b/documentation/makefile
index bedb174..4a8de5b 100644
--- a/documentation/makefile
+++ b/documentation/makefile
@@ -11,25 +11,112 @@ dist := $(out_base)/.dist
dist-win := $(out_base)/.dist-win
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)/xsd.xhtml \
+$(out_base)/xsd.1
+
+# Man/html pages.
+#
+$(out_base)/xsd.xhtml $(out_base)/xsd.1: cli := $(cli)
+$(out_base)/xsd.xhtml $(out_base)/xsd.1: cli_options += -I $(src_root)/xsd
+
+$(out_base)/xsd.xhtml $(out_base)/xsd.1: \
+$(src_root)/xsd/options.cli \
+$(src_root)/xsd/cxx/options.cli \
+$(src_root)/xsd/cxx/tree/options.cli \
+$(src_root)/xsd/cxx/parser/options.cli
+
+# Assemble the options from different files in a specific order.
+#
+
+# XHTML
+#
+$(out_base)/xsd.xhtml: $(src_base)/xsd-prologue.xhtml \
+ $(src_base)/xsd-epilogue.xhtml \
+ $(src_base)/xsd-tree-header.xhtml \
+ $(src_base)/xsd-parser-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)/xsd-prologue.xhtml \
+$$1 >$@, $(src_root)/xsd/cxx/options.cli)
+
+# C++/Tree options.
+#
+ $(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base \
+--html-prologue $(src_base)/xsd-tree-header.xhtml \
+$$1 >>$@, $(src_root)/xsd/cxx/tree/options.cli)
+
+# C++/Parser options.
+#
+ $(call message,cli-html $$1,$(cli) $(cli_options) --generate-html \
+--stdout --suppress-undocumented --exclude-base \
+--html-prologue $(src_base)/xsd-parser-header.xhtml \
+--html-epilogue $(src_base)/xsd-epilogue.xhtml \
+$$1 >>$@, $(src_root)/xsd/cxx/parser/options.cli)
+
+# MAN
+#
+$(out_base)/xsd.1: $(src_base)/xsd-prologue.1 \
+ $(src_base)/xsd-epilogue.1 \
+ $(src_base)/xsd-tree-header.1 \
+ $(src_base)/xsd-parser-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)/xsd-prologue.1 \
+$$1 >$@, $(src_root)/xsd/cxx/options.cli)
+
+# C++/Tree options.
+#
+ $(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base \
+--man-prologue $(src_base)/xsd-tree-header.1 \
+$$1 >>$@, $(src_root)/xsd/cxx/tree/options.cli)
+
+# C++/Parser options.
+#
+ $(call message,cli-man $$1,$(cli) $(cli_options) --generate-man \
+--stdout --suppress-undocumented --exclude-base \
+--man-prologue $(src_base)/xsd-parser-header.1 \
+--man-epilogue $(src_base)/xsd-epilogue.1 \
+$$1 >>$@, $(src_root)/xsd/cxx/parser/options.cli)
+
# Install.
#
-$(install): $(out_base)/cxx/.install
+$(install): $(out_base)/cxx/.install \
+ $(out_base)/xsd.xhtml \
+ $(out_base)/xsd.1
$(call install-data,$(src_base)/default.css,$(install_doc_dir)/xsd/default.css)
$(call install-data,$(src_base)/schema-authoring-guide.xhtml,$(install_doc_dir)/xsd/schema-authoring-guide.xhtml)
- $(call install-data,$(src_base)/xsd.xhtml,$(install_doc_dir)/xsd/xsd.xhtml)
+ $(call install-data,$(out_base)/xsd.xhtml,$(install_doc_dir)/xsd/xsd.xhtml)
$(call install-data,$(src_base)/custom-literals.xsd,$(install_doc_dir)/xsd/custom-literals.xsd)
- $(call install-data,$(src_base)/xsd.1,$(install_man_dir)/man1/xsd.1)
+ $(call install-data,$(out_base)/xsd.1,$(install_man_dir)/man1/xsd.1)
# Dist.
#
dist-common := $(out_base)/.dist-common
-$(dist-common):
+$(dist-common): $(out_base)/xsd.xhtml \
+ $(out_base)/xsd.1
$(call install-data,$(src_base)/default.css,$(dist_prefix)/documentation/default.css)
- $(call install-data,$(src_base)/xsd.xhtml,$(dist_prefix)/documentation/xsd.xhtml)
- $(call install-data,$(src_base)/xsd.1,$(dist_prefix)/documentation/xsd.1)
+ $(call install-data,$(out_base)/xsd.xhtml,$(dist_prefix)/documentation/xsd.xhtml)
+ $(call install-data,$(out_base)/xsd.1,$(dist_prefix)/documentation/xsd.1)
$(call install-data,$(src_base)/schema-authoring-guide.xhtml,$(dist_prefix)/documentation/schema-authoring-guide.xhtml)
$(call install-data,$(src_base)/custom-literals.xsd,$(dist_prefix)/documentation/custom-literals.xsd)
@@ -39,7 +126,19 @@ $(dist-win): $(dist-common) $(out_base)/cxx/.dist-win
# Clean.
#
$(cleandoc): $(src_base)/cxx/.cleandoc
+ $(call message,rm $$1,rm -f $$1,$(out_base)/xsd.1)
+ $(call message,rm $$1,rm -f $$1,$(out_base)/xsd.xhtml)
-$(call include,$(bld_root)/install.make)
+# Generated .gitignore.
+#
+ifeq ($(out_base),$(src_base))
+$(out_base)/xsd.xhtml $(out_base)/xsd.1: | $(out_base)/.gitignore
+$(out_base)/.gitignore: files := xsd.1 xsd.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/xsd-epilogue.1 b/documentation/xsd-epilogue.1
new file mode 100644
index 0000000..ddd2f8e
--- /dev/null
+++ b/documentation/xsd-epilogue.1
@@ -0,0 +1,561 @@
+\"
+\" NAMING CONVENTION
+\"
+
+.SH NAMING CONVENTION
+The compiler can be instructed to use a particular naming convention in
+the generated code. A number of widely-used conventions can be selected
+using the
+.B --type-naming
+and
+.B --function-naming
+options. A custom naming convention can be achieved using the
+.BR --type-regex ,
+.BR --accessor-regex ,
+.BR --one-accessor-regex ,
+.BR --opt-accessor-regex ,
+.BR --seq-accessor-regex ,
+.BR --modifier-regex ,
+.BR --one-modifier-regex ,
+.BR --opt-modifier-regex ,
+.BR --seq-modifier-regex ,
+.BR --parser-regex ,
+.BR --serializer-regex ,
+.BR --enumerator-regex ,
+and
+.B --element-type-regex
+options.
+
+The
+.B --type-naming
+option specifies the convention that should be used for naming C++ types.
+Possible values for this option are
+.B knr
+(default),
+.BR ucc ,
+and
+.BR java .
+The
+.B knr
+value (stands for K&R) signifies the standard, lower-case naming convention
+with the underscore used as a word delimiter, for example: foo, foo_bar.
+The
+.B ucc
+(stands for upper-camel-case) and
+.B java
+values a synonyms for the same naming convention where the first letter
+of each word in the name is capitalized, for example: Foo, FooBar.
+
+Similarly, the
+.B --function-naming
+option specifies the convention that should be used for naming C++ functions.
+Possible values for this option are
+.B knr
+(default),
+.BR lcc ,
+and
+.BR java .
+The
+.B knr
+value (stands for K&R) signifies the standard, lower-case naming convention
+with the underscore used as a word delimiter, for example: foo(), foo_bar().
+The
+.B lcc
+value (stands for lower-camel-case) signifies a naming convention where the
+first letter of each word except the first is capitalized, for example: foo(),
+fooBar(). The
+.B java
+naming convention is similar to the lower-camel-case one except that accessor
+functions are prefixed with get, modifier functions are prefixed with set,
+parsing functions are prefixed with parse, and serialization functions are
+prefixed with serialize, for example: getFoo(), setFooBar(), parseRoot(),
+serializeRoot().
+
+Note that the naming conventions specified with the
+.B --type-naming
+and
+.B --function-naming
+options perform only limited transformations on the
+names that come from the schema in the form of type, attribute, and element
+names. In other words, to get consistent results, your schemas should follow
+a similar naming convention as the one you would like to have in the generated
+code. Alternatively, you can use the
+.B --*-regex
+options (discussed below) to perform further transformations on the names
+that come from the schema.
+
+The
+.BR --type-regex ,
+.BR --accessor-regex ,
+.BR --one-accessor-regex ,
+.BR --opt-accessor-regex ,
+.BR --seq-accessor-regex ,
+.BR --modifier-regex ,
+.BR --one-modifier-regex ,
+.BR --opt-modifier-regex ,
+.BR --seq-modifier-regex ,
+.BR --parser-regex ,
+.BR --serializer-regex ,
+.BR --enumerator-regex ,
+and
+.B --element-type-regex
+options allow you to specify extra regular expressions for each name
+category in addition to the predefined set that is added depending on
+the
+.B --type-naming
+and
+.B --function-naming
+options. Expressions that are provided with the
+.B --*-regex
+options are evaluated prior to any predefined expressions. This allows
+you to selectively override some or all of the predefined transformations.
+When debugging your own expressions, it is often useful to see which
+expressions match which names. The
+.B --name-regex-trace
+option allows you to trace the process of applying
+regular expressions to names.
+
+The value for the
+.B --*-regex
+options should be 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 for each category are pushed
+into a category-specific stack with the last specified expression
+considered first. The first match that succeeds is used. For the
+.B --one-accessor-regex
+(accessors with cardinality one),
+.B --opt-accessor-regex
+(accessors with cardinality optional), and
+.B --seq-accessor-regex
+(accessors with cardinality sequence) categories the
+.B --accessor-regex
+expressions are used as a fallback. For the
+.BR --one-modifier-regex ,
+.BR --opt-modifier-regex ,
+and
+.B --seq-modifier-regex
+categories the
+.B --modifier-regex
+expressions are used as a fallback. For the
+.B --element-type-regex
+category the
+.B --type-regex
+expressions are used as a fallback.
+
+The type name expressions
+.RB ( --type-regex )
+are evaluated on the name string that has the following format:
+
+[\fInamespace \fR]\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR][\fB,\fIname\fR]
+
+The element type name expressions
+.RB ( --element-type-regex ),
+effective only when the
+.B --generate-element-type
+option is specified, are evaluated on the name string that has the following
+format:
+
+.I namespace name
+
+In the type name format the
+.I namespace
+part followed by a space is only present for global type names. For global
+types and elements defined in schemas without a target namespace, the
+.I namespace
+part is empty but the space is still present. In the type name format after
+the initial
+.I name
+component, up to three additional
+.I name
+components can be present, separated by commas. For example:
+
+.B http://example.com/hello type
+
+.B foo
+
+.B foo,iterator
+
+.B foo,const,iterator
+
+The following set of predefined regular expressions is used to transform
+type names when the upper-camel-case naming convention is selected:
+
+.B /(?:[^ ]* )?([^,]+)/\\\\u$1/
+
+.B /(?:[^ ]* )?([^,]+),([^,]+)/\\\\u$1\\\\u$2/
+
+.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3/
+
+.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3\\\\u$4/
+
+The accessor and modifier expressions
+.RB ( --*accessor-regex
+and
+.BR --*modifier-regex )
+are evaluated on the name string that has the following format:
+
+\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR]
+
+After the initial
+.I name
+component, up to two additional
+.I name
+components can be present, separated by commas. For example:
+
+.B foo
+
+.B dom,document
+
+.B foo,default,value
+
+The following set of predefined regular expressions is used to transform
+accessor names when the
+.B java
+naming convention is selected:
+
+.B /([^,]+)/get\\\\u$1/
+
+.B /([^,]+),([^,]+)/get\\\\u$1\\\\u$2/
+
+.B /([^,]+),([^,]+),([^,]+)/get\\\\u$1\\\\u$2\\\\u$3/
+
+For the parser, serializer, and enumerator categories, the corresponding
+regular expressions are evaluated on local names of elements and on
+enumeration values, respectively. For example, the following predefined
+regular expression is used to transform parsing function names when the
+.B java
+naming convention is selected:
+
+.B /(.+)/parse\\\\u$1/
+
+See also the REGEX AND SHELL QUOTING section below.
+
+\"
+\" TYPE MAP
+\"
+.SH TYPE MAP
+Type map files are used in C++/Parser to define a mapping between XML
+Schema and C++ types. 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.
+
+The compiler has a set of predefined mapping rules that map built-in
+XML Schema types to suitable C++ types (discussed below) 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_*
+functions. Optional
+.I cxx-arg-type
+is an argument type for callback functions corresponding to elements and
+attributes of this type. 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 that can be
+presented as the following map files. The string-based XML Schema
+built-in types are mapped to either
+.B std::string
+or
+.B std::wstring
+depending on the character type selected with the
+.B --char-type
+option
+.RB ( char
+by default).
+
+.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" "long long";
+.br
+
+ negativeInteger "long long" "long long";
+.br
+ nonPositiveInteger "long long" "long long";
+.br
+
+ positiveInteger "unsigned long long" "unsigned long long";
+.br
+ nonNegativeInteger "unsigned long long" "unsigned long long";
+.br
+
+ float float float;
+.br
+ double double double;
+.br
+ decimal double double;
+.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
+
+ NMTOKENS xml_schema::string_sequence;
+.br
+ IDREFS xml_schema::string_sequence;
+.br
+
+ QName xml_schema::qname;
+.br
+
+ base64Binary std::auto_ptr<xml_schema::buffer>
+.br
+ std::auto_ptr<xml_schema::buffer>;
+.br
+ hexBinary std::auto_ptr<xml_schema::buffer>
+.br
+ std::auto_ptr<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
+
+
+The last predefined rule 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.
+
+.\"
+.\" 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 xsd
+will issue diagnostic messages to
+.B STDERR
+and exit with non-zero exit code.
+.SH BUGS
+Send bug reports to the xsd-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/xsd-epilogue.xhtml b/documentation/xsd-epilogue.xhtml
new file mode 100644
index 0000000..f9b7c47
--- /dev/null
+++ b/documentation/xsd-epilogue.xhtml
@@ -0,0 +1,417 @@
+ <h1>NAMING CONVENTION</h1>
+
+ <p>The compiler can be instructed to use a particular naming
+ convention in the generated code. A number of widely-used
+ conventions can be selected using the <code><b>--type-naming</b></code>
+ and <code><b>--function-naming</b></code> options. A custom
+ naming convention can be achieved using the
+ <code><b>--type-regex</b></code>,
+ <code><b>--accessor-regex</b></code>,
+ <code><b>--one-accessor-regex</b></code>,
+ <code><b>--opt-accessor-regex</b></code>,
+ <code><b>--seq-accessor-regex</b></code>,
+ <code><b>--modifier-regex</b></code>,
+ <code><b>--one-modifier-regex</b></code>,
+ <code><b>--opt-modifier-regex</b></code>,
+ <code><b>--seq-modifier-regex</b></code>,
+ <code><b>--parser-regex</b></code>,
+ <code><b>--serializer-regex</b></code>,
+ <code><b>--enumerator-regex</b></code>, and
+ <code><b>--element-type-regex</b></code> options.
+ </p>
+
+ <p>The <code><b>--type-naming</b></code> option specifies the
+ convention that should be used for naming C++ types. Possible
+ values for this option are <code><b>knr</b></code> (default),
+ <code><b>ucc</b></code>, and <code><b>java</b></code>. The
+ <code><b>knr</b></code> value (stands for K&amp;R) signifies
+ the standard, lower-case naming convention with the underscore
+ used as a word delimiter, for example: <code>foo</code>,
+ <code>foo_bar</code>. The <code><b>ucc</b></code> (stands
+ for upper-camel-case) and
+ <code><b>java</b></code> values a synonyms for the same
+ naming convention where the first letter of each word in the
+ name is capitalized, for example: <code>Foo</code>,
+ <code>FooBar</code>.</p>
+
+ <p>Similarly, the <code><b>--function-naming</b></code> option
+ specifies the convention that should be used for naming C++
+ functions. Possible values for this option are <code><b>knr</b></code>
+ (default), <code><b>lcc</b></code>, and <code><b>java</b></code>. The
+ <code><b>knr</b></code> value (stands for K&amp;R) signifies
+ the standard, lower-case naming convention with the underscore
+ used as a word delimiter, for example: <code>foo()</code>,
+ <code>foo_bar()</code>. The <code><b>lcc</b></code> value
+ (stands for lower-camel-case) signifies a naming convention
+ where the first letter of each word except the first is
+ capitalized, for example: <code>foo()</code>, <code>fooBar()</code>.
+ The <code><b>java</b></code> naming convention is similar to
+ the lower-camel-case one except that accessor functions are prefixed
+ with <code>get</code>, modifier functions are prefixed
+ with <code>set</code>, parsing functions are prefixed
+ with <code>parse</code>, and serialization functions are
+ prefixed with <code>serialize</code>, for example:
+ <code>getFoo()</code>, <code>setFooBar()</code>,
+ <code>parseRoot()</code>, <code>serializeRoot()</code>.</p>
+
+ <p>Note that the naming conventions specified with the
+ <code><b>--type-naming</b></code> and
+ <code><b>--function-naming</b></code> options perform only limited
+ transformations on the names that come from the schema in the
+ form of type, attribute, and element names. In other words, to
+ get consistent results, your schemas should follow a similar
+ naming convention as the one you would like to have in the
+ generated code. Alternatively, you can use the
+ <code><b>--*-regex</b></code> options (discussed below)
+ to perform further transformations on the names that come from
+ the schema.</p>
+
+ <p>The
+ <code><b>--type-regex</b></code>,
+ <code><b>--accessor-regex</b></code>,
+ <code><b>--one-accessor-regex</b></code>,
+ <code><b>--opt-accessor-regex</b></code>,
+ <code><b>--seq-accessor-regex</b></code>,
+ <code><b>--modifier-regex</b></code>,
+ <code><b>--one-modifier-regex</b></code>,
+ <code><b>--opt-modifier-regex</b></code>,
+ <code><b>--seq-modifier-regex</b></code>,
+ <code><b>--parser-regex</b></code>,
+ <code><b>--serializer-regex</b></code>,
+ <code><b>--enumerator-regex</b></code>, and
+ <code><b>--element-type-regex</b></code> options allow you to
+ specify extra regular expressions for each name category in
+ addition to the predefined set that is added depending on
+ the <code><b>--type-naming</b></code> and
+ <code><b>--function-naming</b></code> options. Expressions
+ that are provided with the <code><b>--*-regex</b></code>
+ options are evaluated prior to any predefined expressions.
+ This allows you to selectively override some or all of the
+ predefined transformations. When debugging your own expressions,
+ it is often useful to see which expressions match which names.
+ The <code><b>--name-regex-trace</b></code> option allows you
+ to trace the process of applying regular expressions to
+ names.</p>
+
+ <p>The value for the <code><b>--*-regex</b></code> options should be
+ 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 for each category are pushed into a
+ category-specific stack with the last specified expression
+ considered first. The first match that succeeds is used. For the
+ <code><b>--one-accessor-regex</b></code> (accessors with cardinality one),
+ <code><b>--opt-accessor-regex</b></code> (accessors with cardinality optional), and
+ <code><b>--seq-accessor-regex</b></code> (accessors with cardinality sequence)
+ categories the <code><b>--accessor-regex</b></code> expressions are
+ used as a fallback. For the
+ <code><b>--one-modifier-regex</b></code>,
+ <code><b>--opt-modifier-regex</b></code>, and
+ <code><b>--seq-modifier-regex</b></code>
+ categories the <code><b>--modifier-regex</b></code> expressions are
+ used as a fallback. For the <code><b>--element-type-regex</b></code>
+ category the <code><b>--type-regex</b></code> expressions are
+ used as a fallback.</p>
+
+ <p>The type name expressions (<code><b>--type-regex</b></code>)
+ are evaluated on the name string that has the following
+ format:</p>
+
+ <p><code>[<i>namespace</i> ]<i>name</i>[,<i>name</i>][,<i>name</i>][,<i>name</i>]</code></p>
+
+ <p>The element type name expressions
+ (<code><b>--element-type-regex</b></code>), effective only when
+ the <code><b>--generate-element-type</b></code> option is specified,
+ are evaluated on the name string that has the following
+ format:</p>
+
+ <p><code><i>namespace</i> <i>name</i></code></p>
+
+ <p>In the type name format the <code><i>namespace</i></code> part
+ followed by a space is only present for global type names. For
+ global types and elements defined in schemas without a target
+ namespace, the <code><i>namespace</i></code> part is empty but
+ the space is still present. In the type name format after the
+ initial <code><i>name</i></code> component, up to three additional
+ <code><i>name</i></code> components can be present, separated
+ by commas. For example:</p>
+
+ <p><code><b>http://example.com/hello type</b></code></p>
+ <p><code><b>foo</b></code></p>
+ <p><code><b>foo,iterator</b></code></p>
+ <p><code><b>foo,const,iterator</b></code></p>
+
+ <p>The following set of predefined regular expressions is used to
+ transform type names when the upper-camel-case naming convention
+ is selected:</p>
+
+ <p><code><b>/(?:[^ ]* )?([^,]+)/\u$1/</b></code></p>
+ <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/</b></code></p>
+ <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/</b></code></p>
+ <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/</b></code></p>
+
+ <p>The accessor and modifier expressions
+ (<code><b>--*accessor-regex</b></code> and
+ <code><b>--*modifier-regex</b></code>) are evaluated on the name string
+ that has the following format:</p>
+
+ <p><code><i>name</i>[,<i>name</i>][,<i>name</i>]</code></p>
+
+ <p>After the initial <code><i>name</i></code> component, up to two
+ additional <code><i>name</i></code> components can be present,
+ separated by commas. For example:</p>
+
+ <p><code><b>foo</b></code></p>
+ <p><code><b>dom,document</b></code></p>
+ <p><code><b>foo,default,value</b></code></p>
+
+ <p>The following set of predefined regular expressions is used to
+ transform accessor names when the <code><b>java</b></code> naming
+ convention is selected:</p>
+
+ <p><code><b>/([^,]+)/get\u$1/</b></code></p>
+ <p><code><b>/([^,]+),([^,]+)/get\u$1\u$2/</b></code></p>
+ <p><code><b>/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/</b></code></p>
+
+ <p>For the parser, serializer, and enumerator categories, the
+ corresponding regular expressions are evaluated on local names of
+ elements and on enumeration values, respectively. For example, the
+ following predefined regular expression is used to transform parsing
+ function names when the <code><b>java</b></code> naming convention
+ is selected:</p>
+
+ <p><code><b>/(.+)/parse\u$1/</b></code></p>
+
+ <p>See also the REGEX AND SHELL QUOTING section below.</p>
+
+ <h1>TYPE MAP</h1>
+
+ <p>Type map files are used in C++/Parser to define a mapping between
+ XML Schema and C++ types. 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.</p>
+
+ <p>The compiler has a set of predefined mapping rules that map
+ built-in XML Schema types to suitable C++ types (discussed
+ below) 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>" "</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> functions.
+ Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
+ type for callback functions corresponding to elements and attributes
+ of this type. 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>" "</b></code> or <code><b>&lt; ></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>" "</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 that can be
+ presented as the following map files. The string-based XML Schema
+ built-in types are mapped to either <code><b>std::string</b></code>
+ or <code><b>std::wstring</b></code> depending on the character type
+ selected with the <code><b>--char-type</b></code> option
+ (<code><b>char</b></code> by default).</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" "long long";
+
+ negativeInteger "long long" "long long";
+ nonPositiveInteger "long long" "long long";
+
+ positiveInteger "unsigned long long" "unsigned long long";
+ nonNegativeInteger "unsigned long long" "unsigned long long";
+
+ float float float;
+ double double double;
+ decimal double double;
+
+ 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;
+
+ NMTOKENS xml_schema::string_sequence;
+ IDREFS xml_schema::string_sequence;
+
+ QName xml_schema::qname;
+
+ base64Binary std::auto_ptr&lt;xml_schema::buffer>
+ std::auto_ptr&lt;xml_schema::buffer>;
+ hexBinary std::auto_ptr&lt;xml_schema::buffer>
+ std::auto_ptr&lt;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>The last predefined rule 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>
+
+ <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>xsd</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:xsd-users@codesynthesis.com">xsd-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/xsd-parser-header.1 b/documentation/xsd-parser-header.1
new file mode 100644
index 0000000..e0cf84e
--- /dev/null
+++ b/documentation/xsd-parser-header.1
@@ -0,0 +1,4 @@
+\"
+\" C++/Parser
+\"
+.SS cxx-parser command options
diff --git a/documentation/xsd-parser-header.xhtml b/documentation/xsd-parser-header.xhtml
new file mode 100644
index 0000000..94fa2c1
--- /dev/null
+++ b/documentation/xsd-parser-header.xhtml
@@ -0,0 +1 @@
+ <h2>CXX-PARSER COMMAND OPTIONS</h2>
diff --git a/documentation/xsd-prologue.1 b/documentation/xsd-prologue.1
new file mode 100644
index 0000000..9a31635
--- /dev/null
+++ b/documentation/xsd-prologue.1
@@ -0,0 +1,119 @@
+.\" Process this file with
+.\" groff -man -Tascii xsd.1
+.\"
+.TH XSD 1 "August 2010" "XSD 4.0.0"
+.SH NAME
+xsd \- W3C XML Schema to C++ Compiler
+.\"
+.\"
+.\"
+.\"--------------------------------------------------------------------
+.SH SYNOPSIS
+.\"--------------------------------------------------------------------
+.B xsd
+.I command
+.B [
+.I options
+.B ]
+.I file
+.B [
+.I file
+.B ...]
+.in
+.B xsd help
+.B [
+.I command
+.B ]
+.in
+.B xsd version
+.\"
+.\"
+.\"
+.\"--------------------------------------------------------------------
+.SH DESCRIPTION
+.\"--------------------------------------------------------------------
+.B xsd
+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-tree\fR
+Generate the C++/Tree mapping. For each input file in the form
+.B name.xsd
+the following C++ files are generated:
+.B name.hxx
+(header file),
+.B name.ixx
+(inline file, generated only if the
+.B --generate-inline
+option is specified),
+.B name.cxx
+(source file), and
+.B name-fwd.hxx
+(forward declaration file, generated only if the
+.B --generate-forward
+option is specified).
+
+.IP \fBcxx-parser\fR
+Generate the 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-driver.cxx
+test driver file is generated.
+
+.IP \fBhelp\fR
+Print usage information and exit. Use
+.PP
+.RS
+.RS 3
+.B xsd 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/xsd-prologue.xhtml b/documentation/xsd-prologue.xhtml
new file mode 100644
index 0000000..d29b729
--- /dev/null
+++ b/documentation/xsd-prologue.xhtml
@@ -0,0 +1,120 @@
+<?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 4.0.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 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>xsd - W3C XML Schema to C++ Compiler</p>
+
+ <h1>SYNOPSIS</h1>
+
+ <dl id="synopsis">
+ <dt><code><b>xsd</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
+ <dt><code><b>xsd help</b> [<i>command</i>]</code></dt>
+ <dt><code><b>xsd version</b></code></dt>
+ </dl>
+
+ <h1>DESCRIPTION</h1>
+
+ <p><code><b>xsd</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-tree</b></code></dt>
+ <dd>Generate the C++/Tree 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> (header file),
+ <code><b>name.ixx</b></code> (inline file, generated only if the
+ <code><b>--generate-inline</b></code> option is specified),
+ <code><b>name.cxx</b></code> (source file), and
+ <code><b>name-fwd.hxx</b></code> (forward declaration file, generated
+ only if the <code><b>--generate-forward</b></code> option is
+ specified).</dd>
+
+ <dt><code><b>cxx-parser</b></code></dt>
+ <dd>Generate the 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-driver.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>xsd 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/xsd-tree-header.1 b/documentation/xsd-tree-header.1
new file mode 100644
index 0000000..b9146a7
--- /dev/null
+++ b/documentation/xsd-tree-header.1
@@ -0,0 +1,4 @@
+.\"
+.\" C++/Tree options.
+.\"
+.SS cxx-tree command options
diff --git a/documentation/xsd-tree-header.xhtml b/documentation/xsd-tree-header.xhtml
new file mode 100644
index 0000000..73f9c99
--- /dev/null
+++ b/documentation/xsd-tree-header.xhtml
@@ -0,0 +1 @@
+ <h2>CXX-TREE COMMAND OPTIONS</h2>
diff --git a/documentation/xsd.1 b/documentation/xsd.1
deleted file mode 100644
index 0920c29..0000000
--- a/documentation/xsd.1
+++ /dev/null
@@ -1,1906 +0,0 @@
-.\" Process this file with
-.\" groff -man -Tascii xsd.1
-.\"
-.TH XSD 1 "August 2010" "XSD 4.0.0"
-.SH NAME
-xsd \- W3C XML Schema to C++ Compiler
-.\"
-.\"
-.\"
-.\"--------------------------------------------------------------------
-.SH SYNOPSIS
-.\"--------------------------------------------------------------------
-.B xsd
-.I command
-.B [
-.I options
-.B ]
-.I file
-.B [
-.I file
-.B ...]
-.in
-.B xsd help
-.B [
-.I command
-.B ]
-.in
-.B xsd version
-.\"
-.\"
-.\"
-.\"--------------------------------------------------------------------
-.SH DESCRIPTION
-.\"--------------------------------------------------------------------
-.B xsd
-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-tree\fR
-Generate the C++/Tree mapping. For each input file in the form
-.B name.xsd
-the following C++ files are generated:
-.B name.hxx
-(header file),
-.B name.ixx
-(inline file, generated only if the
-.B --generate-inline
-option is specified),
-.B name.cxx
-(source file), and
-.B name-fwd.hxx
-(forward declaration file, generated only if the
-.B --generate-forward
-option is specified).
-
-.IP \fBcxx-parser\fR
-Generate the 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-driver.cxx
-test driver file is generated.
-
-.IP \fBhelp\fR
-Print usage information and exit. Use
-.PP
-.RS
-.RS 3
-.B xsd 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\--char-type \fItype\fR"
-Generate code using the provided character
-.I type
-instead of the default
-.BR char .
-Valid values are
-.B char
-and
-.BR wchar_t .
-.
-.IP "\fB\--char-encoding \fIenc\fR"
-Specify the character encoding that should be used in the generated code.
-Valid values for the
-.B char
-character type are
-.B utf8
-(default),
-.BR iso8859-1 , lcp
-(Xerces-C++ local code page),
-and
-.BR custom .
-If you pass
-.B custom
-as the value then you will need to include the transcoder implementation
-header for your encoding at the beginning of the generated header files
-(see the
-.B --hxx-prologue
-option).
-
-For the
-.B wchar_t
-character type the only valid value is
-.B auto
-and the encoding is automatically selected between UTF-16 and UTF-32/UCS-4,
-depending on the
-.B wchar_t
-type size.
-.
-.IP "\fB\--output-dir \fIdir\fR"
-Write generated files to
-.I dir
-instead of the current directory.
-
-.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.
-
-\"
-\" Include
-\"
-
-.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.
-
-.\"
-.\" Suffixes.
-.\"
-
-.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\--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.
-Note that this expression is also used to construct names for
-included/imported schemas. 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.
-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.
-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.
-
-.IP "\fB\--ixx-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the inline file.
-
-.IP "\fB\--cxx-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the source file.
-
-.IP "\fB\--prologue \fItext\fR"
-Insert
-.I text
-at the beginning of each generated file for which there is no file-specific
-prologue.
-
-.IP "\fB\--hxx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the header file.
-
-.IP "\fB\--ixx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the inline file.
-
-.IP "\fB\--cxx-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the source file.
-
-.IP "\fB\--epilogue \fItext\fR"
-Insert
-.I text
-at the end of each generated file for which there is no file-specific
-epilogue.
-
-.IP "\fB\--hxx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the header file.
-
-.IP "\fB\--ixx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the inline file.
-
-.IP "\fB\--cxx-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the source file.
-
-.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.
-
-.IP "\fB\--hxx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the header file.
-
-.IP "\fB\--ixx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the inline file.
-
-.IP "\fB\--cxx-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the source file.
-
-.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.
-
-.IP "\fB\--custom-literals \fIfile\fR"
-Load custom XML string to C++ literal mappings from
-.IR file .
-This mechanism can be useful if you are using a custom character encoding
-and some of the strings in your schemas, for example element/attribute
-names or enumeration values, contain non-ASCII characters. In this case
-you will need to provide a custom mapping to C++ literals for such
-strings. The format of this file is specified in the
-.B custom-literals.xsd
-XML Schema file that can be found in the documentation directory.
-
-.IP "\fB\--export-symbol \fIsymbol\fR"
-Insert
-.I symbol
-in places where DLL export/import control statements (
-.BR __declspec(dllexport/dllimport) )
-are necessary.
-
-.IP "\fB\--export-xml-schema\fR"
-Export/import types in the XML Schema namespace using the export
-symbol provided with the
-.B --export-symbol
-option. The
-.B XSD_NO_EXPORT
-macro can be used to omit this code during C++ compilation, which may be
-useful if you would like to use the same generated code across multiple
-platforms.
-
-.IP "\fB\--export-maps\fR"
-Export polymorphism support maps from a Win32 DLL into which this generated
-code is linked. This is necessary when your type hierarchy is split across
-several DLLs since otherwise each DLL will have its own set of maps. In
-this situation the generated code for the DLL which contains base types
-and/or substitution group heads should be compiled with this option and
-the generated code for all other DLLs should be compiled with
-.BR --import-maps .
-This option is only valid together with
-.BR --generate-polymorphic.
-The
-.B XSD_NO_EXPORT
-macro can be used to omit this code during C++ compilation, which may be
-useful if you would like to use the same generated code across multiple
-platforms.
-
-.IP "\fB\--import-maps\fR"
-Import polymorphism support maps to a Win32 DLL or executable into which
-this generated code is linked. See the
-.B --export-maps
-option documentation for details. This option is only valid together with
-.BR --generate-polymorphic.
-The
-.B XSD_NO_EXPORT
-macro can be used to omit this code during C++ compilation, which may be
-useful if you would like to use the same generated code across multiple
-platforms.
-
-.IP "\fB\--disable-warning \fIwarn\fR"
-Disable printing warning with id
-.IR warn .
-If
-.B all
-is specified for the warning id then all 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++/Tree options.
-.\"
-.SS cxx-tree command options
-
-.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
-or
-.B --polymorphic-type-all
-option to specify which type hierarchies are polymorphic.
-
-.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 .
-The
-.I type
-argument is an XML Schema type name that can be optionally qualified
-with a namespace in the
-.IB namespace # name
-form.
-
-.IP "\fB\--polymorphic-type-all\fR"
-Indicate that all types should be treated as polymorphic.
-
-.IP "\fB\--generate-serialization\fR"
-Generate serialization functions. Serialization functions convert
-the object model back to XML.
-
-.IP "\fB\--generate-inline\fR"
-Generate simple functions inline. This option triggers creation of the
-inline file.
-
-.IP "\fB\--generate-ostream\fR"
-Generate ostream insertion operators
-.RB ( operator<< )
-for generated types. This allows to easily print a fragment or the whole
-object model for debugging or logging.
-
-.IP "\fB\--generate-doxygen\fR"
-Generate documentation comments suitable for extraction by the Doxygen
-documentation system. Documentation from annotations is added to the
-comments if present in the schema.
-
-.IP "\fB\--generate-comparison\fR"
-Generate comparison operators
-.RB ( operator==
-and
-.BR operator!= )
-for complex types. Comparison is performed memberwise.
-
-.IP "\fB\--generate-default-ctor\fR"
-Generate default constructors even for types that have required members.
-Required members of an instance constructed using such a constructor are
-not initialized and accessing them results in undefined behavior.
-
-.IP "\fB\--generate-from-base-ctor\fR"
-Generate constructors that expect an instance of a base type followed by all
-required members.
-
-.IP "\fB\--suppress-assignment\fR"
-Suppress the generation of copy assignment operators for complex types.
-If this option is specified, the copy assignment operators for such
-types are declared private and left unimplemented.
-
-.IP "\fB\--generate-detach\fR"
-Generate detach functions for required elements and attributes (detach
-functions for optional and sequence cardinalities are provided by the
-respective containers). These functions, for example, allow you to move
-sub-trees in the object model either within the same tree or between
-different trees.
-
-.IP "\fB\--generate-wildcard\fR"
-Generate accessors and modifiers as well as parsing and serialization code
-for XML Schema wildcards
-.RB ( any
-and
-.BR anyAttribute ).
-XML content matched by wildcards is presented as DOM fragments. Note that
-you need to initialize the Xerces-C++ runtime if you are using this option.
-
-.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 ACE CDR stream
-.RB ( ACE_OutputCDR )
-and RPC XDR are recognized by the compiler and the necessary
-.B #include
-directives are automatically generated. For custom stream types use the
-.B --hxx-prologue*
-options to provide the necessary declarations.
-
-.IP "\fB\--generate-extraction \fIis\fR"
-Generate data representation stream extraction constructors for the
-.I is
-input stream type. Repeat this option to specify more than one stream
-type. The ACE CDR stream
-.RB ( ACE_InputCDR )
-and RPC XDR are recognized by the compiler and the necessary
-.B #include
-directives are automatically generated. For custom stream types use the
-.B --hxx-prologue*
-options to provide the necessary declarations.
-
-.IP "\fB\--generate-forward\fR"
-Generate a separate header file with forward declarations for the types
-being generated.
-
-.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 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\--suppress-parsing\fR"
-Suppress the generation of the parsing functions and constructors. Use this
-option to reduce the generated code size when parsing from XML is not
-needed.
-
-.IP "\fB\--generate-element-type\fR"
-Generate types instead of parsing and serialization functions for root
-elements. This is primarily useful to distinguish object models with the
-same root type but with different root elements.
-
-.IP "\fB\--generate-element-map\fR"
-Generate a root element map that allows uniform parsing and serialization
-of multiple root elements. This option is only valid together with
-.BR --generate-element-type .
-
-.IP "\fB\--generate-intellisense\fR"
-Generate workarounds for IntelliSense bugs in Visual Studio 2005 (8.0). When
-this option is used, the resulting code is slightly more verbose. IntelliSense
-in Visual Studio 2008 (9.0) does not require these workarounds. Support for
-IntelliSense in Visual Studio 2003 (7.1) is improved with this option but
-is still incomplete.
-
-.IP "\fB\--omit-default-attributes\fR"
-Omit attributes with default and fixed values from serialized XML
-documents.
-
-\"
-\" Naming
-\"
-
-.IP "\fB\--type-naming \fIstyle\fR"
-Specify the type naming convention that should be used in the generated code.
-Valid styles are
-.B knr
-(default),
-.BR ucc ,
-and
-.BR java .
-See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--function-naming \fIstyle\fR"
-Specify the function naming convention that should be used in the generated
-code. Valid styles are
-.B knr
-(default),
-.BR lcc ,
-and
-.BR java.
-See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--type-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-type names to C++ type names. See the NAMING CONVENTION section below for
-more information.
-
-.IP "\fB\--accessor-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes to C++ accessor function names. See the NAMING
-CONVENTION section below for more information.
-
-.IP "\fB\--one-accessor-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality one to C++ accessor function
-names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--opt-accessor-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality optional to C++ accessor
-function names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--seq-accessor-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality sequence to C++ accessor
-function names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--modifier-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes to C++ modifier function names. See the NAMING
-CONVENTION section below for more information.
-
-.IP "\fB\--one-modifier-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality one to C++ modifier function
-names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--opt-modifier-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality optional to C++ modifier
-function names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--seq-modifier-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-names of elements/attributes with cardinality sequence to C++ modifier
-function names. See the NAMING CONVENTION section below for more information.
-
-.IP "\fB\--parser-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-element names to C++ parsing function names. See the NAMING CONVENTION
-section below for more information.
-
-.IP "\fB\--serializer-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-element names to C++ serialization function names. See the NAMING
-CONVENTION section below for more information.
-
-.IP "\fB\--enumerator-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-enumeration values to C++ enumerator names. See the NAMING CONVENTION
-section below for more information.
-
-.IP "\fB\--element-type-regex \fIregex\fR"
-Add
-.I regex
-to the list of regular expressions used to translate XML Schema
-element names to C++ element type names. See the NAMING CONVENTION section
-below for more information.
-
-.IP "\fB\--name-regex-trace\fR"
-Trace the process of applying regular expressions specified with the name
-transformation options. Use this option to find out why your regular
-expressions don't do what you expected them to do.
-
-\"
-\" Root element.
-\"
-
-.IP "\fB\--root-element-first\fR"
-Treat only the first global element as a document root. By default all
-global elements are considered document roots.
-
-.IP "\fB\--root-element-last\fR"
-Treat only the last global element as a document root. By default all
-global elements are considered document roots.
-
-.IP "\fB\--root-element-all\fR"
-Treat all global elements as document roots. This is the default behavior.
-By explicitly specifying this option you can suppress the warning that is
-issued if more than one global element is defined.
-
-.IP "\fB\--root-element-none\fR"
-Do not treat any global elements as document roots. By default all global
-elements are considered document roots.
-
-.IP "\fB\--root-element \fIelement\fR"
-Treat only
-.I element
-as a document root. Repeat this option to specify more than one root element.
-
-\"
-\" Custom type.
-\"
-
-.IP "\fB\--custom-type \fIname\fR[\fB=\fItype\fR[\fB/\fIbase\fR]]"
-Use a custom C++ type
-.I type
-instead of the generated class for XML Schema type
-.IR name .
-If
-.I type
-is not present or empty then the custom type is assumed to have the same name
-and be defined in the same namespace as the generated class would have. If
-.I base
-is specified then the generated class is still generated but with that name.
-
-.IP "\fB\--custom-type-regex \fB/\fIname-pat\fB/\fR[\fItype-sub\fB/\fR[\fIbase-sub\fB/\fR]]"
-For each type defined in XML Schema that matches the
-.I name-pat
-pattern use a custom C++ type instead of the generated class. The
-name of the custom type is obtained by substituting
-.IR type-sub .
-If
-.I type-sub
-is not present or its substitution results in an empty string then the
-custom type is assumed to have the same name and be defined in the same
-namespace as the generated class would have. If
-.I base-sub
-is present and its substitution results in a non-empty string then the
-generated class is still generated but with the result of substitution
-as its name. The pattern and substitutions are in the perl regular
-expression format. See also the REGEX AND SHELL QUOTING section below.
-
-\"
-\" Suffixes.
-\"
-
-.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.
-
-.IP "\fB\--fwd-regex \fIregex\fR"
-Use the provided expression to construct the name of the forward
-declaration file.
-.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\--fwd-prologue \fItext\fR"
-Insert
-.I text
-at the beginning of the forward declaration file.
-
-.IP "\fB\--fwd-epilogue \fItext\fR"
-Insert
-.I text
-at the end of the forward declaration file.
-
-.IP "\fB\--fwd-prologue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the beginning of the forward declaration file.
-
-.IP "\fB\--fwd-epilogue-file \fIfile\fR"
-Insert the content of the
-.I file
-at the end of the forward declaration file.
-
-\"
-\" Parts.
-\"
-
-.IP "\fB\--parts \fInum\fR"
-Split generated source code into
-.I num
-parts. This is useful when translating large, monolithic schemas and a C++
-compiler is not able to compile the resulting source code at once (usually
-due to insufficient memory).
-
-.IP "\fB\--parts-suffix \fIsuffix\fR"
-Use
-.I suffix
-instead of the default '\fB-\fR' to separate the file name from the part
-number.
-
-\"
-\" C++/Parser
-\"
-
-.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\--xml-parser \fIparser\fR"
-Use
-.I parser
-as the underlying XML parser. Valid values are
-.B xerces
-for Xerces-C++ (default) and
-.B expat
-for Expat.
-
-.IP "\fB\--generate-inline\fR"
-Generate simple functions inline. This option triggers creation of the
-inline file.
-
-.IP "\fB\--generate-validation\fR"
-Generate validation code ("perfect" parser) which ensures that instance
-documents conform to the schema. Validation code is generated by default
-when the selected underlying XML parser is non-validating (\fBexpat\fR).
-
-.IP "\fB\--suppress-validation\fR"
-Suppress the generation of validation code ("perfect" parser). Validation is
-suppressed by default when the selected underlying XML parser is
-validating (\fBxerces\fR).
-
-.IP "\fB\--generate-polymorphic\fR"
-Generate polymorphism-aware code. Specify this option if you use substitution
-groups or
-.BR xsi:type .
-
-.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-driver.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.
-
-\"
-\" NAMING CONVENTION
-\"
-
-.SH NAMING CONVENTION
-The compiler can be instructed to use a particular naming convention in
-the generated code. A number of widely-used conventions can be selected
-using the
-.B --type-naming
-and
-.B --function-naming
-options. A custom naming convention can be achieved using the
-.BR --type-regex ,
-.BR --accessor-regex ,
-.BR --one-accessor-regex ,
-.BR --opt-accessor-regex ,
-.BR --seq-accessor-regex ,
-.BR --modifier-regex ,
-.BR --one-modifier-regex ,
-.BR --opt-modifier-regex ,
-.BR --seq-modifier-regex ,
-.BR --parser-regex ,
-.BR --serializer-regex ,
-.BR --enumerator-regex ,
-and
-.B --element-type-regex
-options.
-
-The
-.B --type-naming
-option specifies the convention that should be used for naming C++ types.
-Possible values for this option are
-.B knr
-(default),
-.BR ucc ,
-and
-.BR java .
-The
-.B knr
-value (stands for K&R) signifies the standard, lower-case naming convention
-with the underscore used as a word delimiter, for example: foo, foo_bar.
-The
-.B ucc
-(stands for upper-camel-case) and
-.B java
-values a synonyms for the same naming convention where the first letter
-of each word in the name is capitalized, for example: Foo, FooBar.
-
-Similarly, the
-.B --function-naming
-option specifies the convention that should be used for naming C++ functions.
-Possible values for this option are
-.B knr
-(default),
-.BR lcc ,
-and
-.BR java .
-The
-.B knr
-value (stands for K&R) signifies the standard, lower-case naming convention
-with the underscore used as a word delimiter, for example: foo(), foo_bar().
-The
-.B lcc
-value (stands for lower-camel-case) signifies a naming convention where the
-first letter of each word except the first is capitalized, for example: foo(),
-fooBar(). The
-.B java
-naming convention is similar to the lower-camel-case one except that accessor
-functions are prefixed with get, modifier functions are prefixed with set,
-parsing functions are prefixed with parse, and serialization functions are
-prefixed with serialize, for example: getFoo(), setFooBar(), parseRoot(),
-serializeRoot().
-
-Note that the naming conventions specified with the
-.B --type-naming
-and
-.B --function-naming
-options perform only limited transformations on the
-names that come from the schema in the form of type, attribute, and element
-names. In other words, to get consistent results, your schemas should follow
-a similar naming convention as the one you would like to have in the generated
-code. Alternatively, you can use the
-.B --*-regex
-options (discussed below) to perform further transformations on the names
-that come from the schema.
-
-The
-.BR --type-regex ,
-.BR --accessor-regex ,
-.BR --one-accessor-regex ,
-.BR --opt-accessor-regex ,
-.BR --seq-accessor-regex ,
-.BR --modifier-regex ,
-.BR --one-modifier-regex ,
-.BR --opt-modifier-regex ,
-.BR --seq-modifier-regex ,
-.BR --parser-regex ,
-.BR --serializer-regex ,
-.BR --enumerator-regex ,
-and
-.B --element-type-regex
-options allow you to specify extra regular expressions for each name
-category in addition to the predefined set that is added depending on
-the
-.B --type-naming
-and
-.B --function-naming
-options. Expressions that are provided with the
-.B --*-regex
-options are evaluated prior to any predefined expressions. This allows
-you to selectively override some or all of the predefined transformations.
-When debugging your own expressions, it is often useful to see which
-expressions match which names. The
-.B --name-regex-trace
-option allows you to trace the process of applying
-regular expressions to names.
-
-The value for the
-.B --*-regex
-options should be 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 for each category are pushed
-into a category-specific stack with the last specified expression
-considered first. The first match that succeeds is used. For the
-.B --one-accessor-regex
-(accessors with cardinality one),
-.B --opt-accessor-regex
-(accessors with cardinality optional), and
-.B --seq-accessor-regex
-(accessors with cardinality sequence) categories the
-.B --accessor-regex
-expressions are used as a fallback. For the
-.BR --one-modifier-regex ,
-.BR --opt-modifier-regex ,
-and
-.B --seq-modifier-regex
-categories the
-.B --modifier-regex
-expressions are used as a fallback. For the
-.B --element-type-regex
-category the
-.B --type-regex
-expressions are used as a fallback.
-
-The type name expressions
-.RB ( --type-regex )
-are evaluated on the name string that has the following format:
-
-[\fInamespace \fR]\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR][\fB,\fIname\fR]
-
-The element type name expressions
-.RB ( --element-type-regex ),
-effective only when the
-.B --generate-element-type
-option is specified, are evaluated on the name string that has the following
-format:
-
-.I namespace name
-
-In the type name format the
-.I namespace
-part followed by a space is only present for global type names. For global
-types and elements defined in schemas without a target namespace, the
-.I namespace
-part is empty but the space is still present. In the type name format after
-the initial
-.I name
-component, up to three additional
-.I name
-components can be present, separated by commas. For example:
-
-.B http://example.com/hello type
-
-.B foo
-
-.B foo,iterator
-
-.B foo,const,iterator
-
-The following set of predefined regular expressions is used to transform
-type names when the upper-camel-case naming convention is selected:
-
-.B /(?:[^ ]* )?([^,]+)/\\\\u$1/
-
-.B /(?:[^ ]* )?([^,]+),([^,]+)/\\\\u$1\\\\u$2/
-
-.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3/
-
-.B /(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\\\\u$1\\\\u$2\\\\u$3\\\\u$4/
-
-The accessor and modifier expressions
-.RB ( --*accessor-regex
-and
-.BR --*modifier-regex )
-are evaluated on the name string that has the following format:
-
-\fIname\fR[\fB,\fIname\fR][\fB,\fIname\fR]
-
-After the initial
-.I name
-component, up to two additional
-.I name
-components can be present, separated by commas. For example:
-
-.B foo
-
-.B dom,document
-
-.B foo,default,value
-
-The following set of predefined regular expressions is used to transform
-accessor names when the
-.B java
-naming convention is selected:
-
-.B /([^,]+)/get\\\\u$1/
-
-.B /([^,]+),([^,]+)/get\\\\u$1\\\\u$2/
-
-.B /([^,]+),([^,]+),([^,]+)/get\\\\u$1\\\\u$2\\\\u$3/
-
-For the parser, serializer, and enumerator categories, the corresponding
-regular expressions are evaluated on local names of elements and on
-enumeration values, respectively. For example, the following predefined
-regular expression is used to transform parsing function names when the
-.B java
-naming convention is selected:
-
-.B /(.+)/parse\\\\u$1/
-
-See also the REGEX AND SHELL QUOTING section below.
-
-\"
-\" TYPE MAP
-\"
-.SH TYPE MAP
-Type map files are used in C++/Parser to define a mapping between XML
-Schema and C++ types. 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.
-
-The compiler has a set of predefined mapping rules that map built-in
-XML Schema types to suitable C++ types (discussed below) 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_*
-functions. Optional
-.I cxx-arg-type
-is an argument type for callback functions corresponding to elements and
-attributes of this type. 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 that can be
-presented as the following map files. The string-based XML Schema
-built-in types are mapped to either
-.B std::string
-or
-.B std::wstring
-depending on the character type selected with the
-.B --char-type
-option
-.RB ( char
-by default).
-
-.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" "long long";
-.br
-
- negativeInteger "long long" "long long";
-.br
- nonPositiveInteger "long long" "long long";
-.br
-
- positiveInteger "unsigned long long" "unsigned long long";
-.br
- nonNegativeInteger "unsigned long long" "unsigned long long";
-.br
-
- float float float;
-.br
- double double double;
-.br
- decimal double double;
-.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
-
- NMTOKENS xml_schema::string_sequence;
-.br
- IDREFS xml_schema::string_sequence;
-.br
-
- QName xml_schema::qname;
-.br
-
- base64Binary std::auto_ptr<xml_schema::buffer>
-.br
- std::auto_ptr<xml_schema::buffer>;
-.br
- hexBinary std::auto_ptr<xml_schema::buffer>
-.br
- std::auto_ptr<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
-
-
-The last predefined rule 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.
-
-.\"
-.\" 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 xsd
-will issue diagnostic messages to
-.B STDERR
-and exit with non-zero exit code.
-.SH BUGS
-Send bug reports to the xsd-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/xsd.xhtml b/documentation/xsd.xhtml
deleted file mode 100644
index 79dd1fb..0000000
--- a/documentation/xsd.xhtml
+++ /dev/null
@@ -1,1613 +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 4.0.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 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>xsd - W3C XML Schema to C++ Compiler</p>
-
- <h1>SYNOPSIS</h1>
-
- <dl id="synopsis">
- <dt><code><b>xsd</b> <i>command</i> [<i>options</i>] <i>file</i> [<i>file</i> ...]</code></dt>
- <dt><code><b>xsd help</b> [<i>command</i>]</code></dt>
- <dt><code><b>xsd version</b></code></dt>
- </dl>
-
- <h1>DESCRIPTION</h1>
-
- <p><code><b>xsd</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-tree</b></code></dt>
- <dd>Generate the C++/Tree 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> (header file),
- <code><b>name.ixx</b></code> (inline file, generated only if the
- <code><b>--generate-inline</b></code> option is specified),
- <code><b>name.cxx</b></code> (source file), and
- <code><b>name-fwd.hxx</b></code> (forward declaration file, generated
- only if the <code><b>--generate-forward</b></code> option is
- specified).</dd>
-
- <dt><code><b>cxx-parser</b></code></dt>
- <dd>Generate the 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-driver.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>xsd 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>--char-type</b> <i>type</i></code></dt>
- <dd>Generate code using the provided character <code><i>type</i></code>
- instead of the default <code><b>char</b></code>. Valid values
- are <code><b>char</b></code> and <code><b>wchar_t</b></code>.</dd>
-
- <dt><code><b>--char-encoding</b> <i>enc</i></code></dt>
- <dd>Specify the character encoding that should be used in the generated
- code. Valid values for the <code><b>char</b></code> character type
- are <code><b>utf8</b></code> (default), <code><b>iso8859-1</b></code>,
- <code><b>lcp</b></code> (Xerces-C++ local code page), and
- <code><b>custom</b></code>. If you pass <code><b>custom</b></code> as
- the value then you will need to include the transcoder implementation
- header for your encoding at the beginning of the generated header
- files (see the <code><b>--hxx-prologue</b></code> option).
-
- <p>For the <code><b>wchar_t</b></code> character type the only valid
- value is <code><b>auto</b></code> and the encoding is automatically
- selected between UTF-16 and UTF-32/UCS-4, depending on the
- <code><b>wchar_t</b></code> type size.</p></dd>
-
- <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>--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>
-
- <!-- Include -->
-
- <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>
-
- <!-- Suffixes. -->
-
- <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>--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>.
- Note that this expression is also used to construct names for
- included/imported schemas. See also the REGEX AND SHELL QUOTING
- section below.
- </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>.
- 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>.
- See also the REGEX AND SHELL QUOTING section below.
- </dd>
-
-
- <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.
- </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.
- </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.
- </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.
- </dd>
-
- <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.
- </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.
- </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.
- </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.
- </dd>
-
-
- <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.
- </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.
- </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.
- </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.
- </dd>
-
- <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.
- </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.
- </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.
- </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.
- </dd>
-
- <dt><code><b>--custom-literals</b> <i>file</i></code></dt>
- <dd>Load custom XML string to C++ literal mappings from
- <code><i>file</i></code>. This mechanism can be useful if you
- are using a custom character encoding and some of the strings
- in your schemas, for example element/attribute names or enumeration
- values, contain non-ASCII characters. In this case you will need
- to provide a custom mapping to C++ literals for such
- strings. The format of this file is specified in the
- <code><b>custom-literals.xsd</b></code> XML Schema file that
- can be found in the documentation directory.
- </dd>
-
- <dt><code><b>--export-symbol</b> <i>symbol</i></code></dt>
- <dd>Insert <code><i>symbol</i></code> in places where DLL
- export/import control statements
- (<code><b>__declspec(dllexport/dllimport)</b></code>) are necessary.
- </dd>
-
- <dt><code><b>--export-xml-schema</b></code></dt>
- <dd>Export/import types in the XML Schema namespace using the export
- symbol provided with the <code><b>--export-symbol</b></code> option.
- The <code><b>XSD_NO_EXPORT</b></code> macro can be used to omit
- this code during C++ compilation, which may be useful if you
- would like to use the same generated code across multiple platforms.
- </dd>
-
- <dt><code><b>--export-maps</b></code></dt>
- <dd>Export polymorphism support maps from a Win32 DLL into which this
- generated code is linked. This is necessary when your type hierarchy
- is split across several DLLs since otherwise each DLL will have its
- own set of maps. In this situation the generated code for the DLL
- which contains base types and/or substitution group heads should be
- compiled with this option and the generated code for all other
- DLLs should be compiled with <code><b>--import-maps</b></code>.
- This option is only valid together with
- <code><b>--generate-polymorphic</b></code>.
- The <code><b>XSD_NO_EXPORT</b></code> macro can be used to omit
- this code during C++ compilation, which may be useful if you
- would like to use the same generated code across multiple platforms.
- </dd>
-
- <dt><code><b>--import-maps</b></code></dt>
- <dd>Import polymorphism support maps to a Win32 DLL or executable into
- which this generated code is linked. See the <code><b>--export-maps</b></code>
- option documentation for details. This options is only valid together
- with <code><b>--generate-polymorphic</b></code>.
- The <code><b>XSD_NO_EXPORT</b></code> macro can be used to omit
- this code during C++ compilation, which may be useful if you
- would like to use the same generated code across multiple platforms.
- </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 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-TREE COMMAND OPTIONS</h2>
-
- <dl class="options">
- <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> or
- <code><b>--polymorphic-type-all</b></code> option to specify
- which type hierarchies are polymorphic.</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>. The
- <code><i>type</i></code> argument is an XML Schema type name that
- can be optionally qualified with a namespace in the
- <code><i>namespace</i><b>#</b><i>name</i></code> form.</dd>
-
- <dt><code><b>--polymorphic-type-all</b></code></dt>
- <dd>Indicate that all types should be treated as polymorphic.</dd>
-
- <dt><code><b>--generate-serialization</b></code></dt>
- <dd>Generate serialization functions. Serialization functions
- convert the object model back to XML.</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>--generate-ostream</b></code></dt>
- <dd>Generate ostream insertion operators
- (<code><b>operator&lt;&lt;</b></code>) for generated types. This
- allows to easily print a fragment or the whole object model
- for debugging or logging.</dd>
-
- <dt><code><b>--generate-doxygen</b></code></dt>
- <dd>Generate documentation comments suitable for extraction by the
- Doxygen documentation system. Documentation from annotations
- is added to the comments if present in the schema.</dd>
-
- <dt><code><b>--generate-comparison</b></code></dt>
- <dd>Generate comparison operators
- (<code><b>operator==</b></code> and <code><b>operator!=</b></code>)
- for complex types. Comparison is performed memberwise.</dd>
-
- <dt><code><b>--generate-default-ctor</b></code></dt>
- <dd>Generate default constructors even for types that have required
- members. Required members of an instance constructed using such a
- constructor are not initialized and accessing them results in
- undefined behavior.</dd>
-
- <dt><code><b>--generate-from-base-ctor</b></code></dt>
- <dd>Generate constructors that expect an instance of a base type
- followed by all required members.</dd>
-
- <dt><code><b>--suppress-assignment</b></code></dt>
- <dd>Suppress the generation of copy assignment operators for complex
- types. If this option is specified, the copy assignment operators
- for such types are declared private and left unimplemented.</dd>
-
- <dt><code><b>--generate-detach</b></code></dt>
- <dd>Generate detach functions for required elements and attributes
- (detach functions for optional and sequence cardinalities are
- provided by the respective containers). These functions, for
- example, allow you to move sub-trees in the object model either
- within the same tree or between different trees.</dd>
-
- <dt><code><b>--generate-wildcard</b></code></dt>
- <dd>Generate accessors and modifiers as well as parsing and serialization
- code for XML Schema wildcards (<code><b>any</b></code> and
- <code><b>anyAttribute</b></code>). XML content matched by wildcards
- is presented as DOM fragments. Note that you need to initialize the
- Xerces-C++ runtime if you are using this option.</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 ACE CDR stream
- (<code><b>ACE_OutputCDR</b></code>) and RPC XDR are recognized
- by the compiler and the necessary <code><b>#include</b></code>
- directives are automatically generated. For custom stream
- types use the <code><b>--hxx-prologue*</b></code> options
- to provide the necessary declarations.</dd>
-
- <dt><code><b>--generate-extraction</b> <i>is</i></code></dt>
- <dd>Generate data representation stream extraction constructors for
- the <code><i>is</i></code> input stream type. Repeat this
- option to specify more than one stream type. The ACE CDR stream
- (<code><b>ACE_InputCDR</b></code>) and RPC XDR are recognized by
- the compiler and the necessary <code><b>#include</b></code>
- directives are automatically generated. For custom stream
- types use the <code><b>--hxx-prologue*</b></code> options
- to provide the necessary declarations.</dd>
-
- <dt><code><b>--generate-forward</b></code></dt>
- <dd>Generate a separate header file with forward declarations for the
- types being generated.</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 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>--suppress-parsing</b></code></dt>
- <dd>Suppress the generation of the parsing functions and constructors.
- Use this option to reduce the generated code size when parsing
- from XML is not needed.</dd>
-
- <dt><code><b>--generate-element-type</b></code></dt>
- <dd>Generate types instead of parsing and serialization functions
- for root elements. This is primarily useful to distinguish
- object models with the same root type but with different root
- elements.</dd>
-
- <dt><code><b>--generate-element-map</b></code></dt>
- <dd>Generate a root element map that allows uniform parsing and
- serialization of multiple root elements. This option is only
- valid together with <code><b>--generate-element-type</b></code>.
- </dd>
-
- <dt><code><b>--generate-intellisense</b></code></dt>
- <dd>Generate workarounds for IntelliSense bugs in Visual Studio
- 2005 (8.0). When this option is used, the resulting code is
- slightly more verbose. IntelliSense in Visual Studio 2008 (9.0)
- does not require these workarounds. Support for IntelliSense in
- Visual Studio 2003 (7.1) is improved with this option but is
- still incomplete.</dd>
-
- <dt><code><b>--omit-default-attributes</b></code></dt>
- <dd>Omit attributes with default and fixed values from serialized
- XML documents.</dd>
-
- <!-- Naming -->
-
- <dt><code><b>--type-naming</b> <i>style</i></code></dt>
- <dd>Specify the type naming convention that should be used in the
- generated code. Valid styles are <code><b>knr</b></code>
- (default), <code><b>ucc</b></code>, and <code><b>java</b></code>.
- See the NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--function-naming</b> <i>style</i></code></dt>
- <dd>Specify the function naming convention that should be used in the
- generated code. Valid styles are <code><b>knr</b></code>
- (default), <code><b>lcc</b></code>, and <code><b>java</b></code>.
- See the NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--type-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 type names to C++ type names. See the
- NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--accessor-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 names of elements/attributes to C++
- accessor function names. See the NAMING CONVENTION section below
- for more information.
- </dd>
-
- <dt><code><b>--one-accessor-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 names of elements/attributes with
- cardinality one to C++ accessor function names. See the NAMING
- CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--opt-accessor-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 names of elements/attributes with
- cardinality optional to C++ accessor function names. See the
- NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--seq-accessor-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 names of elements/attributes with
- cardinality sequence to C++ accessor function names. See the
- NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--modifier-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 names of elements/attributes to C++
- modifier function names. See the NAMING CONVENTION section below
- for more information.
- </dd>
-
- <dt><code><b>--one-modifier-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 names of elements/attributes with
- cardinality one to C++ modifier function names. See the NAMING
- CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--opt-modifier-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 names of elements/attributes with
- cardinality optional to C++ modifier function names. See the
- NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--seq-modifier-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 names of elements/attributes with
- cardinality sequence to C++ modifier function names. See the
- NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--parser-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 element names to C++ parsing function
- names. See the NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--serializer-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 element names to C++ serialization
- function names. See the NAMING CONVENTION section below for more
- information.
- </dd>
-
- <dt><code><b>--enumerator-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 enumeration values to C++ enumerator
- names. See the NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--element-type-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 element names to C++ element type
- names. See the NAMING CONVENTION section below for more information.
- </dd>
-
- <dt><code><b>--name-regex-trace</b></code></dt>
- <dd>Trace the process of applying regular expressions specified with
- the name transformation options. Use this option to find out why
- your regular expressions don't do what you expected them to do.
- </dd>
-
- <!-- Root element. -->
-
- <dt><code><b>--root-element-first</b></code></dt>
- <dd>Treat only the first global element as a document root. By default
- all global elements are considered document roots.
- </dd>
-
- <dt><code><b>--root-element-last</b></code></dt>
- <dd>Treat only the last global element as a document root. By default
- all global elements are considered document roots.
- </dd>
-
- <dt><code><b>--root-element-all</b></code></dt>
- <dd>Treat all global elements as document roots. This is the default
- behavior. By explicitly specifying this option you can suppress
- the warning that is issued if more than one global element is defined.
- </dd>
-
- <dt><code><b>--root-element-none</b></code></dt>
- <dd>Do not treat any global elements as document roots. By default
- all global elements are considered document roots.
- </dd>
-
- <dt><code><b>--root-element</b> <i>element</i></code></dt>
- <dd>Treat only <code><i>element</i></code> as a document root. Repeat this
- option to specify more than one root element.
- </dd>
-
- <!-- Custom type. -->
-
- <dt><code><b>--custom-type</b>
- <i>name</i>[<b>=</b><i>type</i>[<b>/</b><i>base</i>]]</code></dt>
- <dd>Use a custom C++ type <i>type</i> instead of the generated class for
- XML Schema type <i>name</i>. If <i>type</i> is not present
- or empty then the custom type is assumed to have the same name and
- be defined in the same namespace as the generated class would have.
- If <i>base</i> is specified then the generated class is still
- generated but with that name.
- </dd>
-
- <dt><code><b>--custom-type-regex</b>
- <b>/</b><i>name-pat</i><b>/</b>[<i>type-sub</i><b>/</b>[<i>base-sub</i><b>/</b>]]</code></dt>
- <dd>For each type defined in XML Schema that matches the <i>name-pat</i>
- pattern use a custom C++ type instead of the generated class. The
- name of the custom type is obtained by substituting <i>type-sub</i>.
- If <i>type-sub</i> is not present or its substitution results in an
- empty string then the custom type is assumed to have the same name
- and be defined in the same namespace as the generated class would
- have. If <i>base-sub</i> is present and its substitution results
- in a non-empty string then the generated class is still generated
- but with the result of substitution as its name. The pattern and
- substitutions are in the perl regular expression format. See also
- the REGEX AND SHELL QUOTING section below.
- </dd>
-
- <!-- Suffixes. -->
-
- <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.
- </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. <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>
-
- <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.
- </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.
- </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.
- </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.
- </dd>
-
- <!-- Parts. -->
-
- <dt><code><b>--parts</b> <i>num</i></code></dt>
- <dd>Split generated source code into <code><i>num</i></code> parts. This
- is useful when translating large, monolithic schemas and a C++
- compiler is not able to compile the resulting source code at once
- (usually due to insufficient memory).
- </dd>
-
- <dt><code><b>--parts-suffix</b> <i>suffix</i></code></dt>
- <dd>Use <code><i>suffix</i></code> instead of the default
- '<code><b>-</b></code>' to separate the file name from the
- part number.
- </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>--xml-parser</b> <i>parser</i></code></dt>
- <dd>Use <code><i>parser</i></code> as the underlying XML parser.
- Valid values are <code><b>xerces</b></code> for Xerces-C++ (default)
- and <code><b>expat</b></code> for Expat.</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>--generate-validation</b></code></dt>
- <dd>Generate validation code ("perfect" parser) which ensures that
- instance documents conform to the schema. Validation code is
- generated by default when the selected underlying XML parser
- is non-validating (<code><b>expat</b></code>).</dd>
-
- <dt><code><b>--suppress-validation</b></code></dt>
- <dd>Suppress the generation of validation code ("perfect" parser).
- Validation is suppressed by default when the selected underlying
- XML parser is validating (<code><b>xerces</b></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>--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-driver.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>
-
- <h1>NAMING CONVENTION</h1>
-
- <p>The compiler can be instructed to use a particular naming
- convention in the generated code. A number of widely-used
- conventions can be selected using the <code><b>--type-naming</b></code>
- and <code><b>--function-naming</b></code> options. A custom
- naming convention can be achieved using the
- <code><b>--type-regex</b></code>,
- <code><b>--accessor-regex</b></code>,
- <code><b>--one-accessor-regex</b></code>,
- <code><b>--opt-accessor-regex</b></code>,
- <code><b>--seq-accessor-regex</b></code>,
- <code><b>--modifier-regex</b></code>,
- <code><b>--one-modifier-regex</b></code>,
- <code><b>--opt-modifier-regex</b></code>,
- <code><b>--seq-modifier-regex</b></code>,
- <code><b>--parser-regex</b></code>,
- <code><b>--serializer-regex</b></code>,
- <code><b>--enumerator-regex</b></code>, and
- <code><b>--element-type-regex</b></code> options.
- </p>
-
- <p>The <code><b>--type-naming</b></code> option specifies the
- convention that should be used for naming C++ types. Possible
- values for this option are <code><b>knr</b></code> (default),
- <code><b>ucc</b></code>, and <code><b>java</b></code>. The
- <code><b>knr</b></code> value (stands for K&amp;R) signifies
- the standard, lower-case naming convention with the underscore
- used as a word delimiter, for example: <code>foo</code>,
- <code>foo_bar</code>. The <code><b>ucc</b></code> (stands
- for upper-camel-case) and
- <code><b>java</b></code> values a synonyms for the same
- naming convention where the first letter of each word in the
- name is capitalized, for example: <code>Foo</code>,
- <code>FooBar</code>.</p>
-
- <p>Similarly, the <code><b>--function-naming</b></code> option
- specifies the convention that should be used for naming C++
- functions. Possible values for this option are <code><b>knr</b></code>
- (default), <code><b>lcc</b></code>, and <code><b>java</b></code>. The
- <code><b>knr</b></code> value (stands for K&amp;R) signifies
- the standard, lower-case naming convention with the underscore
- used as a word delimiter, for example: <code>foo()</code>,
- <code>foo_bar()</code>. The <code><b>lcc</b></code> value
- (stands for lower-camel-case) signifies a naming convention
- where the first letter of each word except the first is
- capitalized, for example: <code>foo()</code>, <code>fooBar()</code>.
- The <code><b>java</b></code> naming convention is similar to
- the lower-camel-case one except that accessor functions are prefixed
- with <code>get</code>, modifier functions are prefixed
- with <code>set</code>, parsing functions are prefixed
- with <code>parse</code>, and serialization functions are
- prefixed with <code>serialize</code>, for example:
- <code>getFoo()</code>, <code>setFooBar()</code>,
- <code>parseRoot()</code>, <code>serializeRoot()</code>.</p>
-
- <p>Note that the naming conventions specified with the
- <code><b>--type-naming</b></code> and
- <code><b>--function-naming</b></code> options perform only limited
- transformations on the names that come from the schema in the
- form of type, attribute, and element names. In other words, to
- get consistent results, your schemas should follow a similar
- naming convention as the one you would like to have in the
- generated code. Alternatively, you can use the
- <code><b>--*-regex</b></code> options (discussed below)
- to perform further transformations on the names that come from
- the schema.</p>
-
- <p>The
- <code><b>--type-regex</b></code>,
- <code><b>--accessor-regex</b></code>,
- <code><b>--one-accessor-regex</b></code>,
- <code><b>--opt-accessor-regex</b></code>,
- <code><b>--seq-accessor-regex</b></code>,
- <code><b>--modifier-regex</b></code>,
- <code><b>--one-modifier-regex</b></code>,
- <code><b>--opt-modifier-regex</b></code>,
- <code><b>--seq-modifier-regex</b></code>,
- <code><b>--parser-regex</b></code>,
- <code><b>--serializer-regex</b></code>,
- <code><b>--enumerator-regex</b></code>, and
- <code><b>--element-type-regex</b></code> options allow you to
- specify extra regular expressions for each name category in
- addition to the predefined set that is added depending on
- the <code><b>--type-naming</b></code> and
- <code><b>--function-naming</b></code> options. Expressions
- that are provided with the <code><b>--*-regex</b></code>
- options are evaluated prior to any predefined expressions.
- This allows you to selectively override some or all of the
- predefined transformations. When debugging your own expressions,
- it is often useful to see which expressions match which names.
- The <code><b>--name-regex-trace</b></code> option allows you
- to trace the process of applying regular expressions to
- names.</p>
-
- <p>The value for the <code><b>--*-regex</b></code> options should be
- 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 for each category are pushed into a
- category-specific stack with the last specified expression
- considered first. The first match that succeeds is used. For the
- <code><b>--one-accessor-regex</b></code> (accessors with cardinality one),
- <code><b>--opt-accessor-regex</b></code> (accessors with cardinality optional), and
- <code><b>--seq-accessor-regex</b></code> (accessors with cardinality sequence)
- categories the <code><b>--accessor-regex</b></code> expressions are
- used as a fallback. For the
- <code><b>--one-modifier-regex</b></code>,
- <code><b>--opt-modifier-regex</b></code>, and
- <code><b>--seq-modifier-regex</b></code>
- categories the <code><b>--modifier-regex</b></code> expressions are
- used as a fallback. For the <code><b>--element-type-regex</b></code>
- category the <code><b>--type-regex</b></code> expressions are
- used as a fallback.</p>
-
- <p>The type name expressions (<code><b>--type-regex</b></code>)
- are evaluated on the name string that has the following
- format:</p>
-
- <p><code>[<i>namespace</i> ]<i>name</i>[,<i>name</i>][,<i>name</i>][,<i>name</i>]</code></p>
-
- <p>The element type name expressions
- (<code><b>--element-type-regex</b></code>), effective only when
- the <code><b>--generate-element-type</b></code> option is specified,
- are evaluated on the name string that has the following
- format:</p>
-
- <p><code><i>namespace</i> <i>name</i></code></p>
-
- <p>In the type name format the <code><i>namespace</i></code> part
- followed by a space is only present for global type names. For
- global types and elements defined in schemas without a target
- namespace, the <code><i>namespace</i></code> part is empty but
- the space is still present. In the type name format after the
- initial <code><i>name</i></code> component, up to three additional
- <code><i>name</i></code> components can be present, separated
- by commas. For example:</p>
-
- <p><code><b>http://example.com/hello type</b></code></p>
- <p><code><b>foo</b></code></p>
- <p><code><b>foo,iterator</b></code></p>
- <p><code><b>foo,const,iterator</b></code></p>
-
- <p>The following set of predefined regular expressions is used to
- transform type names when the upper-camel-case naming convention
- is selected:</p>
-
- <p><code><b>/(?:[^ ]* )?([^,]+)/\u$1/</b></code></p>
- <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+)/\u$1\u$2/</b></code></p>
- <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3/</b></code></p>
- <p><code><b>/(?:[^ ]* )?([^,]+),([^,]+),([^,]+),([^,]+)/\u$1\u$2\u$3\u$4/</b></code></p>
-
- <p>The accessor and modifier expressions
- (<code><b>--*accessor-regex</b></code> and
- <code><b>--*modifier-regex</b></code>) are evaluated on the name string
- that has the following format:</p>
-
- <p><code><i>name</i>[,<i>name</i>][,<i>name</i>]</code></p>
-
- <p>After the initial <code><i>name</i></code> component, up to two
- additional <code><i>name</i></code> components can be present,
- separated by commas. For example:</p>
-
- <p><code><b>foo</b></code></p>
- <p><code><b>dom,document</b></code></p>
- <p><code><b>foo,default,value</b></code></p>
-
- <p>The following set of predefined regular expressions is used to
- transform accessor names when the <code><b>java</b></code> naming
- convention is selected:</p>
-
- <p><code><b>/([^,]+)/get\u$1/</b></code></p>
- <p><code><b>/([^,]+),([^,]+)/get\u$1\u$2/</b></code></p>
- <p><code><b>/([^,]+),([^,]+),([^,]+)/get\u$1\u$2\u$3/</b></code></p>
-
- <p>For the parser, serializer, and enumerator categories, the
- corresponding regular expressions are evaluated on local names of
- elements and on enumeration values, respectively. For example, the
- following predefined regular expression is used to transform parsing
- function names when the <code><b>java</b></code> naming convention
- is selected:</p>
-
- <p><code><b>/(.+)/parse\u$1/</b></code></p>
-
- <p>See also the REGEX AND SHELL QUOTING section below.</p>
-
- <h1>TYPE MAP</h1>
-
- <p>Type map files are used in C++/Parser to define a mapping between
- XML Schema and C++ types. 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.</p>
-
- <p>The compiler has a set of predefined mapping rules that map
- built-in XML Schema types to suitable C++ types (discussed
- below) 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>" "</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> functions.
- Optional <code><i>&lt;cxx-arg-type></i></code> is an argument
- type for callback functions corresponding to elements and attributes
- of this type. 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>" "</b></code> or <code><b>&lt; ></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>" "</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 that can be
- presented as the following map files. The string-based XML Schema
- built-in types are mapped to either <code><b>std::string</b></code>
- or <code><b>std::wstring</b></code> depending on the character type
- selected with the <code><b>--char-type</b></code> option
- (<code><b>char</b></code> by default).</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" "long long";
-
- negativeInteger "long long" "long long";
- nonPositiveInteger "long long" "long long";
-
- positiveInteger "unsigned long long" "unsigned long long";
- nonNegativeInteger "unsigned long long" "unsigned long long";
-
- float float float;
- double double double;
- decimal double double;
-
- 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;
-
- NMTOKENS xml_schema::string_sequence;
- IDREFS xml_schema::string_sequence;
-
- QName xml_schema::qname;
-
- base64Binary std::auto_ptr&lt;xml_schema::buffer>
- std::auto_ptr&lt;xml_schema::buffer>;
- hexBinary std::auto_ptr&lt;xml_schema::buffer>
- std::auto_ptr&lt;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>The last predefined rule 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>
-
- <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>xsd</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:xsd-users@codesynthesis.com">xsd-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/xsd/cxx/options.cli b/xsd/cxx/options.cli
new file mode 100644
index 0000000..fa46f96
--- /dev/null
+++ b/xsd/cxx/options.cli
@@ -0,0 +1,463 @@
+// file : xsd/cxx/options.cli
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
+// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <vector>;
+include <string>;
+include <cstddef>; // std::size_t
+
+include <cult/types.hxx>; // NarrowString
+
+include <options.cli>;
+
+namespace CXX
+{
+ class options: ::options = 0
+ {
+ // Character type and encoding.
+ //
+ Cult::Types::NarrowString --char-type = "char"
+ {
+ "<type>",
+ "Generate code using the provided character <type> instead of the
+ default \cb{char}. Valid values are \cb{char} and \cb{wchar_t}."
+ };
+
+ Cult::Types::NarrowString --char-encoding
+ {
+ "<enc>",
+ "Specify the character encoding that should be used in the generated
+ code. Valid values for the \cb{char} character type are \cb{utf8}
+ (default), \cb{iso8859-1}, \cb{lcp} (Xerces-C++ local code page),
+ and \cb{custom}. If you pass \cb{custom} as the value then you will
+ need to include the transcoder implementation header for your
+ encoding at the beginning of the generated header files (see the
+ \cb{--hxx-prologue} option).
+
+ For the \cb{wchar_t} character type the only valid value is \cb{auto}
+ and the encoding is automatically selected between UTF-16 and
+ UTF-32/UCS-4, depending on the \cb{wchar_t} type size."
+ };
+
+ // Output options.
+ //
+ Cult::Types::NarrowString --output-dir
+ {
+ "<dir>",
+ "Write generated files to <dir> instead of the current directory."
+ };
+
+ // Extern XML Schema.
+ //
+ bool --generate-xml-schema
+ {
+ "Generate a C++ header file as if the schema being compiled defines the
+ XML Schema namespace. For the C++/Tree mapping, the resulting file will
+ contain definitions for all XML Schema built-in types. For the
+ C++/Parser mapping, the resulting file will contain definitions for
+ all the 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
+ \cb{--extern-xml-schema} option to include this file in the
+ generated files for other schemas."
+ };
+
+ Cult::Types::NarrowString --extern-xml-schema
+ {
+ "<file>",
+ "Include a header file derived from <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 \cb{--generate-xml-schema} option to generate this
+ header file."
+ };
+
+ // Namespace mapping.
+ //
+ std::vector<Cult::Types::NarrowString> --namespace-map
+ {
+ "<xns>=<cns>",
+ "Map XML Schema namespace <xns> to C++ namespace <cns>. Repeat
+ this option to specify mapping for more than one XML Schema namespace.
+ For example, the following option:
+
+ \cb{--namespace-map http://example.com/foo/bar=foo::bar}
+
+ Will map the \cb{http://example.com/foo/bar} XML Schema namespace to
+ the \cb{foo::bar} C++ namespace."
+ };
+
+ std::vector<Cult::Types::NarrowString> --namespace-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate XML
+ Schema namespace names to C++ namespace names. <regex> is a Perl-like
+ regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be
+ used as a delimiter instead of \cb{/}. Escaping of the delimiter
+ character in \ci{pattern} or \ci{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
+
+ \c{\i{filename} \i{namespace}}
+
+ For example, if you have file \cb{hello.xsd} with namespace
+ \cb{http://example.com/hello} and you run \cb{xsd} on this file,
+ then the string in question will be:
+
+ \cb{hello.xsd. http://example.com/hello}
+
+ For the built-in XML Schema namespace the string is:
+
+ \cb{XMLSchema.xsd http://www.w3.org/2001/XMLSchema}
+
+ The following three steps are performed for each regular expression
+ until the match is found:
+
+ 1. The expression is applied and if the result is empty the next
+ expression is considered.
+
+ 2. All \cb{/} are replaced with \cb{::}.
+
+ 3. The result is verified to be a valid C++ scope name (e.g.,
+ \cb{foo::bar}). If this test succeeds, the result is used as a
+ C++ namespace name.
+
+ As an example, the following expression maps XML Schema namespaces
+ in the form \cb{http://example.com/foo/bar} to C++ namespaces in the
+ form \cb{foo::bar}:
+
+ \cb{%.* http://example.com/(.+)%$1%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --namespace-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--namespace-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+
+ // Reserved names.
+ //
+ std::vector<Cult::Types::NarrowString> --reserved-name
+ {
+ "<n>[=<r>]",
+ "Add name <n> to the list of names that should not be used as
+ identifiers. The name can optionally be followed by \cb{=} and the
+ replacement name <r> that should be used instead. All the C++ keywords
+ are already in this list."
+ };
+
+ // Include options.
+ //
+ bool --include-with-brackets
+ {
+ "Use angle brackets (<>) instead of quotes (\"\") in generated
+ \cb{#include} directives."
+ };
+
+ Cult::Types::NarrowString --include-prefix
+ {
+ "<prefix>",
+ "Add <prefix> to generated \cb{#include} directive paths.
+
+ For example, if you had the following import element in your schema
+
+ \cb{<import namespace=\"...\" schemaLocation=\"base.xsd\"/>}
+
+ and compiled this fragment with \cb{--include-prefix schemas/}, then
+ the include directive in the generated code would be:
+
+ \cb{#include \"schemas/base.hxx\"}"
+ };
+
+ std::vector<Cult::Types::NarrowString> --include-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to transform
+ \cb{#include} directive paths. <regex> is a Perl-like regular
+ expression in the form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+ Any character can be used as a delimiter instead of \cb{/}. Escaping
+ of the delimiter character in \ci{pattern} or \ci{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
+ \cb{schemas/foo/bar} to paths in the form \cb{generated/foo/bar}:
+
+ \cb{%schemas/(.+)%generated/$1%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --include-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--include-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+
+ Cult::Types::NarrowString --guard-prefix
+ {
+ "<prefix>",
+ "Add <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."
+ };
+
+ // File suffixes.
+ //
+ Cult::Types::NarrowString --hxx-suffix = ".hxx"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{.hxx} to
+ construct the name of the header file. Note that this suffix is also
+ used to construct names of header files corresponding to
+ included/imported schemas."
+ };
+
+ Cult::Types::NarrowString --ixx-suffix = ".ixx"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{.ixx} to
+ construct the name of the inline file."
+ };
+
+ Cult::Types::NarrowString --cxx-suffix = ".cxx"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{.cxx} to
+ construct the name of the source file."
+ };
+
+ Cult::Types::NarrowString --fwd-suffix = "-fwd.hxx"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{-fwd.hxx} to
+ construct the name of the forward declaration file."
+ };
+
+ Cult::Types::NarrowString --hxx-regex
+ {
+ "<regex>",
+ "Use the provided expression to construct the name of the header file.
+ <regex> is a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+ Note that this expression is also used to construct names of header
+ files corresponding to included/imported schemas. See also the REGEX
+ AND SHELL QUOTING section below."
+ };
+
+ Cult::Types::NarrowString --ixx-regex
+ {
+ "<regex>",
+ "Use the provided expression to construct the name of the inline file.
+ <regex> is a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND
+ SHELL QUOTING section below."
+ };
+
+ Cult::Types::NarrowString --cxx-regex
+ {
+ "<regex>",
+ "Use the provided expression to construct the name of the source file.
+ <regex> is a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX AND
+ SHELL QUOTING section below."
+ };
+
+ Cult::Types::NarrowString --fwd-regex
+ {
+ "<regex>",
+ "Use the provided expression to construct the name of the forward
+ declaration file. <regex> is a Perl-like regular expression in the
+ form \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. See also the REGEX
+ AND SHELL QUOTING section below."
+ };
+
+ // Prologues/epilogues.
+ //
+ std::vector<Cult::Types::NarrowString> --hxx-prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of the header file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --ixx-prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of the inline file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --cxx-prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of the source file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --fwd-prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of the forward declaration file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of each generated file for which
+ there is no file-specific prologue."
+ };
+
+ std::vector<Cult::Types::NarrowString> --hxx-epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of the header file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --ixx-epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of the inline file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --cxx-epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of the source file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --fwd-epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of the forward declaration file."
+ };
+
+ std::vector<Cult::Types::NarrowString> --epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of each generated file for which there
+ is no file-specific epilogue."
+ };
+
+ Cult::Types::NarrowString --hxx-prologue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the beginning of the header file."
+ };
+
+ Cult::Types::NarrowString --ixx-prologue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the beginning of the inline file."
+ };
+
+ Cult::Types::NarrowString --cxx-prologue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the beginning of the source file."
+ };
+
+ Cult::Types::NarrowString --fwd-prologue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the beginning of the forward
+ declaration file."
+ };
+
+ Cult::Types::NarrowString --prologue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the beginning of each generated
+ file for which there is no file-specific prologue file."
+ };
+
+ Cult::Types::NarrowString --hxx-epilogue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the end of the header file."
+ };
+
+ Cult::Types::NarrowString --ixx-epilogue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the end of the inline file."
+ };
+
+ Cult::Types::NarrowString --cxx-epilogue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the end of the source file."
+ };
+
+ Cult::Types::NarrowString --fwd-epilogue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the end of the forward declaration
+ file."
+ };
+
+ Cult::Types::NarrowString --epilogue-file
+ {
+ "<file>",
+ "Insert the content of the <file> at the end of each generated file
+ for which there is no file-specific epilogue file."
+ };
+
+ // Export options.
+ //
+ Cult::Types::NarrowString --export-symbol
+ {
+ "<symbol>",
+ "Insert <symbol> in places where DLL export/import control statements
+ (\cb{__declspec(dllexport/dllimport)}) are necessary."
+ };
+
+ bool --export-xml-schema
+ {
+ "Export/import types in the XML Schema namespace using the export
+ symbol provided with the \cb{--export-symbol} option. The
+ \cb{XSD_NO_EXPORT} macro can be used to omit this code during C++
+ compilation, which may be useful if you would like to use the same
+ generated code across multiple platforms."
+ };
+
+ bool --export-maps
+ {
+ "Export polymorphism support maps from a Win32 DLL into which this
+ generated code is placed. This is necessary when your type hierarchy
+ is split across several DLLs since otherwise each DLL will have its
+ own set of maps. In this situation the generated code for the DLL
+ which contains base types and/or substitution group heads should be
+ compiled with this option and the generated code for all other DLLs
+ should be compiled with \cb{--import-maps}. This option is only valid
+ together with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT}
+ macro can be used to omit this code during C++ compilation, which may
+ be useful if you would like to use the same generated code across
+ multiple platforms."
+ };
+
+ bool --import-maps
+ {
+ "Import polymorphism support maps to a Win32 DLL or executable into
+ which this generated code is linked. See the \cb{--export-maps}
+ option documentation for details. This options is only valid together
+ with \cb{--generate-polymorphic}. The \cb{XSD_NO_EXPORT} macro can be
+ used to omit this code during C++ compilation, which may be useful if
+ you would like to use the same generated code across multiple
+ platforms."
+ };
+ };
+}
diff --git a/xsd/cxx/parser/generator.cxx b/xsd/cxx/parser/generator.cxx
index 998c480..95a48c5 100644
--- a/xsd/cxx/parser/generator.cxx
+++ b/xsd/cxx/parser/generator.cxx
@@ -16,8 +16,6 @@
#include <cutl/compiler/cxx-indenter.hxx>
#include <cutl/compiler/sloc-counter.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
#include <xsd-frontend/semantic-graph.hxx>
#include <type-map/lexer.hxx>
@@ -45,7 +43,7 @@
#include <cxx/parser/attribute-validation-source.hxx>
#include <cxx/parser/characters-validation-source.hxx>
-#include <usage.hxx>
+#include <cxx/parser/options.hxx>
#include "../../../libxsd/xsd/cxx/version.hxx"
@@ -195,336 +193,8 @@ namespace CXX
Void Parser::Generator::
usage ()
{
- std::wostream& o (wcout);
- ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (o);
-
- o << "--type-map <mapfile>" << endl
- << " Read XML Schema to C++ type mapping information\n"
- << " from <mapfile>. Repeat this option to specify\n"
- << " several type maps. Type maps are considered in\n"
- << " order of appearance and the first match is used."
- << endl;
-
- o << "--char-type <type>" << endl
- << " Use <type> as the base character type. Valid\n"
- << " values are 'char' (default) and 'wchar_t'."
- << endl;
-
- o << "--char-encoding <enc>" << endl
- << " Specify the character encoding that should be used\n"
- << " in the object model. Valid values for the 'char'\n"
- << " character type are 'utf8' (default), 'iso8859-1',\n"
- << " 'lcp', and 'custom'. For the 'wchar_t' character\n"
- << " type the only valid value is 'auto'."
- << endl;
-
- o << "--output-dir <dir>" << endl
- << " Write generated files to <dir> instead of current\n"
- << " directory."
- << endl;
-
- o << "--xml-parser <parser>" << endl
- << " Use <parser> as the underlying XML parser. Valid\n"
- << " values are 'xerces' (default) and 'expat'."
- << endl;
-
- o << "--generate-inline" << endl
- << " Generate certain functions inline."
- << endl;
-
- o << "--generate-validation" << endl
- << " Generate validation code."
- << endl;
-
- o << "--suppress-validation" << endl
- << " Suppress the generation of validation code."
- << endl;
-
- o << "--generate-polymorphic" << endl
- << " Generate polymorphism-aware code. Specify this\n"
- << " option if you use substitution groups or xsi:type."
- << endl;
-
- o << "--generate-noop-impl" << endl
- << " Generate a sample parser implementation that\n"
- << " does nothing (no operation)."
- << endl;
-
- o << "--generate-print-impl" << endl
- << " Generate a sample parser implementation that\n"
- << " prints the XML data to STDOUT."
- << endl;
-
- o << "--generate-test-driver" << endl
- << " Generate a test driver for the sample parser\n"
- << " implementation."
- << endl;
-
- o << "--force-overwrite" << endl
- << " Force overwriting of the existing implementation\n"
- << " and test driver files."
- << endl;
-
- o << "--root-element-first" << endl
- << " Indicate that the first global element is the\n"
- << " document root."
- << endl;
-
- o << "--root-element-last" << endl
- << " Indicate that the last global element is the\n"
- << " document root."
- << endl;
-
- o << "--root-element <element>" << endl
- << " Indicate that <element> is the document root."
- << endl;
-
- o << "--generate-xml-schema" << endl
- << " Generate a C++ header file as if the schema being\n"
- << " compiled defines the XML Schema namespace."
- << endl;
-
- o << "--extern-xml-schema <file>" << endl
- << " Generate code as if the XML Schema namespace was\n"
- << " defined in <file> and xsd:included in the schema\n"
- << " being compiled."
- << endl;
-
- o << "--skel-type-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '_pskel' to\n"
- << " construct the names of generated parser skeletons."
- << endl;
-
- o << "--skel-file-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '-pskel' to\n"
- << " construct the names of generated parser skeleton\n"
- << " files."
- << endl;
-
- o << "--impl-type-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '_pimpl' to\n"
- << " construct the names of parser implementations for\n"
- << " the built-in XML Schema types and sample parser\n"
- << " implementations."
- << endl;
-
- o << "--impl-file-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '-pimpl' to\n"
- << " construct the names of generated sample parser\n"
- << " implementation files."
- << endl;
-
- o << "--namespace-map <xns>=<cns>" << endl
- << " Map XML Schema namespace <xns> to C++ namespace\n"
- << " <cns>. Repeat this option to specify mapping for\n"
- << " more than one XML Schema namespace."
- << endl;
-
- o << "--namespace-regex <regex>" << endl
- << " Add <regex> to the list of regular expressions\n"
- << " used to translate XML Schema namespace names to\n"
- << " C++ namespace names."
- << endl;
-
- o << "--namespace-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --namespace-regex option."
- << endl;
-
- o << "--reserved-name <name>" << endl
- << " Add <name> to the list of names that should not\n"
- << " be used as identifiers. The name can optionally\n"
- << " be followed by '=' and the replacement name that\n"
- << " should be used instead."
- << endl;
-
- o << "--include-with-brackets" << endl
- << " Use angle brackets (<>) instead of quotes (\"\") in\n"
- << " generated #include directives."
- << endl;
-
- o << "--include-prefix <prefix>" << endl
- << " Add <prefix> to generated #include directive\n"
- << " paths."
- << endl;
-
- o << "--include-regex <regex>" << endl
- << " Add <regex> to the list of regular expressions\n"
- << " used to transform #include directive paths."
- << endl;
-
- o << "--include-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --include-regex option."
- << endl;
-
- o << "--guard-prefix <prefix>" << endl
- << " Add <prefix> to generated header inclusion guards."
- << endl;
-
- o << "--hxx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.hxx' to\n"
- << " construct the name of the header file."
- << endl;
-
- o << "--ixx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.ixx' to\n"
- << " construct the name of the inline file."
- << endl;
-
- o << "--cxx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.cxx' to\n"
- << " construct the name of the source file."
- << endl;
-
- o << "--hxx-regex <regex>" << endl
- << " Use <regex> to construct the name of the header\n"
- << " file."
- << endl;
-
- o << "--ixx-regex <regex>" << endl
- << " Use <regex> to construct the name of the inline\n"
- << " file."
- << endl;
-
- o << "--cxx-regex <regex>" << endl
- << " Use <regex> to construct the name of the source\n"
- << " file."
- << endl;
-
-
- // Prologues.
- //
- o << "--hxx-prologue <text>" << endl
- << " Insert <text> at the beginning of the header file."
- << endl;
-
- o << "--ixx-prologue <text>" << endl
- << " Insert <text> at the beginning of the inline file."
- << endl;
-
- o << "--cxx-prologue <text>" << endl
- << " Insert <text> at the beginning of the source file."
- << endl;
-
- o << "--prologue <text>" << endl
- << " Insert <text> at the beginning of each generated\n"
- << " file for which there is no file-specific prologue."
- << endl;
-
-
- // Epilogues.
- //
- o << "--hxx-epilogue <text>" << endl
- << " Insert <text> at the end of the header file."
- << endl;
-
- o << "--ixx-epilogue <text>" << endl
- << " Insert <text> at the end of the inline file."
- << endl;
-
- o << "--cxx-epilogue <text>" << endl
- << " Insert <text> at the end of the source file."
- << endl;
-
- o << "--epilogue <text>" << endl
- << " Insert <text> at the end of each generated file\n"
- << " for which there is no file-specific epilogue."
- << endl;
-
-
- // Prologue files.
- //
- o << "--hxx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the header file."
- << endl;
-
- o << "--ixx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the inline file."
- << endl;
-
- o << "--cxx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the source file."
- << endl;
-
- o << "--prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of each generated file for which there is no file-\n"
- << " specific prologue file."
- << endl;
-
-
- // Epilogue files.
- //
- o << "--hxx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the header file."
- << endl;
-
- o << "--ixx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the inline file."
- << endl;
-
- o << "--cxx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the source file."
- << endl;
-
- o << "--epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " each generated file for which there is no file-\n"
- << " specific epilogue file."
- << endl;
-
-
- // Misc.
- //
- o << "--custom-literals <file>" << endl
- << " Load custom XML string to C++ literal mappings\n"
- << " from <file>."
- << endl;
-
- o << "--export-symbol <symbol>" << endl
- << " Export symbol for Win32 DLL export/import control."
- << endl;
-
- o << "--export-maps" << endl
- << " Export polymorphism support maps from Win32 DLL."
- << endl;
-
- o << "--import-maps" << endl
- << " Import polymorphism support maps from Win32 DLL."
- << endl;
-
- o << "--show-anonymous" << endl
- << " Show elements and attributes that are of anonymous\n"
- << " types."
- << endl;
-
- o << "--show-sloc" << endl
- << " Show the number of generated physical source lines\n"
- << " of code (SLOC)."
- << endl;
-
- o << "--sloc-limit <num>" << endl
- << " Check that the number of generated physical source\n"
- << " lines of code (SLOC) does not exceed <num>."
- << endl;
-
- o << "--options-file <file>" << endl
- << " Read additional options from <file>. Each option\n"
- << " should appear on a separate line optionally\n"
- << " followed by space and an argument."
- << endl;
-
- o << "--proprietary-license" << endl
- << " Indicate that the generated code is licensed under\n"
- << " a proprietary license instead of the GPL."
- << endl;
+ CXX::Parser::options::print_usage (wcout);
+ CXX::options::print_usage (wcout);
}
Parser::CLI::OptionsSpec Parser::Generator::
@@ -625,7 +295,6 @@ namespace CXX
AutoUnlinks& unlinks)
{
using std::ios_base;
- namespace Indentation = BackendElements::Indentation;
typedef cutl::re::regexsub Regex;
diff --git a/xsd/cxx/parser/options.cli b/xsd/cxx/parser/options.cli
new file mode 100644
index 0000000..e40230b
--- /dev/null
+++ b/xsd/cxx/parser/options.cli
@@ -0,0 +1,157 @@
+// file : xsd/cxx/parser/options.cli
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
+// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <vector>;
+include <string>;
+include <cstddef>; // std::size_t
+
+include <cult/types.hxx>; // NarrowString
+
+include <cxx/options.cli>;
+
+namespace CXX
+{
+ namespace Parser
+ {
+ class options: CXX::options
+ {
+ std::vector<Cult::Types::NarrowString> --type-map
+ {
+ "<mapfile>",
+ "Read XML Schema to C++ type mapping information from <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 \cb{void}. See the
+ TYPE MAP section below for more information."
+ };
+
+ Cult::Types::NarrowString --xml-parser = "xerces"
+ {
+ "<parser>",
+ "Use <parser> as the underlying XML parser. Valid values are
+ \cb{xerces} for Xerces-C++ (default) and \cb{expat} for Expat."
+ };
+
+ // Features.
+ //
+ bool --generate-inline
+ {
+ "Generate simple functions inline. This option triggers creation
+ of the inline file."
+ };
+
+ bool --generate-validation
+ {
+ "Generate validation code. The validation code (\"perfect parser\")
+ ensures that instance documents conform to the schema. Validation
+ code is generated by default when the selected underlying XML parser
+ is non-validating (\cb{expat})."
+ };
+
+ bool --suppress-validation
+ {
+ "Suppress the generation of validation code. Validation is suppressed
+ by default when the selected underlying XML parser is validating
+ (\cb{xerces})."
+ };
+
+ bool --generate-polymorphic
+ {
+ "Generate polymorphism-aware code. Specify this option if you use
+ substitution groups or \cb{xsi:type}."
+ };
+
+ bool --generate-noop-impl
+ {
+ "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
+ \cb{name.xsd} this option triggers the generation of two
+ additional C++ files in the form: \cb{name-pimpl.hxx} (parser
+ implementation header file) and \cb{name-pimpl.cxx} (parser
+ implementation source file)."
+ };
+
+ bool --generate-print-impl
+ {
+ "Generate a sample parser implementation that prints the XML data
+ to \c{STDOUT}. For an input file in the form \cb{name.xsd} this
+ option triggers the generation of two additional C++ files in the
+ form: \cb{name-pimpl.hxx} (parser implementation header file) and
+ \cb{name-pimpl.cxx} (parser implementation source file)."
+ };
+
+ bool --generate-test-driver
+ {
+ "Generate a test driver for the sample parser implementation. For an
+ input file in the form \cb{name.xsd} this option triggers the
+ generation of an additional C++ file in the form
+ \cb{name-driver.cxx}."
+ };
+
+ bool --force-overwrite
+ {
+ "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."
+ };
+
+ // Root element.
+ //
+ bool --root-element-first
+ {
+ "Indicate that the first global element is the document root. This
+ information is used to generate the test driver for the sample
+ implementation."
+ };
+
+ bool --root-element-last
+ {
+ "Indicate that the last global element is the document root. This
+ information is used to generate the test driver for the sample
+ implementation."
+ };
+
+ Cult::Types::NarrowString --root-element
+ {
+ "<element>",
+ "Indicate that <element> is the document root. This information is
+ used to generate the test driver for the sample implementation."
+ };
+
+ // Suffixes.
+ //
+ Cult::Types::NarrowString --skel-type-suffix = "_pskel"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{_pskel} to
+ construct the names of the generated parser skeletons."
+ };
+
+ Cult::Types::NarrowString --skel-file-suffix = "-pskel"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{-pskel} to
+ construct the names of the generated parser skeleton files."
+ };
+
+ Cult::Types::NarrowString --impl-type-suffix = "_pimpl"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{_pimpl} to
+ construct the names of the parser implementations for the built-in
+ XML Schema types as well as sample parser implementations."
+ };
+
+ Cult::Types::NarrowString --impl-file-suffix = "-pimpl"
+ {
+ "<suffix>",
+ "Use the provided <suffix> instead of the default \cb{-pimpl} to
+ construct the names of the generated sample parser implementation
+ files."
+ };
+ };
+ }
+}
diff --git a/xsd/cxx/tree/generator.cxx b/xsd/cxx/tree/generator.cxx
index 5fe4af5..7a6759b 100644
--- a/xsd/cxx/tree/generator.cxx
+++ b/xsd/cxx/tree/generator.cxx
@@ -16,8 +16,6 @@
#include <cutl/compiler/cxx-indenter.hxx>
#include <cutl/compiler/sloc-counter.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
#include <xsd-frontend/semantic-graph.hxx>
#include <cxx/tree/generator.hxx>
@@ -47,7 +45,7 @@
#include <cxx/tree/stream-insertion-source.hxx>
#include <cxx/tree/stream-extraction-source.hxx>
-#include <usage.hxx>
+#include <cxx/tree/options.hxx>
#include "../../../libxsd/xsd/cxx/version.hxx"
@@ -223,536 +221,8 @@ namespace CXX
Void Tree::Generator::
usage ()
{
- std::wostream& o (wcout);
- ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (o);
-
- o << "--char-type <type>" << endl
- << " Use <type> as the base character type. Valid\n"
- << " values are 'char' (default) and 'wchar_t'."
- << endl;
-
- o << "--char-encoding <enc>" << endl
- << " Specify the character encoding that should be used\n"
- << " in the object model. Valid values for the 'char'\n"
- << " character type are 'utf8' (default), 'iso8859-1',\n"
- << " 'lcp', and 'custom'. For the 'wchar_t' character\n"
- << " type the only valid value is 'auto'."
- << endl;
-
- o << "--output-dir <dir>" << endl
- << " Write generated files to <dir> instead of current\n"
- << " directory."
- << endl;
-
- o << "--generate-polymorphic" << endl
- << " Generate polymorphism-aware code. Specify this\n"
- << " option if you use substitution groups or xsi:type."
- << endl;
-
- o << "--polymorphic-type <type>" << endl
- << " Indicate that <type> is a root of a polymorphic\n"
- << " type hierarchy."
- << endl;
-
- o << "--polymorphic-type-all" << endl
- << " Indicate that all types should be treated as\n"
- << " polymorphic."
- << endl;
-
- o << "--generate-serialization" << endl
- << " Generate serialization functions. They convert an\n"
- << " in-memory representation back to XML."
- << endl;
-
- o << "--generate-inline" << endl
- << " Generate certain functions inline."
- << endl;
-
- o << "--generate-ostream" << endl
- << " Generate ostream insertion operators."
- << endl;
-
- o << "--generate-doxygen" << endl
- << " Generate documentation comments in the Doxygen\n"
- << " format."
- << endl;
-
- o << "--generate-comparison" << endl
- << " Generate comparison operators."
- << endl;
-
- o << "--generate-default-ctor" << endl
- << " Generate default constructors even for types that\n"
- << " have required members."
- << endl;
-
- o << "--generate-from-base-ctor" << endl
- << " Generate from-base constructors."
- << endl;
-
- o << "--suppress-assignment" << endl
- << " Suppress the generation of copy assignment\n"
- << " operators for complex types."
- << endl;
-
- o << "--generate-detach" << endl
- << " Generate detach functions for required members."
- << endl;
-
- o << "--generate-wildcard" << endl
- << " Generate accessors/modifiers as well as parsing\n"
- << " and serialization code for XML Schema wildcards."
- << endl;
-
- o << "--generate-insertion <os>" << endl
- << " Generate data representation stream insertion\n"
- << " operators for the <os> output stream type."
- << endl;
-
- o << "--generate-extraction <is>" << endl
- << " Generate data representation stream extraction\n"
- << " constructors for the <is> input stream type."
- << endl;
-
- o << "--generate-forward" << endl
- << " Generate forward declaration file."
- << endl;
-
- o << "--generate-xml-schema" << endl
- << " Generate a C++ header file as if the schema being\n"
- << " compiled defines the XML Schema namespace."
- << endl;
-
- o << "--extern-xml-schema <file>" << endl
- << " Generate code as if the XML Schema namespace was\n"
- << " defined in <file> and xsd:included in the schema\n"
- << " being compiled."
- << endl;
-
- o << "--suppress-parsing" << endl
- << " Suppress the generation of parsing functions."
- << endl;
-
- o << "--generate-element-type" << endl
- << " Generate types instead of parsing/serialization\n"
- << " functions for root elements."
- << endl;
-
- o << "--generate-element-map" << endl
- << " Generate a root element map that allows uniform\n"
- << " parsing/serialization of multiple root elements.\n"
- << endl;
-
- o << "--generate-intellisense" << endl
- << " Generate workarounds for IntelliSense bugs in\n"
- << " Visual Studio 2005 (8.0)."
- << endl;
-
- o << "--omit-default-attributes" << endl
- << " Omit attributes with default and fixed values\n"
- << " from serialized XML documents."
- << endl;
-
- o << "--namespace-map <xns>=<cns>" << endl
- << " Map XML Schema namespace <xns> to C++ namespace\n"
- << " <cns>. Repeat this option to specify mapping for\n"
- << " more than one XML Schema namespace."
- << endl;
-
- o << "--namespace-regex <regex>" << endl
- << " Add <regex> to the list of regular expressions\n"
- << " used to translate XML Schema namespace names to\n"
- << " C++ namespace names."
- << endl;
-
- o << "--namespace-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --namespace-regex option."
- << endl;
-
- o << "--reserved-name <name>" << endl
- << " Add <name> to the list of names that should not\n"
- << " be used as identifiers. The name can optionally\n"
- << " be followed by '=' and the replacement name that\n"
- << " should be used instead."
- << endl;
-
- o << "--type-naming <style>" << endl
- << " Specify the type naming convention that should be\n"
- << " used in the generated code. Valid styles are 'knr'\n"
- << " (default), 'ucc', and 'java'."
- << endl;
-
- o << "--function-naming <style>" << endl
- << " Specify the function naming convention that should\n"
- << " be used in the generated code. Valid styles are\n"
- << " 'knr' (default), 'lcc', and 'java'."
- << endl;
-
- o << "--type-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema type names to C++\n"
- << " type names."
- << endl;
-
- o << "--accessor-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements and\n"
- << " attributes to C++ accessor function names."
- << endl;
-
- o << "--one-accessor-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality one to C++\n"
- << " accessor function names."
- << endl;
-
- o << "--opt-accessor-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality optional to C++\n"
- << " accessor function names."
- << endl;
-
- o << "--seq-accessor-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality sequence to C++\n"
- << " accessor function names."
- << endl;
-
- o << "--modifier-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements and\n"
- << " attributes to C++ modifier function names."
- << endl;
-
- o << "--one-modifier-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality one to C++\n"
- << " modifier function names."
- << endl;
-
- o << "--opt-modifier-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality optional to C++\n"
- << " modifier function names."
- << endl;
-
- o << "--seq-modifier-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema names of elements\n"
- << " and attributes with cardinality sequence to C++\n"
- << " modifier function names."
- << endl;
-
- o << "--parser-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema element names to\n"
- << " C++ parsing function names."
- << endl;
-
- o << "--serializer-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema element names to\n"
- << " C++ serialization function names."
- << endl;
-
- o << "--enumerator-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema enumeration values\n"
- << " to C++ enumerator names."
- << endl;
-
- o << "--element-type-regex <expr>" << endl
- << " Add <expr> to the list of regular expressions\n"
- << " used to translate XML Schema element names to\n"
- << " C++ element type names."
- << endl;
-
- o << "--name-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the name transformation options."
- << endl;
-
- o << "--include-with-brackets" << endl
- << " Use angle brackets (<>) instead of quotes (\"\") in\n"
- << " generated #include directives."
- << endl;
-
- o << "--include-prefix <prefix>" << endl
- << " Add <prefix> to generated #include directive\n"
- << " paths."
- << endl;
-
- o << "--include-regex <regex>" << endl
- << " Add <regex> to the list of regular expressions\n"
- << " used to transform #include directive paths."
- << endl;
-
- o << "--include-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --include-regex option."
- << endl;
-
- o << "--guard-prefix <prefix>" << endl
- << " Add <prefix> to generated header inclusion guards."
- << endl;
-
- o << "--root-element-first" << endl
- << " Treat only the first global element as a document\n"
- << " root."
- << endl;
-
- o << "--root-element-last" << endl
- << " Treat only the last global element as a document\n"
- << " root."
- << endl;
-
- o << "--root-element-all" << endl
- << " Treat all global elements as document roots."
- << endl;
-
- o << "--root-element-none" << endl
- << " Don't treat any global elements as document roots."
- << endl;
-
- o << "--root-element <element>" << endl
- << " Treat only <element> as a document root. Repeat\n"
- << " this option to specify more than one root element."
- << endl;
-
- o << "--custom-type <map>" << endl
- << " Use a custom C++ type instead of the generated\n"
- << " class. The <map> argument is in the form\n"
- << " name[=type[/base]], where <name> is a type name as\n"
- << " defined in XML Schema, <type> is a C++ type name\n"
- << " that should be used instead, and optional <base>\n"
- << " is a C++ name that should be given to the C++\n"
- << " class generated from the XML Schema definition\n"
- << " which is normally used as a base for the custom\n"
- << " type."
- << endl;
-
- o << "--custom-type-regex <regex>" << endl
- << " Use custom C++ types instead of the generated\n"
- << " classes. The <regex> argument is in the form\n"
- << " /name/[type/[base/]], where <name> is a regex\n"
- << " pattern that will be matched against type names\n"
- << " as defined in XML Schema, <type> is a C++ type\n"
- << " name that should be used instead, and optional\n"
- << " <base> is a C++ name that should be given to\n"
- << " the C++ class generated from the XML Schema\n"
- << " definition."
- << endl;
-
- o << "--hxx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.hxx' to\n"
- << " construct the name of the header file."
- << endl;
-
- o << "--ixx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.ixx' to\n"
- << " construct the name of the inline file."
- << endl;
-
- o << "--cxx-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '.cxx' to\n"
- << " construct the name of the source file."
- << endl;
-
- o << "--fwd-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '-fwd.hxx'\n"
- << " to construct the name of the forward declaration\n"
- << " file."
- << endl;
-
- o << "--hxx-regex <regex>" << endl
- << " Use <regex> to construct the name of the header\n"
- << " file."
- << endl;
-
- o << "--ixx-regex <regex>" << endl
- << " Use <regex> to construct the name of the inline\n"
- << " file."
- << endl;
-
- o << "--cxx-regex <regex>" << endl
- << " Use <regex> to construct the name of the source\n"
- << " file."
- << endl;
-
- o << "--fwd-regex <regex>" << endl
- << " Use <regex> to construct the name of the forward\n"
- << " declaration file."
- << endl;
-
- // Prologues.
- //
- o << "--hxx-prologue <text>" << endl
- << " Insert <text> at the beginning of the header file."
- << endl;
-
- o << "--ixx-prologue <text>" << endl
- << " Insert <text> at the beginning of the inline file."
- << endl;
-
- o << "--cxx-prologue <text>" << endl
- << " Insert <text> at the beginning of the source file."
- << endl;
-
- o << "--fwd-prologue <text>" << endl
- << " Insert <text> at the beginning of the forward\n"
- << " declaration file."
- << endl;
-
- o << "--prologue <text>" << endl
- << " Insert <text> at the beginning of each generated\n"
- << " file for which there is no file-specific prologue."
- << endl;
-
-
- // Epilogues.
- //
- o << "--hxx-epilogue <text>" << endl
- << " Insert <text> at the end of the header file."
- << endl;
-
- o << "--ixx-epilogue <text>" << endl
- << " Insert <text> at the end of the inline file."
- << endl;
-
- o << "--cxx-epilogue <text>" << endl
- << " Insert <text> at the end of the source file."
- << endl;
-
- o << "--fwd-epilogue <text>" << endl
- << " Insert <text> at the end of the forward\n"
- << " declaration file."
- << endl;
-
- o << "--epilogue <text>" << endl
- << " Insert <text> at the end of each generated file\n"
- << " for which there is no file-specific epilogue."
- << endl;
-
-
- // Prologue files.
- //
- o << "--hxx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the header file."
- << endl;
-
- o << "--ixx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the inline file."
- << endl;
-
- o << "--cxx-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the source file."
- << endl;
-
- o << "--fwd-prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of the forward declaration file."
- << endl;
-
- o << "--prologue-file <file>" << endl
- << " Insert the content of the <file> at the beginning\n"
- << " of each generated file for which there is no file-\n"
- << " specific prologue file."
- << endl;
-
- // Epilogue files.
- //
- o << "--hxx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the header file."
- << endl;
-
- o << "--ixx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the inline file."
- << endl;
-
- o << "--cxx-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the source file."
- << endl;
-
- o << "--fwd-epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " the forward declaration file."
- << endl;
-
- o << "--epilogue-file <file>" << endl
- << " Insert the content of the <file> at the end of\n"
- << " each generated file for which there is no file-\n"
- << " specific epilogue file."
- << endl;
-
- // Misc.
- //
- o << "--parts <num>" << endl
- << " Split generated source code into <num> parts."
- << endl;
-
- o << "--parts-suffix <suffix>" << endl
- << " Use <suffix> instead of the default '-' to\n"
- << " separate the file name from the part number."
- << endl;
-
- o << "--custom-literals <file>" << endl
- << " Load custom XML string to C++ literal mappings\n"
- << " from <file>."
- << endl;
-
- o << "--export-symbol <symbol>" << endl
- << " Export symbol for Win32 DLL export/import control."
- << endl;
-
- o << "--export-xml-schema" << endl
- << " Export/import types in the XML Schema namespace."
- << endl;
-
- o << "--export-maps" << endl
- << " Export polymorphism support maps from Win32 DLL."
- << endl;
-
- o << "--import-maps" << endl
- << " Import polymorphism support maps from Win32 DLL."
- << endl;
-
- o << "--show-anonymous" << endl
- << " Show elements and attributes that are of anonymous\n"
- << " types."
- << endl;
-
- o << "--show-sloc" << endl
- << " Show the number of generated physical source lines\n"
- << " of code (SLOC)."
- << endl;
-
- o << "--sloc-limit <num>" << endl
- << " Check that the number of generated physical source\n"
- << " lines of code (SLOC) does not exceed <num>."
- << endl;
-
- o << "--options-file <file>" << endl
- << " Read additional options from <file>. Each option\n"
- << " should appear on a separate line optionally\n"
- << " followed by space and an argument."
- << endl;
-
- o << "--proprietary-license" << endl
- << " Indicate that the generated code is licensed under\n"
- << " a proprietary license instead of the GPL."
- << endl;
+ CXX::Tree::options::print_usage (wcout);
+ CXX::options::print_usage (wcout);
}
Tree::CLI::OptionsSpec Tree::Generator::
@@ -852,7 +322,6 @@ namespace CXX
AutoUnlinks& unlinks)
{
using std::ios_base;
- namespace Indentation = BackendElements::Indentation;
typedef cutl::re::regexsub Regex;
diff --git a/xsd/cxx/tree/options.cli b/xsd/cxx/tree/options.cli
new file mode 100644
index 0000000..58407fa
--- /dev/null
+++ b/xsd/cxx/tree/options.cli
@@ -0,0 +1,415 @@
+// file : xsd/cxx/tree/options.cli
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
+// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <vector>;
+include <string>;
+include <cstddef>; // std::size_t
+
+include <cult/types.hxx>; // NarrowString
+
+include <cxx/options.cli>;
+
+namespace CXX
+{
+ namespace Tree
+ {
+ class options: CXX::options
+ {
+ // Polymorphism.
+ //
+ bool --generate-polymorphic
+ {
+ "Generate polymorphism-aware code. Specify this option if you use
+ substitution groups or \cb{xsi:type}. Use the \cb{--polymorphic-type}
+ or \cb{--polymorphic-type-all} option to specify which type
+ hierarchies are polymorphic."
+ };
+
+ std::vector<Cult::Types::NarrowString> --polymorphic-type
+ {
+ "<type>",
+ "Indicate that <type> is a root of a polymorphic type hierarchy. The
+ compiler can often automatically determine which types are
+ polymorphic based on the substitution group declarations. However,
+ you may need to use this option if you are not using substitution
+ groups or if substitution groups are defined in another schema. You
+ need to specify this option when compiling every schema file that
+ references <type>. The <type> argument is an XML Schema type name
+ that can be optionally qualified with a namespace in the
+ \c{\i{namespace}\b{#}\i{name}} form."
+ };
+
+ bool --polymorphic-type-all
+ {
+ "Indicate that all types should be treated as polymorphic."
+ };
+
+
+ // Features.
+ //
+ bool --generate-serialization
+ {
+ "Generate serialization functions. Serialization functions convert
+ the object model back to XML."
+ };
+
+ bool --generate-inline
+ {
+ "Generate simple functions inline. This option triggers creation of
+ the inline file."
+ };
+
+ bool --generate-ostream
+ {
+ "Generate ostream insertion operators (\cb{operator<<}) for generated
+ types. This allows one to easily print a fragment or the whole object
+ model for debugging or logging."
+ };
+
+ bool --generate-doxygen
+ {
+ "Generate documentation comments suitable for extraction by the
+ Doxygen documentation system. Documentation from annotations is
+ added to the comments if present in the schema."
+ };
+
+ bool --generate-comparison
+ {
+ "Generate comparison operators (\cb{operator==} and \cb{operator!=})
+ for complex types. Comparison is performed member-wise."
+ };
+
+ bool --generate-default-ctor
+ {
+ "Generate default constructors even for types that have required
+ members. Required members of an instance constructed using such a
+ constructor are not initialized and accessing them results in
+ undefined behavior."
+ };
+
+ bool --generate-from-base-ctor
+ {
+ "Generate constructors that expect an instance of a base type
+ followed by all required members."
+ };
+
+ bool --suppress-assignment
+ {
+ "Suppress the generation of copy assignment operators for complex
+ types. If this option is specified, the copy assignment operators
+ for such types are declared private and left unimplemented."
+ };
+
+ bool --generate-detach
+ {
+ "Generate detach functions for required elements and attributes.
+ Detach functions for optional and sequence cardinalities are
+ provided by the respective containers. These functions, for
+ example, allow you to move sub-trees in the object model either
+ within the same tree or between different trees."
+ };
+
+ bool --generate-wildcard
+ {
+ "Generate accessors and modifiers as well as parsing and serialization
+ code for XML Schema wildcards (\cb{any} and \cb{anyAttribute}). XML
+ content matched by wildcards is presented as DOM fragments. Note
+ that you need to initialize the Xerces-C++ runtime if you are using
+ this option."
+ };
+
+ std::vector<Cult::Types::NarrowString> --generate-insertion
+ {
+ "<os>",
+ "Generate data representation stream insertion operators for the <os>
+ output stream type. Repeat this option to specify more than one
+ stream type. The ACE CDR stream (\cb{ACE_OutputCDR}) and RPC XDR
+ are recognized by the compiler and the necessary \cb{#include}
+ directives are automatically generated. For custom stream types use
+ the \cb{--hxx-prologue*} options to provide the necessary
+ declarations."
+ };
+
+ std::vector<Cult::Types::NarrowString> --generate-extraction
+ {
+ "<is>",
+ "Generate data representation stream extraction constructors for the
+ <is> input stream type. Repeat this option to specify more than one
+ stream type. The ACE CDR stream (\cb{ACE_InputCDR}) and RPC XDR are
+ recognized by the compiler and the necessary \cb{#include} directives
+ are automatically generated. For custom stream types use the
+ \cb{--hxx-prologue*} options to provide the necessary declarations."
+ };
+
+ bool --generate-forward
+ {
+ "Generate a separate header file with forward declarations for the
+ types being generated."
+ };
+
+ bool --suppress-parsing
+ {
+ "Suppress the generation of the parsing functions and constructors.
+ Use this option to reduce the generated code size when parsing from
+ XML is not needed."
+ };
+
+ bool --generate-element-type
+ {
+ "Generate types instead of parsing and serialization functions for
+ root elements. This is primarily useful to distinguish object models
+ with the same root type but with different root elements."
+ };
+
+ bool --generate-element-map
+ {
+ "Generate a root element map that allows uniform parsing and
+ serialization of multiple root elements. This option is only valid
+ together with \cb{--generate-element-type}."
+ };
+
+ bool --generate-intellisense
+ {
+ "Generate workarounds for IntelliSense bugs in Visual Studio 2005
+ (8.0). When this option is used, the resulting code is slightly
+ more verbose. IntelliSense in Visual Studio 2008 (9.0) and later
+ does not require these workarounds. Support for IntelliSense in
+ Visual Studio 2003 (7.1) is improved with this option but is
+ still incomplete."
+ };
+
+ bool --omit-default-attributes
+ {
+ "Omit attributes with default and fixed values from serialized XML
+ documents."
+ };
+
+ // Naming.
+ //
+ Cult::Types::NarrowString --type-naming = "knr"
+ {
+ "<style>",
+ "Specify the type naming convention that should be used in the
+ generated code. Valid styles are \cb{knr} (default), \cb{ucc},
+ and \cb{java}. See the NAMING CONVENTION section below for more
+ information."
+ };
+
+ Cult::Types::NarrowString --function-naming = "knr"
+ {
+ "<style>",
+ "Specify the function naming convention that should be used in the
+ generated code. Valid styles are \cb{knr} (default), \cb{lcc}, and
+ \cb{java}. See the NAMING CONVENTION section below for more
+ information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --type-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema type names to C++ type names. See the NAMING CONVENTION
+ section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --accessor-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes to C++ accessor function
+ names. See the NAMING CONVENTION section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --one-accessor-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality one to
+ C++ accessor function names. See the NAMING CONVENTION section
+ below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --opt-accessor-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality optional
+ to C++ accessor function names. See the NAMING CONVENTION section
+ below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --seq-accessor-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality sequence
+ to C++ accessor function names. See the NAMING CONVENTION section
+ below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --modifier-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes to C++ modifier function
+ names. See the NAMING CONVENTION section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --one-modifier-regex
+
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality one to C++
+ modifier function names. See the NAMING CONVENTION section below
+ for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --opt-modifier-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality optional
+ to C++ modifier function names. See the NAMING CONVENTION section
+ below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --seq-modifier-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema names of elements/attributes with cardinality sequence
+ to C++ modifier function names. See the NAMING CONVENTION section
+ below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --parser-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema element names to C++ parsing function names. See the
+ NAMING CONVENTION section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --serializer-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema element names to C++ serialization function names. See
+ the NAMING CONVENTION section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --enumerator-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema enumeration values to C++ enumerator names. See the
+ NAMING CONVENTION section below for more information."
+ };
+
+ std::vector<Cult::Types::NarrowString> --element-type-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate
+ XML Schema element names to C++ element type names. See the NAMING
+ CONVENTION section below for more information."
+ };
+
+ bool --name-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with
+ the name transformation options. Use this option to find out why
+ your regular expressions don't do what you expected them to do."
+ };
+
+ // Root element.
+ //
+ bool --root-element-first
+ {
+ "Treat only the first global element as a document root. By default
+ all global elements are considered document roots."
+ };
+
+ bool --root-element-last
+ {
+ "Treat only the last global element as a document root. By default
+ all global elements are considered document roots."
+ };
+
+ bool --root-element-all
+ {
+ "Treat all global elements as document roots. This is the default
+ behavior. By explicitly specifying this option you can suppress
+ the warning that is issued if more than one global element is
+ defined."
+ };
+
+ bool --root-element-none
+ {
+ "Do not treat any global elements as document roots. By default all
+ global elements are considered document roots."
+ };
+
+ std::vector<Cult::Types::NarrowString> --root-element
+ {
+ "<element>",
+ "Treat only <element> as a document root. Repeat this option to
+ specify more than one root element."
+ };
+
+ // Custom type.
+ //
+ std::vector<Cult::Types::NarrowString> --custom-type
+ {
+ "<map>",
+ "Use a custom C++ type instead of the generated class. The <map>
+ argument is in the form \c{\i{name}[\b{=}\i{type}[\b{/}\i{base}]]},
+ where \i{name} is a type name as defined in XML Schema and \i{type}
+ is a C++ type name that should be used instead. If \i{type} is not
+ present or empty then the custom type is assumed to have the same
+ name and be defined in the same namespace as the generated class
+ would have. If \i{base} is specified then the generated class is
+ still generated but with that name."
+ };
+
+ std::vector<Cult::Types::NarrowString> --custom-type-regex
+ {
+ "<regex>",
+ "Use custom C++ types instead of the generated classes. The <regex>
+ argument is in the form
+ \c{\b{/}\i{name-pat}\b{/}[\i{type-sub}\b{/}[\i{base-sub}\b{/}]]},
+ where \i{name-pat} is a regex pattern that will be matched against
+ type names as defined in XML Schema and \i{type-sub} is a C++ type
+ name substitution that should be used instead. If \i{type-sub} is
+ not present or its substitution results in an empty string then
+ the custom type is assumed to have the same name and be defined
+ in the same namespace as the generated class would have. If
+ \i{base-sub} is present and its substitution results in a
+ non-empty string then the generated class is still generated
+ but with the result of this substitution as its name. The pattern
+ and substitutions are in the Perl regular expression format.
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ // Parts.
+ //
+ std::size_t --parts = 1
+ {
+ "<num>",
+ "Split generated source code into <num> parts. This is useful when
+ translating large, monolithic schemas and a C++ compiler is not
+ able to compile the resulting source code at once (usually due
+ to insufficient memory)."
+ };
+
+ Cult::Types::NarrowString --parts-suffix = "-"
+ {
+ "<suffix>",
+ "Use <suffix> instead of the default '\cb{-}' to separate the file
+ name from the part number."
+ };
+ };
+ }
+}
diff --git a/xsd/makefile b/xsd/makefile
index e2d00ea..59fa51a 100644
--- a/xsd/makefile
+++ b/xsd/makefile
@@ -49,18 +49,24 @@ cxx_tun += cxx/tree/elements.cxx \
cxx/tree/stream-extraction-source.cxx
-# Type map
+# Type map.
#
cxx_tun += type-map/lexer.cxx \
type-map/parser.cxx
-# Processing
+# Processing.
#
cxx_tun += processing/cardinality/processor.cxx \
processing/inheritance/processor.cxx
+# Options file.
+#
+cli_tun := options.cli \
+ cxx/options.cli \
+ cxx/tree/options.cli \
+ cxx/parser/options.cli
-cxx_obj := $(addprefix $(out_base)/,$(cxx_tun:.cxx=.o))
+cxx_obj := $(addprefix $(out_base)/,$(cxx_tun:.cxx=.o) $(cli_tun:.cli=.o))
cxx_od := $(cxx_obj:.o=.o.d)
xsd := $(out_base)/xsd
@@ -72,6 +78,10 @@ clean := $(out_base)/.clean
# Import.
#
$(call import,\
+ $(scf_root)/import/cli/stub.make,\
+ cli: cli,cli-rules: cli_rules)
+
+$(call import,\
$(scf_root)/import/libcutl/stub.make,\
l: cutl.l,cpp-options: cutl.l.cpp-options)
@@ -80,10 +90,6 @@ $(call import,\
l: cult.l,cpp-options: cult.l.cpp-options)
$(call import,\
- $(scf_root)/import/libbackend-elements/stub.make,\
- l: be.l,cpp-options: be.l.cpp-options)
-
-$(call import,\
$(scf_root)/import/libboost/filesystem/stub.make,\
l: fs.l,cpp-options: fs.l.cpp-options)
@@ -97,18 +103,48 @@ $(call import,\
# Build.
#
-$(xsd): $(cxx_obj) $(xsd_fe.l) $(be.l) $(cult.l) $(cutl.l) $(fs.l) $(xerces_c.l)
+$(xsd): $(cxx_obj) $(xsd_fe.l) $(cult.l) $(cutl.l) $(fs.l) $(xerces_c.l)
$(cxx_obj) $(cxx_od): cpp_options := -I$(src_base)
$(cxx_obj) $(cxx_od): \
$(xsd_fe.l.cpp-options) \
- $(be.l.cpp-options) \
$(cult.l.cpp-options) \
$(cutl.l.cpp-options) \
$(fs.l.cpp-options) \
$(xerces_c.l.cpp-options)
-$(call include-dep,$(cxx_od))
+genf := $(cli_tun:.cli=.hxx) $(cli_tun:.cli=.ixx) $(cli_tun:.cli=.cxx)
+gen := $(addprefix $(out_base)/,$(genf))
+
+$(gen): $(cli)
+$(gen): cli := $(cli)
+$(gen): cli_options += \
+-I $(src_base) \
+--ostream-type ::std::wostream \
+--exclude-base \
+--suppress-undocumented \
+--generate-file-scanner \
+--include-with-brackets \
+--option-length 28
+
+#--include-prefix xsd
+#--guard-prefix XSD
+
+$(addprefix $(out_base)/cxx/options,.hxx .ixx .cxx): $(src_base)/options.cli
+$(addprefix $(out_base)/cxx/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx --guard-prefix CXX
+
+$(addprefix $(out_base)/cxx/tree/options,.hxx .ixx .cxx): \
+$(src_base)/options.cli $(src_base)/cxx/options.cli
+$(addprefix $(out_base)/cxx/tree/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx/tree --guard-prefix CXX_TREE
+
+$(addprefix $(out_base)/cxx/parser/options,.hxx .ixx .cxx): \
+$(src_base)/options.cli $(src_base)/cxx/options.cli
+$(addprefix $(out_base)/cxx/parser/options,.hxx .ixx .cxx): cli_options += \
+--include-prefix cxx/parser --guard-prefix CXX_PARSER
+
+$(call include-dep,$(cxx_od),$(cxx_obj),$(gen))
# Alias for default target.
#
@@ -132,14 +168,15 @@ $(dist-win): $(xsd)
$(clean): \
$(xsd).o.clean \
$(addsuffix .cxx.clean,$(cxx_obj)) \
- $(addsuffix .cxx.clean,$(cxx_od))
+ $(addsuffix .cxx.clean,$(cxx_od)) \
+ $(addprefix $(out_base)/,$(cli_tun:.cli=.cxx.cli.clean))
# Generated .gitignore.
#
ifeq ($(out_base),$(src_base))
$(xsd): | $(out_base)/.gitignore
-$(out_base)/.gitignore: files := xsd
+$(out_base)/.gitignore: files := xsd $(genf)
$(clean): $(out_base)/.gitignore.clean
$(call include,$(bld_root)/git/gitignore.make)
@@ -147,6 +184,7 @@ endif
# How to.
#
+$(call include,$(cli_rules))
$(call include,$(bld_root)/cxx/o-e.make)
$(call include,$(bld_root)/cxx/cxx-o.make)
$(call include,$(bld_root)/cxx/cxx-d.make)
diff --git a/xsd/options.cli b/xsd/options.cli
new file mode 100644
index 0000000..44223b9
--- /dev/null
+++ b/xsd/options.cli
@@ -0,0 +1,315 @@
+// file : xsd/options.cli
+// author : Boris Kolpackov <boris@codesynthesis.com>
+// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
+// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
+
+include <vector>;
+include <string>;
+include <cstddef>; // std::size_t
+
+include <cult/types.hxx>; // NarrowString
+
+class help_options
+{
+ // These are all documented elsewhere.
+ //
+ bool --help;
+ bool --version;
+ bool --proprietary-license;
+};
+
+class options = 0
+{
+ std::vector<Cult::Types::NarrowString> --disable-warning
+ {
+ "<warn>",
+ "Disable printing warning with id <warn>. If \cb{all} is specified for
+ the warning id then all warnings are disabled."
+ };
+
+ // The following option is "fake" in that it is actually handled by
+ // argv_file_scanner. We have it here to get the documentation.
+ //
+ std::string --options-file
+ {
+ "<file>",
+ "Read additional options from <file>. Each option should appearing on a
+ separate line optionally followed by space and an option value. Empty
+ lines and lines starting with \cb{#} are ignored. Option values can
+ be enclosed in double (\cb{\"}) or single (\cb{'}) quotes to preserve
+ leading and trailing whitespaces as well as to specify empty values.
+ If the value itself contains trailing or leading quotes, enclose it
+ with an extra pair of quotes, for example \cb{'\"x\"'}. Non-leading
+ and non-trailing quotes are interpreted as being part of the option
+ value.
+
+ The semantics of providing options in a file is equivalent to providing
+ the same set of options in the same order on the command line at the
+ point where the \cb{--options-file} option is specified except that
+ the shell escaping and quoting is not required. You can repeat this
+ option to specify more than one options file."
+ };
+
+ // SLOC/license options.
+ //
+ bool --show-sloc
+ {
+ "Show the number of generated physical source lines of code (SLOC)."
+ };
+
+ std::size_t --sloc-limit
+ {
+ "<num>",
+ "Check that the number of generated physical source lines of code (SLOC)
+ does not exceed <num>."
+ };
+
+ bool --proprietary-license
+ {
+ "Indicate that the generated code is licensed under a proprietary
+ license instead of the GPL."
+ };
+
+ std::vector<Cult::Types::NarrowString> --custom-literals
+ {
+ "<file>",
+ "Load custom XML string to C++ literal mappings from <file>. This
+ mechanism can be useful if you are using a custom character encoding
+ and some of the strings in your schemas, for example element/attribute
+ names or enumeration values, contain non-ASCII characters. In this
+ case you will need to provide a custom mapping to C++ literals for
+ such strings. The format of this file is specified in the
+ \cb{custom-literals.xsd} XML Schema file that can be found in the
+ documentation directory."
+ };
+
+ // Anonymous type morphing.
+ //
+ bool --preserve-anonymous
+ {
+ "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."
+ };
+
+ bool --show-anonymous
+ {
+ "Show elements and attributes that are of anonymous types. This option
+ only makes sense together with the \cb{--preserve-anonymous} option."
+ };
+
+ std::vector<Cult::Types::NarrowString> --anonymous-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to derive names for
+ anonymous types from the enclosing attributes/elements. <regex> is a
+ Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}.
+ Any character can be used as a delimiter instead of \cb{/}. Escaping of
+ the delimiter character in \ci{pattern} or \ci{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
+
+ \c{\i{filename} \i{namespace} \i{xpath}}
+
+ For instance:
+
+ \cb{hello.xsd http://example.com/hello element}
+
+ \cb{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:
+
+ \cb{%.* .* (.+/)*(.+)%\\u$2%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --anonymous-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--anonymous-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+
+ bool --morph-anonymous; // Deprecated and therefore undocumented.
+
+ // Location options.
+ //
+ std::vector<Cult::Types::NarrowString> --location-map
+ {
+ "<ol>=<nl>",
+ "Map the original schema location <ol> that is specified in the XML
+ Schema include or import elements to new schema location <nl>. Repeat
+ this option to map more than one schema location. For example, the
+ following option maps the \cb{http://example.com/foo.xsd} URL to the
+ \cb{foo.xsd} local file.
+
+ \cb{--location-map http://example.com/foo.xsd=foo.xsd}"
+ };
+
+ std::vector<Cult::Types::NarrowString> --location-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to map schema
+ locations that are specified in the XML Schema include or import
+ elements. <regex> is a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can
+ be used as a delimiter instead of \cb{/}. Escaping of the delimiter
+ character in \ci{pattern} or \ci{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
+ \cb{http://example.com/foo/bar.xsd} to local files in the form
+ \cb{bar.xsd}:
+
+ \cb{%http://.+/(.+)%$1%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --location-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--location-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+
+ // File-per-type option.
+ //
+ bool --file-per-type
+ {
+ "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: \cb{--type-file-regex}, \cb{--schema-file-regex},
+ \cb{--fat-type-file}, and \cb{--file-list}."
+ };
+
+ std::vector<Cult::Types::NarrowString> --type-file-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate type
+ names to file names when the \cb{--file-per-type} option is specified.
+ <regex> is a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be
+ used as a delimiter instead of \cb{/}. Escaping of the delimiter
+ character in \ci{pattern} or \ci{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
+
+ \c{\i{namespace} \i{type-name}}
+
+ For example, the following expression maps type \cb{foo} that is
+ defined in the \cb{http://example.com/bar} namespace to file name
+ \cb{bar-foo}:
+
+ \cb{%http://example.com/(.+) (.+)%$1-$2%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --type-file-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--type-file-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+ std::vector<Cult::Types::NarrowString> --schema-file-regex
+ {
+ "<regex>",
+ "Add <regex> to the list of regular expressions used to translate schema
+ file names when the \cb{--file-per-type} option is specified. <regex> is
+ a Perl-like regular expression in the form
+ \c{\b{/}\i{pattern}\b{/}\i{replacement}\b{/}}. Any character can be used
+ as a delimiter instead of \cb{/}. Escaping of the delimiter character in
+ \ci{pattern} or \ci{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 \cb{#include} directive paths as well as the generated C++ file
+ paths. This option, along with \cb{--type-file-regex} are primarily
+ useful to place the generated files into subdirectories or to resolve
+ file name conflicts.
+
+ For example, the following expression maps schema files in the
+ \cb{foo/1.0.0/} subdirectory to the files in the \cb{foo/} subdirectory.
+ As a result, the \cb{#include} directive paths for such schemas will be
+ in the \cb{foo/schema.hxx} form and the generated C++ files will be
+ placed into the \cb{foo/} subdirectory:
+
+ \cb{%.*/foo/1.0.0/(.+)%foo/$1%}
+
+ See also the REGEX AND SHELL QUOTING section below."
+ };
+
+ bool --schema-file-regex-trace
+ {
+ "Trace the process of applying regular expressions specified with the
+ \cb{--schema-file-regex} option. Use this option to find out why your
+ regular expressions don't do what you expected them to do."
+ };
+
+ bool --fat-type-file
+ {
+ "Generate code corresponding to global elements into type files instead
+ of schema files when the \cb{--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."
+ };
+
+ // File list options.
+ //
+ Cult::Types::NarrowString --file-list
+ {
+ "<file>",
+ "Write a list of generated C++ files to <file>. This option is primarily
+ useful in the file-per-type compilation mode (\cb{--file-per-type}) to
+ create a list of generated C++ files, for example, as a makefile
+ fragment."
+ };
+
+ Cult::Types::NarrowString --file-list-prologue
+ {
+ "<text>",
+ "Insert <text> at the beginning of the file list. As a convenience, all
+ occurrences of the \cb{\\n} character sequence in <text> are replaced
+ with new lines. This option can, for example, be used to assign the
+ generated file list to a makefile variable."
+ };
+
+ Cult::Types::NarrowString --file-list-epilogue
+ {
+ "<text>",
+ "Insert <text> at the end of the file list. As a convenience, all
+ occurrences of the \cb{\\n} character sequence in <text> are replaced
+ with new lines."
+ };
+
+ Cult::Types::NarrowString --file-list-delim = "\n"
+ {
+ "<text>",
+ "Delimit file names written to the file list with <text> instead of new
+ lines. As a convenience, all occurrences of the \cb{\\n} character
+ sequence in <text> are replaced with new lines."
+ };
+
+ // Undocumented.
+ //
+ bool --disable-multi-import;
+ bool --disable-full-check;
+};
diff --git a/xsd/usage.hxx b/xsd/usage.hxx
deleted file mode 100644
index ca07b07..0000000
--- a/xsd/usage.hxx
+++ /dev/null
@@ -1,226 +0,0 @@
-// file : xsd/usage.hxx
-// author : Boris Kolpackov <boris@codesynthesis.com>
-// copyright : Copyright (c) 2005-2011 Code Synthesis Tools CC
-// license : GNU GPL v2 + exceptions; see accompanying LICENSE file
-
-#ifndef USAGE_HXX
-#define USAGE_HXX
-
-#include <cult/types.hxx>
-
-#include <backend-elements/indentation/buffer.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
-namespace CLI
-{
- using namespace Cult::Types;
-
- template <typename C>
- class OptionsUsage: public BackendElements::Indentation::Buffer<C>
- {
- typedef BackendElements::Indentation::Buffer<C> Buffer;
-
- public:
- typedef
- typename Buffer::Traits
- Traits;
-
- typedef
- typename Buffer::AsChar
- AsChar;
-
- typedef
- typename Buffer::AsInt
- AsInt;
-
- typedef
- typename Buffer::Write
- Write;
-
- public:
- OptionsUsage (Buffer& out)
- : out_ (out),
- option_length_ (0),
- construct_ (Construct::newline)
- {
- }
-
- public:
- virtual AsInt
- put (AsChar c)
- {
- AsInt result (Traits::to_int_type (c));
-
- try
- {
- switch (c)
- {
- case '\n':
- {
- switch (construct_)
- {
- case Construct::newline:
- {
- result = out_.put (c);
- break;
- }
- case Construct::option:
- {
- construct_ = Construct::newline;
- break;
- }
- case Construct::description:
- {
- result = out_.put (c);
- construct_ = Construct::newline;
- break;
- }
- default:
- {
- abort ();
- }
- }
-
- break;
- }
- case '-':
- {
- switch (construct_)
- {
- case Construct::newline:
- {
- construct_ = Construct::option;
-
- option_length_ = 0;
-
- output_indentation ();
- result = out_.put (c);
-
- ++option_length_;
-
- break;
- }
- case Construct::option:
- {
- ++option_length_;
- //fall through
- }
- case Construct::description:
- {
- result = out_.put (c);
- break;
- }
- default:
- {
- abort ();
- }
- }
-
- break;
- }
- default:
- {
- switch (construct_)
- {
- case Construct::newline:
- {
- construct_ = Construct::description;
-
- output_indentation ();
-
- result = out_.put (c);
- break;
- }
- case Construct::option:
- {
- ++option_length_;
- //fall through
- }
- default:
- {
- result = out_.put (c);
- break;
- }
- }
-
- break;
- }
- }
- }
- catch (Write const&)
- {
- result = Traits::eof ();
- }
-
- return result;
- }
-
- virtual Void
- unbuffer ()
- {
- }
-
- private:
- Void
- output_indentation ()
- {
- UnsignedLong spaces;
-
- switch (construct_)
- {
- case Construct::option:
- {
- spaces = 2;
- option_length_ += 2;
- break;
- }
- case Construct::description:
- {
- spaces = 29;
-
- if (option_length_)
- {
- if (option_length_ > spaces)
- spaces = 1;
- else
- spaces -= option_length_;
-
- option_length_ = 0;
- }
-
- break;
- }
- default:
- {
- abort ();
- }
- }
-
- while (spaces--)
- out_.put (' ');
- }
-
- private:
- Buffer& out_;
- UnsignedLong option_length_;
-
- struct Construct
- {
- enum Value
- {
- newline,
- option,
- description
- };
- };
-
- typename Construct::Value construct_;
- };
-
- //@@ rename Indentation to Indent in be?
- //
- namespace Indent = BackendElements::Indentation;
-}
-
-#endif // USAGE_HXX
-
diff --git a/xsd/xsd.cxx b/xsd/xsd.cxx
index ea7b09d..27f4b09 100644
--- a/xsd/xsd.cxx
+++ b/xsd/xsd.cxx
@@ -33,8 +33,6 @@
#include <xsd-frontend/transformations/schema-per-type.hxx>
#include <xsd-frontend/transformations/simplifier.hxx>
-#include <backend-elements/indentation/clip.hxx>
-
#include <cxx/tree/generator.hxx>
#include <cxx/parser/generator.hxx>
@@ -42,7 +40,7 @@
#include <processing/inheritance/processor.hxx>
#include <xsd.hxx>
-#include <usage.hxx>
+#include <options.hxx>
#include "../libxsd/xsd/cxx/version.hxx"
@@ -235,7 +233,6 @@ struct XercesInitializer
Void
expand_nl (NarrowString& s);
-
Int
main (Int argc, Char* argv[])
{
@@ -325,117 +322,9 @@ main (Int argc, Char* argv[])
return 1;
}
- ::CLI::Indent::Clip< ::CLI::OptionsUsage, WideChar> clip (o);
-
- // Disable warning option.
- //
- o << "--disable-warning <warn>" << endl
- << " Disable printing warning with id <warn>. If 'all'\n"
- << " is specified for the warning id then all warnings\n"
- << " are disabled."
- << endl;
-
- // Anonymous morphing options.
- //
- o << "--preserve-anonymous" << endl
- << " Preserve anonymous types. By default anonymous\n"
- << " types are automatically named with names derived\n"
- << " from the enclosing elements/attributes."
- << endl;
-
- o << "--anonymous-regex <regex>" << endl
- << " Add the provided regular expression to the list of\n"
- << " regular expressions used to derive names for\n"
- << " anonymous types from the names of the enclosing\n"
- << " attributes/elements."
- << endl;
-
- o << "--anonymous-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --anonymous-regex option."
- << endl;
-
- // Location mapping options.
- //
- o << "--location-map <ol>=<nl>" << endl
- << " Map the original schema location <ol> that is\n"
- << " specified in the XML Schema include or import\n"
- << " elements to new schema location <nl>. Repeat\n"
- << " this option to map more than one schema location."
- << endl;
-
- o << "--location-regex <regex>" << endl
- << " Add <regex> to the list of regular expressions\n"
- << " used to map schema locations that are specified\n"
- << " in the XML Schema include or import elements."
- << endl;
-
- o << "--location-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --location-regex option."
- << endl;
-
- // File-per-type compilation mode options.
+ // Add frontend options at the end.
//
- o << "--file-per-type" << endl
- << " Generate a separate set of C++ files for each\n"
- << " type defined in XML Schema."
- << endl;
-
- o << "--type-file-regex <regex>" << endl
- << " Add the provided regular expression to the list of\n"
- << " regular expressions used to translate type names\n"
- << " to file names when the --file-per-type option is\n"
- << " specified."
- << endl;
-
- o << "--type-file-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --type-file-regex option."
- << endl;
-
- o << "--schema-file-regex <regex>" << endl
- << " Add the provided regular expression to the list\n"
- << " of regular expressions used to translate schema\n"
- << " file names when the --file-per-type option is\n"
- << " specified."
- << endl;
-
- o << "--schema-file-regex-trace" << endl
- << " Trace the process of applying regular expressions\n"
- << " specified with the --schema-file-regex option."
- << endl;
-
- o << "--fat-type-file" << endl
- << " Generate code corresponding to global elements\n"
- << " into type files instead of schema files when the\n"
- << " --file-per-type option is specified."
- << endl;
-
- // File list options.
- //
- o << "--file-list <file>" << endl
- << " Write a list of generated C++ files to <file>."
- << endl;
-
- o << "--file-list-prologue <p>" << endl
- << " Insert <p> at the beginning of the file list. All\n"
- << " occurrences of the \\n character sequence in <p>\n"
- << " are replaced with new lines."
- << endl;
-
- o << "--file-list-prologue <e>" << endl
- << " Insert <e> at the end of the file list. All\n"
- << " occurrences of the \\n character sequence in <e>\n"
- << " are replaced with new lines."
- << endl;
-
- o << "--file-list-delim <d>" << endl
- << " Delimit file names written to the file list with\n"
- << " <d> instead of new lines. All occurrences of the\n"
- << " \\n character sequence in <d> are replaced with\n"
- << " new lines."
- << endl;
+ options::print_usage (o);
}
else
{