Version 3.0.0

  * Anonymous type morphing (automatic type naming) is now performed by
    default in both mappings. The --morph-anonymous option does not have
    any effect but is preserved for backwards compatibility. A new option,
    --preserve-anonymous, disables anonymous type morphing. This option is
    useful together with --show-anonymous if you want to make sure your
    schemas do not have any anonymous types.

  * A number of bugs fixed in both C++/Tree and C++/Parser mappings.

 C++/Tree

  * The new C++/Tree Mapping Getting Started Guide is available in the
    documentation/cxx/tree/guide/ directory.

  * The type definitions for local elements and attributes in the form
    name::type have been changed to name_type. For example, an element
    bar in type foo with maxOccurs="unbounded" used to have its iterator
    type defined as foo::bar::iterator. With this change it becomes
    foo::bar_iterator. Furthermore, the container type name for sequence
    elements has changed from foo::bar::container to foo::bar_sequence
    and for optional elements and attributes from foo::bar::container
    to foo::bar_optional. This is a backwards incompatible change and
    may require application code adjustments (the C++ compiler will
    pinpoint the affected places).

  * New option, --generate-doxygen, triggers generation of documentation
    comments suitable for extraction by the Doxygen documentation system.
    Documentation from annotations is added to the comments if present in
    the schema.

  * New option, --generate-wildcard, triggers generation of the new
    wildcard (any and anyAttribute) mapping. This mapping represents the
    content matched by wildcards as DOM fragments. For more information on
    the new mapping see Section 2.12, "Mapping for any and anyAttribute"
    in the C++/Tree Mapping User Manual as well as the wildcard example in
    the examples/cxx/tree/ directory.

  * New option, --generate-comparison, triggers generation of comparison
    operators (== and !=) for complex types. Comparison is performed
    memberwise.

  * Support for the RPC XDR binary stream in addition to ACE CDR.

  * New constructor is generated for complex types with ultimate bases
    that are simple types and can be default-initialized. This constructor
    includes initializers for all required members but omits the initializer
    for the base type. See Section 2.7, "Mapping for Complex Types" in the
    C++/Tree Mapping User Manual for more information.

  * Support for polymorphic binary serialization and extraction. Note that
    the semantics of the --generate-insertion and --generate-extraction
    options has changed. See the XSD Compiler Command Line Manual (man
    pages) for details.

  * New parsing function with the DOMDocument* argument and the own_dom
    flag allow the tree to assume the ownership of the DOM document
    being parsed when DOM association is requested (keep_dom flag).
    See the C++/Tree Mapping User Manual for more information.

  * New example, multiroot, shows how to handle XML vocabularies with
    multiple root elements.

  * New example, caching, shows how to parse several XML documents while
    reusing the underlying XML parser and caching the schemas used for
    validation.

  * The mapping of built-in XML Schema type decimal has changed from
    long double to double. The old mapping can be obtained by providing
    a custom mapping for this type.

  * The xml_schema::errors type which is used in the xml_schema::parsing
    and xml_schema::serialization exceptions has been renamed to
    xml_schema::diagnostics and extended to include warnings in addition
    to errors.

  * Serialization operators now clear the element being serialized to from
    existing child nodes and attributes (except for special attributes such
    as prefix-namespace mappings, etc.).

  * Improved built-in type parsing, including support for normalization and
    whitespace collapsing.

  * Optimizations for the generated code size and compilation time,
    including space optimizations for polymorphic parsing and
    serialization. Optimizations for XML parsing speed.

 C++/Parser

  * The C++/Parser mapping have been significantly redesigned. See the new
    Getting Started Guide in documentation/cxx/parser/guide/ for details.

  * The new C++/Parser Mapping Getting Started Guide is available in the
    documentation/cxx/parser/guide/ directory.

  * The mapping now provides parser implementations for all built-in XML
    Schema types. See Chapter 6, "Built-In XML Schema Type Parsers" in
    the C++/Parser Mapping Getting Started Guide for more information.

  * The mapping now supports automatic generation of sample parser
    implementations and a test driver. The --generate-noop-impl option
    triggers generation of a sample implementation with empty function
    bodies. The --generate-print-impl option triggers generation of a
    sample implementation that prints the data stored in XML to STDOUT.
    The --generate-test-driver option trigger generation of a test driver.
    For more information on this feature see the XSD Compiler Command Line
    Manual and the generated example in the example/cxx/parser/ directory.
    Other relevant options include: --force-overwrite, --root-element-first,
    --root-element-last, and --root-element.

  * New example, wildcard, shows how to parse the XML data matched by
    XML Schema wildcards (any and anyAttribute).

  * The xml_schema::document parser has been extended with overridable
    virtual functions start_root_element and end_root_element to support
    parsing of XML vocabularies with multiple document roots. See the
    multiroot example in the example/cxx/parser/ directory for more
    information.

  * The xml_schema::errors type which is used in the xml_schema::parsing
    exception has been renamed to xml_schema::diagnostics and extended to
    include warnings in addition to errors.

Version 2.3.1

  * The compiler is now capable of translating multiple schemas with
    one invocation.

  * New option, --sloc-limit, allows one to limit the amount of the
    generated code.

  * New option, --proprietary-license, instructs the compiler not to
    include the GPL banner in each generated file. Instead a short
    notice about a required proprietary license is generated. You
    should not use this option unless you have obtained a proprietary
    license from Code Synthesis Tools CC.

  * The default encoding for the 'char' character type is now UTF-8.
    To get the previous behavior (local code page via the Xerces-C++
    transcode functions) define the XSD_USE_LCP preprocessor macro
    when compiling your source code.

  C++/Tree

    * The --parts option has been improved to split generated code more
      evenly by analyzing the complexity of the generated schema constructs.

    * Ability to customize serialization, std::ostream, and binary
      insertion/extraction operators. See examples/cxx/tree/custom/wildcard
      for an example on how to handle XML Schema wildcards (xsd:any and
      xsd:anyAttribute) by customizing the parsing constructor and
      serialization operators.

    * Optimizations for the run-time memory consumption.

    * Optimizations for space in the generated code.

    * Number of bug fixes.

  C++/Parser

    * Proper handling of an xsd:any nested content. Nested elements,
      attributes, and text are reported via _any_* hooks of the current
      parser.

    * Number of bug fixes, mostly in the generated validation code.


Version 2.3.0

    * Name conflicts across type inheritance hierarchies are now detected
      and resolved via name escaping.

  C++/Tree

    * New option, --suppress-parsing, suppresses generation of the parsing
      constructors and functions. This can be used to minimize the generated
      code footprint when parsing from XML is not used.

    * New option, --generate-forward, triggers generation of a forward
      declaration header file for types defined in the schema. A set of
      --fwd-* options that control the resulting file name as well as
      prologue and epilogue code are available.

    * New option, --generate-xml-schema, triggers generation of mapping for
      the XML Schema namespace to a separate header file. See the man pages
      for details and examples/cxx/tree/custom/calendar for an example.

    * New option, --extern-xml-schema, triggers inclusion of a header
      file for the XML Schema namespace instead of generating necessary
      declarations inline. See the man pages for details and
      examples/cxx/tree/custom/calendar for an example.

    * New options, --custom-type and --custom-type-regex, instruct the
      compiler to use custom C++ type for a type defined in the schema.
      The standard mapping can still be generated (with a different name)
      usually to be used as a base. Built-in XML Schema types can be
      customized using this mechanism. See the man pages for details and
      examples/cxx/tree/custom/* for examples.

    * The generated parsing constructors and serialization operators have
      been changed to use the Xerces-C++ DOM elements and attributes
      instead of the internal wrapper types. This should provide easier
      integration with other code and libraries that use the Xerces-C++
      DOM types such as Berkeley DB XML.

    * New example, examples/cxx/tree/dbxml, shows how to use the C++/Tree
      mapping on top of the Berkeley DB XML database.

  C++/Parser

    * Validation of the attribute structure in the generated code.

    * Validation of the character content models including mixed content in
      the generated code.

    * Validation of the built-in XML Schema types.

    * Optimizations for space and time in the generated code. In particular
      data coping during parsing and validation was significantly reduced.


Version 2.2.0

    * Detection of a version mismatch between the generated code and
      the runtime.

  C++/Tree

    * Escaping of a global element name that conflicts with a global type
      name. This is a backwards-incompatible change. Previous versions
      map them to the same name.

    * New options, --generate--insertion and --generate-extraction,
      trigger generation of (binary) data representation stream
      insertion and extraction operators, respectively. This allows
      one to serialize/deserialize in-memory representation to/from
      data representation streams such as XSD, CDR, etc. ACE CDR
      streams are supported out of the box (see the binary example).
      User-supplied streams can be used via an adaptation layer.

    * New serialization flag, no_xml_declaration, instructs the XML
      serialization functions to omit an XML declaration. This is useful
      for streaming serialization (see the streaming example).

    * Optimizations to reduce generated code size.


  C++/Parser

    * New options, --generate-validation and --suppress-validation,
      trigger and suppress generation of the validation code,
      respectively. The validation code is the implementation of the
      XML Schema validation in the generated code (also known as
      "perfect" parser). In this version validation of the element
      structure has been implemented.

    * New architecture for underlying XML parsers. This is a backwards-
      incompatible change. Existing applications will have to be
      modified. See examples for details.


Version 2.1.1

  C++/Tree

    * New option, --namespace-map, allows direct mapping of XML Schema
      namespaces to C++ namespaces without the use of regular expressions.

    * Further optimizations in the container code and enum mapping to
      reduce generated code size.

    * Number of bug fixes in the generated code.


  C++/Parser

    * New option, --namespace-map, allows direct mapping of XML Schema
      namespaces to C++ namespaces without the use of regular expressions.


Version 2.1.0

  * Automatic handling of forward inheritance. XML Schema allows
    inheritance from yet undefined types while it is illegal to do
    so in C++. Now the translator automatically handles forward
    inheritance by re-arranging the schema during compilation.


  C++/Tree

    * New enum mapping with support for inheritance. Enumerators are
      now parsed using binary search instead of linear search.

    * Associated DOM nodes now retain "back" pointers to tree nodes.

    * Optimizations to reduce generated code size.


  C++/Parser

    * Specialization for void. You can now use void as a hook argument
      type if you don't want to pass any data between parsers.

    * Support for re-use of implementations of base parsers in derived
      parsers using the mixin C++ idiom. See the examples/cxx/parser/mixin
      for more information.

    * Support for uninitialized parser. If you don't provide a parser
      for element/attribute, that element/attribute will be ignored
      during parsing.


Version 2.0.0

  * New cardinality calculator. This improves support for schemas that
    use complex structures with repeated elements, e.g.,

    <complexType name="Type">
      <choice>
        <sequence>
          <element name="a" type="string"/>
          <element name="c" type="string"/>
        </sequence>
        <sequence>
          <element name="b" type="string"/>
          <element name="c" type="string"/>
        </sequence>
      </choice>
    </complexType>


  * New identifier escaping code. With this feature xsd generates proper
    code for schemas that use the same name for an element and an attribute
    in the same type or use several elements/attributes with different
    qualified names but with the same local name, e.g.,

    <!-- base.xsd -->
    <schema xmlns="http://codesynthesis.com/xmlns/test/foo"
            targetNamespace="http://codesynthesis.com/xmlns/test/foo">

      <element name="foo" type="int"/>
    </schema>

    <schema xmlns="http://codesynthesis.com/xmlns/test/bar"
	    xmlns:f="http://codesynthesis.com/xmlns/test/foo"
            targetNamespace="http://codesynthesis.com/xmlns/test/bar">

      <import namespace="http://codesynthesis.com/xmlns/test/foo"
              schemaLocation="base.xsd"/>

      <element name="foo" type="string"/>

      <complexType name="Foo">
        <sequence>
          <element ref="foo"/>
          <element name="foo" type="long"/>
          <element ref="f:foo"/>
          <element ref="f:foo"/>
        </sequence>
        <attribute name="foo" type="string"/>
      </complexType>
    </schema>


  C++/Tree

    * New option, --generate-polymorphic, triggers generation of
      polymorphism-aware code. Before this release xsd used to always
      generate polymorphism-aware code. However, it appears to be quite
      wasteful in terms of the generated code size (up to 40%). You will
      now need to explicitly specify this option if you use substitution
      groups or xsi:type. A warning is issued if this option is not
      specified but the schema makes use of substitution groups.

    * New options, --root-element-first, --root-element-last,
      --root-element-all, --root-element-none, and --root-element, control
      generation of parsing and serialization functions. With these options
      you can avoid generating extra code for global elements that are not
      document roots. See the man pages for details.

    * New options, --parts and -parts-suffix, allows you to split generated
      source code into a number of 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).

    * New option, --generate-default-ctor, triggers generation of 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. Thanks
      to Jean-Francois Dube <jf at magnu.polymtl.ca> for suggesting this
      feature.

    * New option, --generate-from-base-ctor, triggers generation of
      constructors that expect an instance of a base type followed by all
      required members. Thanks to Jean-Francois Dube <jf at magnu.polymtl.ca>
      for suggesting this feature.

    * Information scopes for attributes and elements with default/fixed values
      now define the public static default_value function which allows one to
      obtain the default/fixed value for the element/attribute. Thanks to
      Dave Moss <david.r.moss at selex-comm.com> for suggesting this feature.

    * MSVC 7.1 has a limit on the length of the "if else if" chain. This
      results in ICE when compiling generated code for enumerations with
      a large number of values. This version addresses this issue. Thanks
      to Cyrille Chépélov <cyrille at chepelov.org> for reporting this and
      suggesting a fix.


  C++/Parser

    * The parser construction API has changed. Now, for element 'foo',
      the name of the parser modifier function is 'foo_parser'. Likewise,
      operator() for setting all parsers at once has been changed to the
      'parsers' function.


Version 1.9.0

  C++/Tree

    * The size modifier function in the base64_binary and hex_binary
      built-in types automatically adjusts capacity if needed.

    * More internal names (names that start with _xsd_) were made
      private or protected.

  C++/Parser

    * Typedef for the parser base in the xml_schema namespace.

  C++/Parser-E

    * C++/Parser mapping optimized for embedded systems. For now it
      is equivalent to 'cxx-parser --xml-parser expat'.


Version 1.8.0

  * Moved to the build 0.2 series.

  C++/Tree

    * Support for default and fixed values in attributes. An optional
      attribute with a default or fixed value is mapped to the One
      cardinality class instead of the Optional cardinality class.

    * Mapping for base64Binary and hexBinary has improved. Now these
      types support a basic buffer abstraction and perform automatic
      encoding and decoding.

    * Internal names are protected. We've noticed (via bug reports) a
      wide use of internal names (names that start with _xsd_) in user
      code. This is not portable and instead you should use public
      names. To prevent this from happening in the future we've made
      all internal names protected.

  C++/Parser

    * Support for Expat as the underlying XML parser in addition to
      Xerces-C++. This allows one to use the C++/Parser mapping in
      memory-constrained environments such as embedded systems. To
      select Expat instead of Xerces-C++ (default) add
      '--xml-parser expat' to the command line. At the moment only
      'char' (UTF-8) is supported as the base character type when
      Expat is selected.

    * The invalid_instance exception has been renamed to parsing.

    * Generic error_handler interface has been added in addition
      to Xerces-C++-specific DOMErrorHandler. It allows you to
      handle parsing errors and warnings without having to deal
      with Xerces-C++ specifics.

    * The default error handling behavior has changed in parsing
      functions. Instead of printing errors and warnings to STDERR,
      the errors are now collected and thrown as part of the parsing
      exception.

    * In parsing functions, the name, namespace arguments order has
      been reversed to be consistent with the one used in parsing
      hooks.

Version 1.7.0

  * Number of bug fixes in libxsd and the generated code.

  C++/Tree

    * Comprehensive XML Schema C++/Tree Mapping User Manual.

    * Basic support for union. A simple type that is defined using
      derivation by union is mapped to a C++ class that derives from
      string.

    * The _clone function has its arguments default-initialized.

    * The invalid_instance exception has been renamed to parsing.

    * Generic error_handler interface has been added in addition
      to Xerces-C++-specific DOMErrorHandler. It allows you to
      handle parsing/serialization errors and warnings without
      having to deal with Xerces-C++ specifics. See the user
      manual for more information.

    * The default error handling behavior has changed in parsing
      and serialization functions. Instead of printing errors and
      warnings to STDERR, the errors are now collected and thrown
      as part of the parsing/serialization exception. See the user
      manual for more information.

    * The optional and sequence containers now support operators ==,
      !=, <, >, <=, and >=.

    * Flags argument has been added to serialization functions. The
      only flag that is currently supported is dont_initialize.

    * Generated code cleanups.

  C++/Parser

    * Basic support for union. A simple type that is defined using
      derivation by union is mapped to a C++ class template that
      is just an alias for the generic parser. You are expected to
      override the _characters function in your implementation.

    * Properties argument to parsing functions which allows to
      programmatically specify schemas for instance document
      validation.

    * Flags argument to parsing functions. The following flags
      are supported:

      dont_validate   - do not validate instance documents
      dont_initialize - do not initialize the Xerces-C++ runtime

Version 1.6.0

  * Number of bug fixes in libxsd and the generated code.

  C++/Tree

    * Support for xsi:type and substitution groups in parsing and
      serialization. See examples/cxx/tree/polymorphism for a code
      sample.

    * Properties argument to parsing functions which allows to
      programmatically specify schemas for instance document
      validation.

    * Extra checks in parsing code which prevents construction
      of inconsistent in-memory representation from invalid
      instance documents. Should be useful when validation is
      disabled.

    * Accessors and modifier were made normal member functions.
      Before they were implemented via functors.

    * Workaround for g++-3.3 bug# 16650:

      http://gcc.gnu.org/bugzilla/show_bug.cgi?id=16650

  C++/Parser

    * All "service" functions were renamed to start with '_'.
      This should prevent hiding of service functions by
      elements/attributes with the same names.

Version 1.5.0

  * Number of bug fixes in libxsd and the generated code.

  C++/Tree

    * Basic support for inheritance-by-restriction in complex types.

    * The following parsing flags have been introduced:

      keep_dom        - keep association with underlying DOM nodes
      dont_validate   - do not validate instance documents
      dont_initialize - do not initialize the Xerces-C++ runtime

    * "Type-less content" such as mixed content models, xsd:anyType/
      xsd:anySimpleType, and xsd:any/xsd:anyAttribute is supported by
      exposing corresponding DOM nodes (see the keep_dom parsing flag).
      Note that only a subset of XML Schema xsd:any functionality is
      supported. The compiler will issue diagnostics for unsupported
      cases. See examples/cxx/tree/mixed for a code sample.

  C++/Parser

    * Support for inheritance-by-restriction in complex types.

    * "Type-less content" such as mixed content models, xsd:anyType/
      xsd:anySimpleType, and xsd:any/xsd:anyAttribute is supported
      by forwarding parsing events to a set of "unexpected" hooks.
      Note that only a subset of XML Schema xsd:any functionality is
      supported. The compiler will issue diagnostics for unsupported
      cases. See examples/cxx/parser/mixed for a code sample.

Version 1.4.0

  * Number of improvements and bug fixes in the diagnostics code.

  * libxsd has been reorganized to provide a clean split of code with
    regards to char/wchar_t use. It should be possible to use libxsd
    and the xsd-generated code on platforms that lack wchar_t support,
    such as mingw.

  C++/Tree

    * Work around for g++ bug# 23206.

    * Support for xsd:list.

    * Type/member name conflicts are auto-resolved. Such conflicts
      occur when a type and an element or attribute withing this type
      share the same name.

    * XML Schema extension, the 'refType' attribute, allows one to
      specify referenced type for xsd:IDREF and xsd:IDREFS data types.
      See examples/cxx/tree/library for details.

    * New option, --morph-anonymous, allows automatic morphing
      of anonymous types to named ones. See the man pages for
      details.

    * New option, --namespace-regex-trace, allows one to trace the
      namespace mapping process. See the man pages for details.

    * Mapping for optional elements/attributes (cardinality 0..1)
      has changed in a backwards-incompatible way. In the previous
      version you would write:

      Bar& bar = ...

      if (bar.foo.present ())  // test
      {
        Foo& foo (bar.foo ()); // get

        bar.foo (Foo (...));   // set

        bar.foo.reset ();      // reset
      }

      Now you would write it like this:

      if (bar.foo ().present ())      // test
      {
        Foo& foo (bar.foo ().get ()); // get

        bar.foo (Foo (...));          // set

        bar.foo ().reset ();          // reset
      }

      Or using the pointer notation:

      if (bar.foo ())           // test
      {
        Foo& foo (*bar.foo ()); // get

        bar.foo (Foo (...));    // set

        bar.foo ().reset ();    // reset
      }

  C++/Parser

    * Support for xsd:list.

    * Type/member name conflicts are auto-resolved. Such conflicts
      occur when a type and an element or attribute withing this type
      share the same name.

    * New option, --namespace-regex-trace, allows one to trace the
      namespace mapping process. See the man pages for details.

Version 1.3.0

  * Numerous bug fixes.

  * The XML subsystem of libxsd has been reorganized to provide
    a clean split of DOM and SAX functionalities.

  C++/Parser

    * New option, --morph-anonymous, allows automatic morphing
      of anonymous types to named ones. See the man pages for
      details.

  C++/Tree

    * Additional parser functions provide support for reading
      from std::istream.

Version 1.2.0

  C++/Parser

    * New backend that generates the C++/Parser mapping.

Version 1.1.1

  all backends

    * Bug fixes in the filesystem path handling logic.

Version 1.1.0

  C++/Tree

    * New option, --generate-serialization, triggers generation of
      serialization functions. Serialization functions convert an in-memory
      representation back to XML.

    * xsd::cxx::tree::vector has been extended to closely follow std::vector
      API. This allows you to access and modify element sequences as if they
      were of type std::vector.

    * Generated constructors from xml::attribute and xml::element are made
      explicit.

    * The library example was extended to showcase modification and
      serialization of the in-memory representation.

    * New "XML Schema C++/Tree Mapping Serialization Guide" has an in-depth
      treatment of the serialization mechanisms provided by xsd.

Version 1.0.1

  all backends

    * Improved diagnostics.

    * Bug fixes in the schema inclusion/importing logic.

  C++/Tree

    * Two new options: --include-with-brackets and --include-prefix

Version 1.0.0

  * First public release.
