Change log

This page lists the changes on XMLBooster, version by version. These changes include bug correction, documentation updates and new features.

Version
2.17.10
  • Macro names have been renamed to avoid name clashes in the C code generator
  • The source code distribution has been updated to address a number of deficiencies when compiling on some Unix or Unix-like platforms
  • A bug causing a missing terminating tag to be reported incorrectly has been corrected
2.14.4
  • A minor change in the C code generation in order to avoir spurious error messages
  • The GUI classes delivered have been made more robust and versatile (for instance, when running sub-processes)
2.14.2
  • Significant change of the code generation strategy for COBOL parsers. XMLBooster now generates strictly structured code, rather than relying on some odd – and not always well supported – behaviour of COBOL’s control flow mechanisms. This allows the generated parsers to be even more portable than they were before.
  • A minor bug in the treatment of simple types has been corrected.
2.11.2
  • Support for multiple element deletion in generated GUI’s.
2.11.0
  • Complete overhaul of the namespace resolution mechanism when translating schemas to meta-definitions.
2.10.14
  • Checked for a number of issues based on the regression test suite for C#.
2.10.13
  • Bug in serialization of entities in Java and C# corrected.
2.10.12
  • The cases where the ALIEN construct can be used have been extended, so that it is supported if it is the last sub-expression of a top-level CONCAT.
2.10.11
  • Bug corrected when using dynamic mode with Python through Swig.
  • The save_ function in the C code generator now return a boolean value to indicate whether the target file has been opened succesfully or not.
2.10.10
  • XMLBooster does a error message during the code generation when the target field of a elementref does not exist.
2.10.9
  • C: Improve the xmlb_new_page performance.
2.10.8
  • C++: Added validation support.
2.10.7
  • struct2meta.rcs script added to the distribution, to create the metadefinition corresponding to one or more C structure definition. Beware: this script cannot be handled by XMLBooster’s scripting option directly. Raincode for C must be used instead – available for download at http://www.raincode.com
2.10.6
  • Improve the behaviour of support hexadecimal in the PCDATA for the Java code generators.
2.10.5
  • For the Ada, C, C++, CSharp and Java code generator, improved inherited field name and solved a name conflict between an field and an field inherited.
  • All the samples provided in the distribution are usable with the metaagenda.xml metadefinition.
2.10.4
  • Minor change in the C code generator and in the GUI generator.
  • The Java and CSharp code generators support hexadecimal codes in the PCDATA.
2.10.3
  • GBE has been improved, so that its behaviour can be better controlled by the introduction of the -GBEAGGRESSIVEPOLYMORPHISM command-line option; and its internal data structures have been optimized in such as way that even huge meta-definitions can be dealt with in a matter of minutes (instead of hours).
2.10.2
  • For the Ada code generator, solved a name conflict between an element and an enumeration’s type.
2.10.1
  • XMLBooster can generate parsers to be used from within Python.
  • The C code generator supports hexadecimal codes in the PCDATA.
  • XML Doc support for the CSharp code generator.
  • Fix warnings in the specific CSharp files.
  • Improve feature MinInclusive and MaxExclusive for the Cobol code generator.
2.9.29
  • Update the library of paragraphs that are used by all XMLBooster-generated parsers in such a way that a bug regarding zero’s in XML message is resolved.
  • Henceforth the rc.tab file is not necessary anymore for running the Raincode Scripting Language.
  • The abstract feature now is supported for the CSharp and Java generators.
2.9.28
  • Support for YESTRING and NOSTRING command-line options in COBOL, C++ and Ada (Java and CSharp was already supported).
  • First release of the COBOLPARSING feature. We have the ability to add operations (cobol statements) to do after the parsing step for a element.
2.9.27
  • The feature MinInclusive and MaxExclusive now is available for the Cobol code generator.
  • For Java and CSharp code generators, force the Long typing for Inclusive values.
2.9.26
  • Problem fixed regarding the “Testing empty field” in the Cobol generator when the Element have BaseElement attribute.
2.9.25
  • The SCHEMACONFIG element can control how the schemas can be turned to meta-definitions. More specifically, one can now specify if the namespace of an external element of the root schema can be prefixed by its namespace in the meta-defintion.
2.9.24
  • C generator: Revision of enumeration’s name
2.9.23
  • Improve SCHEMA2META behaviour for the voiceXML support.
  • The mechanism identifier of the TRUNCATEIDENTIFIERS attribute in the COBOLCONFIG element is better.
2.9.22
  • Type discrepancies between ELEMENTREF and the corresponding target FIELD are better detected.
  • The feature MinInclusive and MaxExclusive now is available for the C, Java and CSharp code generator.
  • Support for a LONG datatype in CSharp.
2.9.21
  • Minor problem has been corrected during the DTD2META processus.
  • The C code generator used to require an extra 256 character at the end of the input buffer for its own stuff. This is no longer necessary.
2.9.20
  • For Accept polymorph functions in the Ada code generator, a casting was ommited.
  • During the SIMPLIFY operation, critical changes appear in internal data structures between two releases of XMLBooster. This problem has been resolved.
2.9.19
  • When converting a DTD to a meta-definition, the “Node AttListDecl:1:1 is already in a tree” occurs. This problem is corrected.
  • Improve name conflict resolution for the code generated by the C code generator.
2.9.18
  • The tag_table variable generation in the C code generator is now controlled by a XMLB_NO_TAG_NAME #define.
  • A out of memory error in the C version now falls back on the standard error reporting system, with possible error recovery, rather than calling exit(1) directly.
  • The SCHEMACONFIG element now includes a detailed table where the user can indicate how schema predefined simple types must be mapped onto XMLBooster fields. The documentation has been updated accordingly.
2.9.17
  • Meta2Schema : a void sequence in a group is supported.
  • When a default value has been mentionned, the Ada code generator now generates the value in a correct real format.
  • Installer wizard : problem with the install path directory is fixed.
2.9.16
  • Bug corrected in name resolution in schema to meta.
  • The C code generator now generates a tag_table variable, listing all the tags used in a given meta-definition.
2.9.15
  • Support for empty enumeration values in C, C++ and COBOL (Java was already supported)
  • Support for the caret character as a plain character in regular expressions when it does not follow an opening bracket. The regular expression syntax as supported by XMLBooster thereby becomes closer to the schema’s.
  • Improved support for DTD2META translation.
  • The -NOLOGO command-line option to remove the disclaimer with the version number.
  • Newline character added at the end of the xmlbu.h file in the C distribution.
2.9.14
  • Bug corrected in “Schema to meta” conversion regarding the maxOccurs attribute.
  • First version of the difference and merge management system, including documentation and generation as part of the GUI.
  • Alignment bug corrected in the C version which caused segmentation faults when fetching floating point values on some architectures.
  • setIgnoreAlienAttrs.rcs script added to the distribution, to change the meta-definition file to refuse alien attributes. This script can be used as a post-processing on the meta-definition generated from a schema.
2.9.13
  • Support for a LONG datatype in Cobol.
  • Table interface for the generated GUI : extremely slow to change enum field. Performance improvement.
  • Bug corrected in C code generator, the MAXLEN for a field of PCHAR type was not handled.
  • Improve meta-definition name generator.
  • Minor bug in our regular expression system regarding the carriage return.
2.9.12
  • Support Schema component constraint : minInclusive and minExclusive. This feature is currently only available for the Ada code generator.
  • Minor problem fixed regarding the LOCALACCEPTBODYPREFIX for Cobol.
  • When a group reference is marked as a unbounded at the complex type level in a schema, the information is percolated properly up to the corresponding meta-definition field.
2.9.11
  • Minor problem fixed regarding the test empty generator for Cobol.
  • Minor (but annoying) bug corrected in long default value support for Ada.
2.9.10
  • Minor problem fixed for CSharp code generator.
  • In table interface for the generated GUI, complete support for enumerate type.
2.9.9
  • Swift code generator updated for the standard S.W.I.F.T. 2005.
2.9.8
  • Support for a LONG datatype in Ada.
  • Minor bug corrected in the Ada code generator regarding the RegExp.
2.9.7
  • Minor bug corrected in the Ada code generator. A conflict arises when an element in the meta-definition is named “Size”.
  • In table interface for the generated GUI, now the sorting (by clicking on the column headers) impacts only the view on an otherwise unsorted collection of data. The right-clicking on a node provides a new operation which impacts the sorting on the actual collection.
2.9.6
  • Superfluous prefixes (from TARGETDIR attribute) before the system’s name in the “.h” file extensions as generated by the C code generator have been removed.
  • Minor bug fix in GUI when using VISIBILITY attribute in the FIELDGUIINFO element.
2.9.5
  • The COBOL code generator has been updated in such a way that a bug regarding the DISJUNCT is resolved.
  • Name conflict resolution improved. Significantly decreases the risk of conflict.
2.9.4
  • Minor performance improvement in encoding support for Java.
  • In table interface for the generated GUI, by right-click on an element, the user can trigger a popup-menu with a few features : clipboard functionality, selecting all elements, cloning mechanism and showing form.
  • The generated GUI supports the splash screen feature. The splash screen is displayed while the GUI is loaded. It also supports a full screen system which indicates whether the GUI should be launched in full screen or as small as possible.
2.9.3
  • Minor (but annoying) bug corrected in long integer support for Java.
  • A minor COBOL parsing problem of the zones of the negative type REAL was corrected.
  • Some COBOL compilers have a “value clause ignored” warning. This warning has been fixed.
  • Parser Java : support of different character encoding used while parsing the input and unparsing the output files. The supported charsets are : US-ASCII, ISO-8859-1, UTF-8, UTF-16BE, UTF-16LE and UTF-16.
2.9.2
  • CobolPostProcess.rcs script added to the distribution, to change the generated code in order to comply with some compiler- or environment-specific restriction.
  • Superfluous semicolons after closing braces as generated by the C code generator have been removed.
2.9.1
  • Table interface for the generated GUI : performance improvement.
  • Native support for a LONG datatype, rather than relying on simple types for this purpose.
  • Performance improvement in low-level library functions to clean-up panels in generated GUI’s.
2.8.23
  • Support for simple types in Java.
  • Documentation updated for simple types in java.
  • Swing GUI support : Table interface for the generated GUI.
2.8.22
  • The -SIMPLIFY command-line option now simplifies the nested disjunctions.
  • Fix bug of the MaxLenLength option in the COBOL-specific configuration information (for literals).
2.8.21
  • Changed the installer, thereby making the xmlbins.exe file much smaller.
  • The regular expression syntax has been made more flexible: [a|b|c] is now recognized as an equivalent for [abc].
  • IGNOREALIENATTRS can now be used with ENCLOSED constructs as well as with plain ELEMENT’s.
  • The Java distribution now includes utility classes to run a sub-process in a number of modes (blocking, non-blocking, silent, non-silent, etc).
2.8.18
  • The DTD parser’s error reporting has been corrected, it did not report any error before.
  • The DTD parser has been extended, to support quoted values in addition to plain – unquoted – values in enumerations.
2.8.17
  • The member functions in the factory for the C# version are now marked as virtual.
  • The -SIMPLIFY command-line option now simplify redundant disjunctions (disjunctions with a single argument)
  • Scrambling of enumerations is disabled when using the Lite version together with the Java or C# code generation.
2.8.15
  • There is no empty COBOL paragraph generated any longer; EXIT statements are generated if required.
  • Explicit tags are now preserved when equivalent elements are merged as part of the -SIMPLIFY process.
  • Simple types are supported and documented in the C and C++ code generators.
  • Simple types are now integrated in the regression test environment, as virtually all the code generators now support them (The only exceptions are Java, C# and YAFL).
2.8.14
  • When converting schemas to meta-definitions, groups are now expanded correctly when defined in a complex type.
  • The -SIMPLIFY command now preserves indicators.
  • Error messages in case of fields defined without valid type information have been made more readable.
2.8.13
  • A bug in dealing with the unparsing of optional disjunctions has been solved in the generic code generator (thereby impacting all code generators)
  • The COBOL code generator has been updated in such a way that redundant code generated to set the integer unparsing configuration is not generated any longer.
  • The -SIMPLIFY command-line option now removes duplicated elements in meta-definitions. Such duplicated elements usually occur as a consequence of a translation from a schema where complexType’s are used to factorize properties.
2.8.12
  • When converting schematas to meta-definitions, multiple elements with the same name used in different contexts are now supported, and map to elements with discriminating postfixes in the corresponding meta-definition.
  • When a length is marked as a restriction at the simple type level in a schema, the information is percolated properly up to the corresponding meta-definition field.
  • A number of scripts have been added to the XMLBooster distribution to allow for batched updates on meta-definitions, including override an element’s or a field’s name, putting some configuration information in a meta-definition or changing the system’s name.
2.8.11 Internal release
2.8.10
  • The verbose mode now includes a detailed dump of what is being generated in the C version, as well as for SWIFT parsing code generation.
  • A bug in the documentation has been corrected, which caused the COBOL-specific configuration information used to generated identifiers to be unreadable.
2.8.9
  • A -SWIFTCFG command-line option has been added to allow for explicit reference to a configuration file for SWIFT-related issues.
2.8.8
  • An attribute named CHECKFORSLICELEN has been added to the COBOLCONFIG element. If set to TRUE, it causes statements such as:
    MOVE XMLB-BUFFER(XMLB-PTR:XMLB-LEN) TO XMLB-WRK

    to be completed as:

    IF XMLB-LEN > 0 THEN
      MOVE XMLB-BUFFER(XMLB-PTR:XMLB-LEN) TO XMLB-WRK
    END-IF

    as the code generated by some COBOL compilers crash when extracting a slice of length zero.

2.8.6
  • Spurious error messages in XMLBooster/Swift when backtracking over optional structures are now superseded by real error messages attached to non-optional constructs.
2.8.5
  • XMLBooster/SWIFT has been extended to support C code generation in addition to Java only.
  • The performance of the entire SWIFT generation process has been improved by a factor 12.
2.8.4
  • A TRUNCATEIDENTIFIERS attribute has been added to the COBOLCONFIG element, so that all generated identifiers can be truncated to a user-defined length to comply with compiler limitations.
  • The PERM construct has been made more resilient and versatile, as it now accepts multiple occurrences of a given element, as in:
    <PERM>
      <ELEMENTREF NAME="FirstName" TARGET="first_name" />
      <ELEMENTREF NAME="LastName" TARGET="last_name" />
      <ELEMENTREF NAME="Comment" TARGET="comment_1" OPTIONAL="YES" />
      <ELEMENTREF NAME="Comment" TARGET="comment_2" OPTIONAL="YES"/>
      <ELEMENTREF NAME="Comment" TARGET="comment_3" OPTIONAL="YES"/>
    </PERM>

    where up to three “Comment” elements can be found in any order, and fetched into three separate target fields. This extension is available in all the languages supported by XMLBooster.

  • A minor bug in the way enumeration entries were generated in COBOL has been corrected.
2.8.3
  • Internal release
2.8.2
  • Code generation in the GUI made more robust
  • Bug in the Ada support for simple types has been corrected.
2.8.1
  • Simple types are now supported by the Ada code generator.
  • Bug corrected in indicator support for fields mapped to attributes.
  • Bug corrected in serialization of boolean values without explicit default value.
  • Documentation for the simple types has been completed and updated
2.8.0
  • The code generated by the C code generator produces less warnings than before.
  • Parsing float’s in Ada has been made more resilient to excessively long sequences of digits.
  • Name clashes between element names and enumerations names are solved when converting schemas to meta-definitions.
  • XMLBooster does not crash when encountering an empty REGEXP.
  • HTML documentation generation is more resilient to element names containing colon characters.
  • unsignedLong recognized as integers when converting schemas to XMLBooster’s meta-definition.
  • When converting schemas to meta-definitions, the element’s name is preferred to its type’s name for the corresponding field.
  • Automatic mapping from schema’s simple types to XMLBooster ones.
2.7.12
  • Leading spaces are not removed when recognizing isolated PCDATA’s.
2.7.11
  • GUI: Attributes in column added
  • GUI: Buttons at bottom of pane added
  • GUI: Removed a bug in coloring tab panes
  • Schema2Meta: Warn when an element or complex type is not found
  • Schema2Meta: Enumeration name sclash fixed
  • Schema2Meta: Fixed attribute values set
  • C: Enumerations enclosed in #ifdef EnumName #define EnumName #endif
2.7.10
  • General:Unparsing XML files ready for CVS integration (more Nl)
  • GUI: Correct placement of buttons
  • GUI: Update of the underlying obj structure when another list entry is selected.
2.7.9
  • Schema2Meta: xs:choice can now hold an xs:group
  • General: return values are correctly set when a fatal error occurs
  • C: Empty optional Enumerated attributes do no more cause the parser to fail
2.7.8
  • GuiGC: Bug solved on role dependant buttons on a field
  • Schema2Meta: Attributes were ignored on extensions
  • Schema2Meta: Revision of enumeration’s name
2.7.7
  • General: Optional attributes with default value are unparsed only when their corresponding field’s value differ from the default value.
  • Java: Optional Booleans were not unparsed when false, even if the default value was TRUE
  • Reporting: Attributes referencing Fields with REFTYPE are now reported instead of an InternalCheck.
  • Reporting: Too complex metadefinition generate an error instead of crashing.
2.7.6
  • General: No presence check are performed before unparsing mandatory ELEMENTREFs
  • Added a script to add prefix fields to all main elements of a metadefinition
2.7.5
  • C++: Invalids user’s specified fields names are now generated valid
  • Performance problem solved with C++ and xmlBStringContext under windows platforms
  • Schema2meta: Fixed missing attributes from a base element
  • Added a script to complete empty elements with a PCData in the metadefinition
2.7.4
  • Internal version
2.7.3
  • Support for event-base macros for SAX-like processing together with the C code generator.
  • COBOL library reviewed to use fewer COBOL features, in order to make XMLBooster usable with older COBOL compilers.
2.7.2
  • Visitors revisited 🙂
2.7.1
  • Java: Completed PREFIXFIELD attribute support
  • Java: The class name of the actual factory to use can be set in the configuration in such a way that one can redefine behaviour by subclassing without having to replace the automatically generated “main” function as generated by XMLBooster.
  • GUI: Colour coding support for form views, in addition to tree views only.
2.7.0
  • Complete revision of the documentation
  • Generated files identified by the XMLBooster Version
  • C: Resolved a minor code generation issue for AS_XXX constructs when the target field holds illegal C identifiers characters
  • C++: include xmlb.h instead of xmlB.h
  • Java: Solved nameclash when using -TYPENAMEATTR.
  • Java: Added validation support
  • GUI: allows to place simple attributes in a tab of the tabbed pane instead of above or left to the tabbed pane (ATTRIBUTESINTAB).
  • Schema2Meta: removed schema parsing bug introduced in version 2.6.19.
  • Schema2Meta: correctly handles group in shemas
  • Schema2Meta: added restriction parsing to complextypes in schemas.
  • Schema2Meta: Set to maximum occurence of a repetition
2.6.19
  • Minor bug fix in GUI when using repeated polymorph referenced
  • Check of ARRAYSIZE when parsing LIST fields for C++, Java and CSharp.
  • Minor problem solve when unparsing in c
  • Problem solved when the TAG used in element references does not corresponds to the TAG of the element
  • Problem solved when using interfaces in java, when unparsing
  • Problem solved when parsing a disjunction of an element ref and a PCData.
  • Parse schemas with holding an
  • Problem fix for COBOL unparing with BASEELEMENT
  • Problem fix for java unparsing with BASEELEMENT and interfaces
2.6.18
  • REJECTEMPTYENUMS option added
  • #ifndef and #define fixed when used with TARGETDIR
  • Bug fix: oversymplification for the command SIMPLIFY
  • Set the maximum length for COBOL strings
2.6.17
  • Support for FIXED attributes
  • Systematic use of unbounded strings in Ada.
  • Deep-clone in C++ code generation, used in copy initializers.
  • Support for the -YESSTRING and -NOSTRING command-line options when unparsing booleans.
2.6.16
  • C# version released. Goes through the entire regression test.
  • Restructure the Ada floating point parsing engine, a corresponding entry has been added to the regression test harness.
  • Minor bug in the C++ version corrected, when a disjunction is stored in a central field.
2.6.15
  • Support for processing instruction when parsing textual PCDATA. These PI’s are recognized, but not stored in the parsed attribute; and won’t be unparsed (As of today, this facility is supported by the C and Java code generators)
  • Support for FIXED attributes, which must have a well-defined valud upon parsing if present, and which are unparsed accordingly.
2.6.14
  • Support for namespaces in C++ and systematic prefixes in C, so that several parsers from different meta-definitions can be used in an application without naming conflicts.
  • Support for the -MAINS command-line option, to indicate which element(s) ought to be considered as top-level elements. This option can be used when converting DTD’s or schemas to meta-definitions; or when generating a parser from the meta-definition.
  • When converting schemas to meta-definitions, repeats in disjunctions which are themselves in repeats are simplified.
  • Made more robust in case an enumeration contains an empty item.
2.6.13
  • Bug correction: in some cases, absence of white space between opening tag and first attribute was not reported.
  • HOSTVALUE attributes in enumerations are now fully supported by the C++ code generator.
  • In generated GUI’s avoid crashing when the factory returns null for dynamically created objects.
  • Support for a global prefix attribute in the C-specific configuration information so that two parsers with common elements can be used from within one projects without name clashes.
2.6.12
  • Support for the ability to run Raincode Scripts from within XMLBooster to further automate the generation of fine-tuned parsers from schemas without altering the intermediate meta-definition manually.
  • Introducing a SCHEMACONFIG element which controls how the schemas can be turned to meta-definitions. More specifically, one can now provide the postfix that will be used to convert complex type names to elements in meta-definitions.
  • Support for namespaces in C++ code generation, so that two parsers with conflicting element names can be used in an application.
2.6.11
  • Name conflicts between fields in elements in the same inheritance chains are solved when converting from schemas.
  • Non-string simpletypes are now recognized properly when converting from schemas.
2.6.10
  • A generic_serialize function is generated by the C code generator, and is used in the regression testing system for schemas to ensure that result of the parsing can be unparsed and parsed again flawlessly.
  • A number of changes have been performed on the C code generator to make it generate code that can be accepted as is by a C++ compiler as well.
  • Bug corrected which caused the GUI-generated code to be wrong if some parts of the configuration were missing.
2.6.9
  • Support for a SHORTDESC attribute in enumeration values, which is only used to fill listboxes in generated GUI’s.
  • Support for a FIXEDDIVIDERLOCATION attribute in the FIELDGUIINFO element. This attribute is only used when the field refers to a collection, and prevents the generated GUI from resizing the left column continuously as the right part of the split pane is updated.
2.6.8
  • Support for a “TYPEID” attribute in elements, which can be used to define the identifier which relates to the element when encountering an “xsi:type=” attribute. This attribute can be used to override the default behaviour, which is based on the element’s name.
  • Support for inheritance in the COBOL code generator. This support is restricted to data structure and parser composition. There is no provision for polymorphism in XMLBooster-generated COBOL code.
  • Full review of the schema support, to generate separate XMLBooster elements for schema elements and complextypes, followed by a pass which normalizes the generated meta-definition by removing unnecessary inheritance relationships.
2.6.7
  • Support for the -COMPLETE command-line option, which defines missing fields for a meta-definition where formulas and attributes have been defined consistently, but have not always been attached to target fields.
  • The code generation for PERM constructs with only one argument has been optimized.
2.6.6
  • First tests with fixed formats support.
  • USEASNULL indicator taken into account in the Java code generator.
  • Corrected a bug which caused XMLBooster to crash when generating a parser in Ada when no Ada-specific configuration information was available.
2.6.5
  • Mapping schema’s xsd:all to PERM constructs.
  • Support for simple type mappings when converting schemas.
  • A SYNCMENUBARWITHTREE attribute can now be used for the GUI generation to add a node-specific node on the menu bar when a node in the tree view is selected.
  • minExclusive, maxExclusive, minInclusive and maxInclusive are recognized when parsing schemas, but ignored when it comes to code generation.
  • Name conflict resolution improved when used with Java and Delphi.
  • An xmlGMainFrame base class is defined and used as base class for all top-level applications generated by XMLBooster.
2.6.1
  • TreePaneFillers now provide a method that returns their enclosing tree for programmatic access.
  • Names that differ on a case difference only are considered as clashes, and treated accordingly in Java and COBOL.
2.6.0
  • First release of simpletypes support, in C and COBOL (other languages will follow).
  • Default values are used when unparsing a mandatory but missing attribute.
  • Bug in GUI when lists without atomic fields were used.
  • Permutations used in XMLBOOSTER’s own meta-definition, rather than less stringent repeated disjunctions.
2.5.15
  • Parsing real number inputs in C++ has been corrected again to better deal with extreme values.
  • In C++, all destructors have been made virtual.
  • When converting a DTD to a meta-definition, repeated disjunctions are converted in such a way that every sub-element can only be accessed through a single path.
2.5.14
  • The string literals used in the GUI’s generated by XMLBooster are now defined in an ad hoc java class, so that user can easily adapt them to their own needs.
  • A bug which occurred when parsing real values between -1 and 0 in C++ has been corrected.
  • Enumerations with single punctation characters (“+”, “-“, “:”, etc.) are now translated to sensible names (“PLUS”, “MINUS, “COLON”, etc.).
  • In the C++ code generator, destructors are now called before setting pointer attributes, thereby improving the quality of the published interface. The classes generated by XMLBooster thus own their components (sub-elements or strings) and take care of their memory management issues accordingly.
2.5.13
  • Embedded DTD’s are skipped appropriately when found in prologues, rather than failing as they did before because nested “<“-“>” were not detected appropriately.
  • Support for the PREFIXFIELD attribute, so that parsers can keep track of leading comments (including DTD’s) in the synthesized objects and regenerate them when unparsing.
  • When schemas are converted to meta-definitions, a prefix field is defined automatically for all top-level elements.
  • Confusion between comments and CDATA sections addressed in C++ code generator.
  • The regression testing system for schema to meta-definition translation is now completed. It takes a number of sample schemas,converts them to the corresponding XMLBooster meta-definitions, generates the parsers in a number of languages, and tests these parsers against sample instances. The entire process is then repeated after simplifying the generated meta-definitions using the -SIMPLIFY command-line option. This regression testing facility became necessary, as more and more sophisticated schema-related features have been made available.
2.5.12
  • Support for a system-wide COMPRESSNEWLINES attribute, which prevents the generated unparsers from adding newlines to improve presentation.
2.5.11
  • Ensuring that the field names remain the same when transforming a meta-definition using the -SIMPLIFY option.
  • Support for MIXED content, that is, content made of sequences of elements and plain text. The first version works fully in the C, C++ and Java code generators. Other code generators which support polymorphism – excluding COBOL, thus – are to follow. In this MIXED content, the white space related behaviour is controlled by a mode semantically equivalent to the whiteSpace facet in schemas.
  • The code generation in C++ and in Java has been rationalized: instead of duplicating the logic of the “append” methods during parsing, the generated code merely calls the “append” methods.
  • Bug corrected in C++ code generator, when checking for lookahead strings on page boundaries (xmlBFileContext).
  • Support for the non-repeated case of mixed content, that is, when handling a disjunction where one of the options is a PCDATA construct. This contruction is supported for all code generators, including COBOL, as it does not rely on polymorphism.
  • The DTD2META facility now recognized mixed content, and produces matching constructions in the meta-definition.
2.5.10
  • Support for a “PREV1.2” attribute in the Java configuration information to support code generation for environments with pre-version 1.2 JVMs.
2.5.9
  • Smarter strategy to decide whether an ELEMENTREF needs a target when completing a meta-definition automatically.
  • Unparsing now generates newlines in more places, while ensuring that this will have no effect at all on the semantics of the XML input. In other words, PCDATA and ALIEN formulas are not altered. This feature’s purpose is to allow XMLBooster-saved information to be stored conveniently on version control system which have much better behaviour when lines are not too long.
  • Name disambiguation scheme for inherited C fields, as inheritance is then emulated by aggregation.
  • Proper sorting of the elements when generating C++ so that base classes are defined before the corresponding derived classes.
2.5.8
  • Swift code generator updated to better support latest releases of the S.W.I.F.T. documentation.
  • Bug corrected when a permutation included an enclosed grammar structure.
  • When converting a DTD to a meta-definition, default values for attributes are transferred consistently.
2.5.7
  • First release of the PERM formula constructor. Succesfully integrated in the regression test, except for COBOL where it fails if a sub-element is empty (Should not raise problems in real-world parsers though)
  • Haskell code generator now supports a configuration item to indicate how element names are to be translated to classes
  • Mnemonic shortcuts can be attached to user-defined menus and menu items, using a MNEMONIC attribute, which value must be a valid Swing mnemonic, such as “KeyEvent.VK_R”
  • Bug corrected in the -SIMPLIFY option, when an element reference with an overridden TAG is replaced by an inline ENCLOSED construct.
  • PCDATA built automatically when converting from a schema have the OPTIONAL attribute marked as TRUE, as this reflects the semantics of the equivalent schema construct
2.5.6
  • Bug corrected in GBE generic XML parsing
  • Meta-definitions generated from schemas have IGNOREALIENATTRS and POLYMORPH attributes set to TRUE, as this seems to be the most common required behaviour
  • Simplistic support of schema’s import and include elements, so that factorized schemas can be used to generate parsers using XMLBooster
2.5.5
  • Enums in factorized simple types taken into account when converting schemas to meta-definitions
  • MINLEN attribute defined in meta-definitions, not supported yet
  • maxLength and minLength values are now translated from schemas to meta-definitions
  • Comments generation when a field is built from a schema simpleType
  • Bug corrected when a default value is an enumeration in the Java code generator
  • Identifiers containing “/” are corrected properly in the Java code generator
Sign in
classic
Forgot password?
×
Sign up

(*) Required fields

I agree with Raincode Terms & Privacy Policy

×
CONTACT US