# NAME

xsd - W3C XML Schema to C++ Compiler

# SYNOPSIS

`xsd command [options] file [file ...]`
`xsd help [command]`
`xsd version`

# DESCRIPTION

`xsd` generates vocabulary-specific, statically-typed C++ mapping from W3C XML Schema definitions. Particular mapping to produce is selected by a `command`. Each mapping has a number of mapping-specific `options` that should appear, if any, after the `command`. Input files should be W3C XML Schema definitions. The exact set of the generated files depends on the selected mapping and options.

# COMMANDS

`cxx-tree`
  Generate the C++/Tree mapping. For each input file in the form `name.xsd` the following C++ files are generated: `name.hxx` (header file), `name.ixx` (inline file, generated only if the `--generate-inline` option is specified), `name.cxx` (source file), and `name-fwd.hxx` (forward declaration file, generated only if the `--generate-forward` option is specified).
`cxx-parser`
  Generate the C++/Parser mapping. For each input file in the form `name.xsd` the following C++ files are generated: `name-pskel.hxx` (parser skeleton header file), `name-pskel.ixx` (parser skeleton inline file, generated only if the `--generate-inline` option is specified), and `name-pskel.cxx` (parser skeleton source file). If the `--generate-noop-impl` or `--generate-print-impl` option is specified, the following additional sample implementation files are generated: `name-pimpl.hxx` (parser implementation header file) and `name-pimpl.cxx` (parser implementation source file). If the `--generate-test-driver` option is specified, the additional `name-driver.cxx` test driver file is generated.
`help`
  Print usage information and exit. Use

  `xsd help command`

  for command-specific help.
`version`
  Print version and exit.

# OPTIONS

Command-specific `options`, if any, should appear after the corresponding `command`.

## cxx-tree command options

`--char-type type`
  Generate code using the provided character `type` instead of the default `char`. Valid values are `char` and `wchar_t`.
`--output-dir dir`
  Write generated files to `dir` instead of the current directory.
`--generate-polymorphic`
  Generate polymorphism-aware code. Specify this option if you use substitution groups or `xsi:type`.
`--generate-serialization`
  Generate serialization functions. Serialization functions convert the object model back to XML.
`--generate-inline`
  Generate simple functions inline. This option triggers creation of the inline file.
`--generate-ostream`
  Generate ostream insertion operators (`operator<<`) for generated types. This allows to easily print a fragment or the whole object model for debugging or logging.
`--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.
`--generate-comparison`
  Generate comparison operators (`operator==` and `operator!=`) for complex types. Comparison is performed memberwise.
`--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.
`--generate-from-base-ctor`
  Generate constructors that expect an instance of a base type followed by all required members.
`--generate-wildcard`
  Generate accessors and modifiers as well as parsing and serialization code for XML Schema wildcards (`any` and `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.
`--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 (`ACE_OutputCDR`) and RPC XDR are recognized by the compiler and the necessary `#include` directives are automatically generated. For custom stream types use the `--hxx-prologue*` options to provide the necessary declarations.
`--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 (`ACE_InputCDR`) and RPC XDR are recognized by the compiler and the necessary `#include` directives are automatically generated. For custom stream types use the `--hxx-prologue*` options to provide the necessary declarations.
`--generate-forward`
  Generate a separate header file with forward declarations for the types being generated.
`--generate-xml-schema`
  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 `--extern-xml-schema` option to include this file in the generated files for other schemas.
`--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 `--generate-xml-schema` option to generate this header file.
`--suppress-parsing`
  Suppress generation of the parsing functions and constructors. Use this option to reduce the generated code size when parsing from XML is not needed.
`--namespace-map xns=cns`
  Map W3C 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:

  `--namespace-regex http://example.com/foo/bar=foo::bar`

  will map the `http://example.com/foo/bar` XML Schema namespace to the `foo::bar` C++ namespace.

`--namespace-regex regex`
  Add `regex` to the list of regular expressions used to translate W3C XML Schema namespace names to C++ namespace names. `regex` is a perl-like regular expression in the form `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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

  `filename namespace`

  For example,

  `XMLSchema.xsd http://www.w3.org/2001/XMLSchema`

  The `filename` for the current translation unit is empty. For example, if you have file `hello.xsd` with namespace `http://example.com/hello` and you run `xsd` on this file, then the string in question would be:

  `http://example.com/hello`

  Note the leading space.

  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 `/` are replaced with `::`.
  3. The result is verified to be a valid C++ scope name (e.g., `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 `http://example.com/foo/bar` to C++ namespaces in the form `foo::bar`:

  `%.* http://example.com/(.+)%$1%`

`--namespace-regex-trace`
  Trace the process of applying regular expressions specified with the `--namespace-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.
`--include-with-brackets`
  Use angle brackets (<>) instead of quotes ("") in generated `#include` directives.
`--include-prefix prefix`
  Add `prefix` to generated `#include` directive paths.

  For example, if you had the following import element in your schema

  `<import namespace="..." schemaLocation="base.xsd"/>`

  and compiled this fragment with `--include-prefix schemas/`, then the include directive in the generated code would be:

  `#include "schemas/base.hxx"`

`--include-regex regex`
  Add `regex` to the list of regular expressions used to transform `#include` directive paths. `regex` is a perl-like regular expression in the form `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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 `schemas/foo/bar` to paths in the form `generated/foo/bar`:

  `%schemas/(.+)%generated/$1%`

`--include-regex-trace`
  Trace the process of applying regular expressions specified with the `--include-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.
`--root-element-first`
  Treat only the first global element as a document root. By default all global elements are considered document roots.
`--root-element-last`
  Treat only the last global element as a document root. By default all global elements are considered document roots.
`--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.
`--root-element-none`
  Do not treat any global elements as document roots. By default all global elements are considered document roots.
`--root-element element`
  Treat only `element` as a document root. Repeat this option to specify more than one root element.
`--custom-type name[=type[/base]]`
  Use a custom C++ type type instead of the generated class for XML Schema type name. If 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 base is specified then the generated class is still generated but with that name.
`--custom-type-regex /name-pat/[type-sub/[base-sub/]]`
  For each type defined in XML Schema that matches the name-pat pattern use a custom C++ type instead of the generated class. The name of the custom type is obtained by substituting type-sub. If 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 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.
`--hxx-suffix suffix`
  Use the provided `suffix` instead of the default `.hxx` to construct the name of the header file. Note that this suffix is also used to construct names for included/imported schemas.
`--ixx-suffix suffix`
  Use the provided `suffix` instead of the default `.ixx` to construct the name of the inline file.
`--cxx-suffix suffix`
  Use the provided `suffix` instead of the default `.cxx` to construct the name of the source file.
`--fwd-suffix suffix`
  Use the provided `suffix` instead of the default `-fwd.hxx` to construct the name of the forward declaration file.
`--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 `/pattern/replacement/`. Note that this expression is also used to construct names for included/imported schemas.
`--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 `/pattern/replacement/`.
`--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 `/pattern/replacement/`.
`--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 `/pattern/replacement/`.
`--hxx-prologue text`
  Insert `text` at the beginning of the header file.
`--ixx-prologue text`
  Insert `text` at the beginning of the inline file.
`--cxx-prologue text`
  Insert `text` at the beginning of the source file.
`--fwd-prologue text`
  Insert `text` at the beginning of the forward declaration file.
`--prologue text`
  Insert `text` at the beginning of each generated file for which there is no file-specific prologue.
`--hxx-epilogue text`
  Insert `text` at the end of the header file.
`--ixx-epilogue text`
  Insert `text` at the end of the inline file.
`--cxx-epilogue text`
  Insert `text` at the end of the source file.
`--fwd-epilogue text`
  Insert `text` at the end of the forward declaration file.
`--epilogue text`
  Insert `text` at the end of each generated file for which there is no file-specific epilogue.
`--hxx-prologue-file file`
  Insert the content of the `file` at the beginning of the header file.
`--ixx-prologue-file file`
  Insert the content of the `file` at the beginning of the inline file.
`--cxx-prologue-file file`
  Insert the content of the `file` at the beginning of the source file.
`--fwd-prologue-file file`
  Insert the content of the `file` at the beginning of the forward declaration file.
`--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.
`--hxx-epilogue-file file`
  Insert the content of the `file` at the end of the header file.
`--ixx-epilogue-file file`
  Insert the content of the `file` at the end of the inline file.
`--cxx-epilogue-file file`
  Insert the content of the `file` at the end of the source file.
`--fwd-epilogue-file file`
  Insert the content of the `file` at the end of the forward declaration file.
`--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.
`--parts 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).
`--parts-suffix suffix`
  Use `suffix` instead of the default '`-`' to separate the file name from the part number.
`--export-symbol symbol`
  Insert `symbol` in places where Win32 DLL export/import control statements (`__declspec(dllexport/dllimport)`) are necessary.
`--show-sloc`
  Show the number of generated physical source lines of code (SLOC).
`--sloc-limit num`
  Check that the number of generated physical source lines of code (SLOC) does not exceed `num`.
`--proprietary-license`
  Indicate that the generated code is licensed under a proprietary license instead of the GPL.
`--preserve-anonymous`
  Preserve anonymous types. By default anonymous types are automatically named with names derived from the enclosing elements/attributes. Because C++/Parser mapping requires all types to be named, this option is only useful if you want to make sure your schemas don't have anonymous types.
`--show-anonymous`
  Show elements and attributes that are of anonymous types. This option only makes sense together with the `--preserve-anonymous` option.
`--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 `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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

  `filename namespace xpath`

  For example,

  `hello.xsd http://example.com/hello element`

  `hello.xsd http://example.com/hello type/element`

  The `filename` for the current translation unit is empty. For example, if you have file `hello.xsd` with namespace `http://example.com/hello` and you run `xsd` on this file, then the string in question would be:

  `http://example.com/hello element`

  Note the leading space.

  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:

  `%.* .* (.+/)*(.+)%\u$2%`

`--anonymous-regex-trace`
  Trace the process of applying regular expressions specified with the `--anonymous-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.

## cxx-parser command options

`--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 `void`. See the TYPE MAP section below for more information.
`--char-type type`
  Generate code using the provided character `type` instead of the default `char`. Valid values are `char` and `wchar_t`.
`--output-dir dir`
  Write generated files to `dir` instead of the current directory.
`--xml-parser parser`
  Use `parser` as the underlying XML parser. Valid values are `xerces` for Xerces-C++ (default) and `expat` for Expat.
`--generate-inline`
  Generate simple functions inline. This option triggers creation of the inline file.
`--generate-validation`
  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 (`expat`).
`--suppress-validation`
  Suppress generation of validation code ("perfect" parser). Validation is suppressed by default when the selected underlying XML parser is validating (`xerces`).
`--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 `name.xsd` this option triggers generation of the two additional C++ files in the form: `name-pimpl.hxx` (parser implementation header file) and `name-pimpl.cxx` (parser implementation source file).
`--generate-print-impl`
  Generate a sample parser implementation that prints the XML data to STDOUT. For an input file in the form `name.xsd` this option triggers generation of the two additional C++ files in the form: `name-pimpl.hxx` (parser implementation header file) and `name-pimpl.cxx` (parser implementation source file).
`--generate-test-driver`
  Generate a test driver for the sample parser implementation. For an input file in the form `name.xsd` this option triggers generation of an additional C++ file in the form `name-driver.cxx`.
`--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-first`
  Indicate that the first global element is the document root. This information is used to generate the test driver for the sample implementation.
`--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.
`--root-element element`
  Indicate that `element` is the document root. This information is used to generate the test driver for the sample implementation.
`--skel-type-suffix suffix`
  Use the provided `suffix` instead of the default `_pskel` to construct the names of generated parser skeletons.
`--skel-file-suffix suffix`
  Use the provided `suffix` instead of the default `-pskel` to construct the names of generated parser skeleton files.
`--impl-type-suffix suffix`
  Use the provided `suffix` instead of the default `_pimpl` to construct the names of parser implementations for the built-in XML Schema types and sample parser implementations.
`--impl-file-suffix suffix`
  Use the provided `suffix` instead of the default `-pimpl` to construct the names of generated sample implementation files.
`--namespace-map xns=cns`
  Map W3C 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:

  `--namespace-regex http://example.com/foo/bar=foo::bar`

  will map the `http://example.com/foo/bar` XML Schema namespace to the `foo::bar` C++ namespace.

`--namespace-regex regex`
  Add `regex` to the list of regular expressions used to translate W3C XML Schema namespace names to C++ namespace names. `regex` is a perl-like regular expression in the form `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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

  `filename namespace`

  For example,

  `XMLSchema.xsd http://www.w3.org/2001/XMLSchema`

  The `filename` for the current translation unit is empty. For example, if you have file `hello.xsd` with namespace `http://example.com/hello` and you run `xsd` on this file, then the string in question would be:

  `http://example.com/hello`

  Note the leading space.

  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 `/` are replaced with `::`.
  3. The result is verified to be a valid C++ scope name (e.g., `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 `http://example.com/foo/bar` to C++ namespaces in the form `foo::bar`:

  `%.* http://example.com/(.+)%$1%`

`--namespace-regex-trace`
  Trace the process of applying regular expressions specified with the `--namespace-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.
`--include-with-brackets`
  Use angle brackets (<>) instead of quotes ("") in generated `#include` directives.
`--include-prefix prefix`
  Add `prefix` to generated `#include` directive paths.

  For example, if you had the following import element in your schema

  `<import namespace="..." schemaLocation="base.xsd"/>`

  and compiled this fragment with `--include-prefix schemas/`, then the include directive in the generated code would be:

  `#include "schemas/base.hxx"`

`--include-regex regex`
  Add `regex` to the list of regular expressions used to transform `#include` directive paths. `regex` is a perl-like regular expression in the form `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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 `schemas/foo/bar` to paths in the form `generated/foo/bar`:

  `%schemas/(.+)%generated/$1%`

`--include-regex-trace`
  Trace the process of applying regular expressions specified with the `--include-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.
`--hxx-suffix suffix`
  Use the provided `suffix` instead of the default `.hxx` to construct the name of the header file. Note that this suffix is also used to construct names for included/imported schemas.
`--ixx-suffix suffix`
  Use the provided `suffix` instead of the default `.ixx` to construct the name of the inline file.
`--txx-suffix suffix`
  Use the provided `suffix` instead of the default `.txx` to construct the name of the template file.
`--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 `/pattern/replacement/`. Note that this expression is also used to construct names for included/imported schemas.
`--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 `/pattern/replacement/`.
`--txx-regex regex`
  Use the provided expression to construct the name of the template file. `regex` is a perl-like regular expression in the form `/pattern/replacement/`.
`--hxx-prologue text`
  Insert `text` at the beginning of the header file.
`--ixx-prologue text`
  Insert `text` at the beginning of the inline file.
`--txx-prologue text`
  Insert `text` at the beginning of the template file.
`--prologue text`
  Insert `text` at the beginning of each generated file for which there is no file-specific prologue.
`--hxx-epilogue text`
  Insert `text` at the end of the header file.
`--ixx-epilogue text`
  Insert `text` at the end of the inline file.
`--txx-epilogue text`
  Insert `text` at the end of the template file.
`--epilogue text`
  Insert `text` at the end of each generated file for which there is no file-specific epilogue.
`--hxx-prologue-file file`
  Insert the content of the `file` at the beginning of the header file.
`--ixx-prologue-file file`
  Insert the content of the `file` at the beginning of the inline file.
`--txx-prologue-file file`
  Insert the content of the `file` at the beginning of the template file.
`--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.
`--hxx-epilogue-file file`
  Insert the content of the `file` at the end of the header file.
`--ixx-epilogue-file file`
  Insert the content of the `file` at the end of the inline file.
`--txx-epilogue-file file`
  Insert the content of the `file` at the end of the template file.
`--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-symbol symbol`
  Insert `symbol` in places where Win32 DLL export/import control statements (`__declspec(dllexport/dllimport)`) are necessary.
`--show-sloc`
  Show the number of generated physical source lines of code (SLOC).
`--sloc-limit num`
  Check that the number of generated physical source lines of code (SLOC) does not exceed `num`.
`--proprietary-license`
  Indicate that the generated code is licensed under a proprietary license instead of the GPL.
`--preserve-anonymous`
  Preserve anonymous types. By default anonymous types are automatically named with names derived from the enclosing elements/attributes. Because C++/Parser mapping requires all types to be named, this option is only useful if you want to make sure your schemas don't have anonymous types.
`--show-anonymous`
  Show elements and attributes that are of anonymous types. This option only makes sense together with the `--preserve-anonymous` option.
`--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 `/pattern/replacement/`. Any character can be used as a delimiter instead of `/`. Escaping of the delimiter character in `pattern` or `replacement` is not supported.

  All 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

  `filename namespace xpath`

  For example,

  `hello.xsd http://example.com/hello element`

  `hello.xsd http://example.com/hello type/element`

  The `filename` for the current translation unit is empty. For example, if you have file `hello.xsd` with namespace `http://example.com/hello` and you run `xsd` on this file, then the string in question would be:

  `http://example.com/hello element`

  Note the leading space.

  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:

  `%.* .* (.+/)*(.+)%\u$2%`

`--anonymous-regex-trace`
  Trace the process of applying regular expressions specified with the `--anonymous-regex` option. Use this option to find out why your regular expressions don't do what you expected them to do.

# 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 `post_*` functions in parser skeletons corresponding to XML Schema types as well as argument types for hooks corresponding to elements and attributes of these types.

The compiler has a set of built-in mapping rules that map built-in XML Schema types to suitable C++ types (discussed below) and all other types to `void`. By providing type maps you can override these built-in rules. The format of the type map file is presented below:

    namespace <schema-namespace> [<cxx-namespace>]
    {
      (include <file-name>;)*
      ([type] <schema-type> <cxx-ret-type> [<cxx-arg-type>];)*
    }

Both `<schema-namespace>` and `<schema-type>` are regex patterns while `<cxx-namespace>`, `<cxx-ret-type>`, and `<cxx-arg-type>` are regex pattern substitutions. All names can be optionally enclosed in `" "`, for example, to include white-spaces.

`<schema-namespace>` determines XML Schema namespace. Optional `<cxx-namespace>` is prefixed to every C++ type name in this namespace declaration. `<cxx-ret-type>` is a C++ type name that is used as a return type for the `post_*` functions. Optional `<cxx-arg-type>` is an argument type for hook functions corresponding to elements and attributes of this type. If not specified, it defaults to `const <cxx-ret-type>&`. `<file-name>` is a file name either in the `" "` or `< >` format and is added with the `#include` directive to the generated code. For example:

    namespace http://www.example.com/xmlns/my my
    {
      include "my.hxx";

      apple apple;
      orange orange_t* orange_t*;
    }

In the example above, for the `http://www.example.com/xmlns/my#orange` XML Schema type, the `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:

    include "my.hxx";
    apple apple;

    namespace http://www.example.com/xmlns/my
    {
      orange "const orange_t*" "const orange_t*";
    }

The compiler has a number of built-in mapping rules that can be presented as the following map files. The string-based XML Schema built-in types are mapped to either `std::string` or `std::wstring` depending on the character type selected with the `--char-type` option (`char` by default).

    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<xml_schema::buffer>
                   std::auto_ptr<xml_schema::buffer>;
      hexBinary std::auto_ptr<xml_schema::buffer>
                std::auto_ptr<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;
    }

The last predefined rule maps anything that wasn't mapped by previous rules to `void`:

    namespace .*
    {
      .* void void;
    }

When you provide your own type maps with the `--type-map`, they are evaluated before any of the built-in rules. This allows you to selectively override built-in rules.

# DIAGNOSTICS

If the input file is not a valid W3C XML Schema definition, `xsd` will issue diagnostic messages to STDERR and exit with non-zero exit code.

# BUGS

Send bug reports to the xsd-users@codesynthesis.com mailing list.