Changeset 38

trunk/include/expat/expat.h

-              r36
+              r38
 typedef char XML_LChar;
+enum XML_Content_Type {
+  XML_CTYPE_EMPTY = 1,
+  XML_CTYPE_ANY,
+  XML_CTYPE_MIXED,
+  XML_CTYPE_NAME,
+  XML_CTYPE_CHOICE,
+  XML_CTYPE_SEQ
+enum XML_Content_Type
+{
+    XML_CTYPE_EMPTY = 1,
+    XML_CTYPE_ANY,
+    XML_CTYPE_MIXED,
+    XML_CTYPE_NAME,
+    XML_CTYPE_CHOICE,
+    XML_CTYPE_SEQ
 };
+enum XML_Content_Quant {
+  XML_CQUANT_NONE,
+  XML_CQUANT_OPT,
+  XML_CQUANT_REP,
+  XML_CQUANT_PLUS
+enum XML_Content_Quant
+{
+    XML_CQUANT_NONE,
+    XML_CQUANT_OPT,
+    XML_CQUANT_REP,
+    XML_CQUANT_PLUS
 };
+/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
+   XML_CQUANT_NONE, and the other fields will be zero or NULL.
+   If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
+   numchildren will contain number of elements that may be mixed in
+   and children point to an array of XML_Content cells that will be
+   all of XML_CTYPE_NAME type with no quantification.
+   If type == XML_CTYPE_NAME, then the name points to the name, and
+   the numchildren field will be zero and children will be NULL. The
+   quant fields indicates any quantifiers placed on the name.
+   CHOICE and SEQ will have name NULL, the number of children in
+   numchildren and children will point, recursively, to an array
+   of XML_Content cells.
+   The EMPTY, ANY, and MIXED types will only occur at top level.
+*/
+typedef struct XML_cp XML_Content;
+struct XML_cp {
+  enum XML_Content_Type     type;
+  enum XML_Content_Quant    quant;
+  const XML_Char *      name;
+  unsigned int          numchildren;
+  XML_Content *         children;
+};
+/*
+ *@@ XMLCONTENT:
+ *      structure passed with the @expat "element declaration handler"
+ *      (see XML_SetElementDeclHandler).
+ *
+ *      The model argument is the root of a tree of XMLCONTENT
+ *      nodes. If type equals XML_CTYPE_EMPTY or XML_CTYPE_ANY,
+ *      then quant will be XML_CQUANT_NONE, and the other fields
+ *      will be zero or NULL.
+ *
+ *      If type is XML_CTYPE_MIXED:
+ *
+ *      --  "quant" will be XML_CQUANT_NONE or XML_CQUANT_REP.
+ *
+ *      --  "numchildren" will contain the number of elements that
+ *          are allowed to be mixed in.
+ *
+ *      --  "children" points to a sub-array of XMLCONTENT structures
+ *          that will all have type XML_CTYPE_NAME with no quantification.
+ *
+ *      Only the root node can be type XML_CTYPE_EMPTY, XML_CTYPE_ANY,
+ *      or XML_CTYPE_MIXED.
+ *
+ *      For type XML_CTYPE_NAME, the name field points to the
+ *      name and the numchildren and children fields will be
+ *      zero and NULL. The quant field will indicate any
+ *      quantifiers placed on the name.
+ *
+ *      Types XML_CTYPE_CHOICE and XML_CTYPE_SEQ indicate a
+ *      choice or sequence respectively. The numchildren field
+ *      indicates how many nodes in the choice or sequence and
+ *      children points to the nodes.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+typedef struct _XMLCONTENT
+{
+    enum XML_Content_Type       type;
+                    // one of:
+                    // -- XML_CTYPE_EMPTY   --> quant will be XML_CQUANT_NONE, rest is NULL
+                    // -- XML_CTYPE_ANY,    --> quant will be XML_CQUANT_NONE, rest is NULL
+                    // -- XML_CTYPE_MIXED,  --> (#PCDATA) gives us this
+                    // -- XML_CTYPE_CHOICE, --> choice ("|" list)
+                    // -- XML_CTYPE_SEQ     --> sequence (comma list)
+                    // -- XML_CTYPE_NAME: used for sub-content if content has CML_CTYPE_MIXED;
+                    //                    only "name" is valid for sub-content
+    enum XML_Content_Quant      quant;
+                    // one of:
+                    // -- XML_CQUANT_NONE   --> all fields below are NULL
+                    // -- XML_CQUANT_OPT,
+                    // -- XML_CQUANT_REP,
+                    // -- XML_CQUANT_PLUS
+    const XML_Char              *name;
+    unsigned int                numchildren;
+    struct _XMLCONTENT          *children;
+} XMLCONTENT, *PXMLCONTENT;
 …
 typedef void (* EXPATENTRY XML_ElementDeclHandler) (void *userData,
                     const XML_Char *name,
                     XML_Content *model);
+                                                    const XML_Char *name,
+                                                    XMLCONTENT *model);
 void XMLPARSEAPI XML_SetElementDeclHandler(XML_Parser parser,
 …
 have standalone="yes"). If this handler returns 0, then processing
 will not continue, and the parser will return a
 XML_ERROR_NOT_STANDALONE error. */
+ERROR_EXPAT_NOT_STANDALONE error. */
 typedef int (* EXPATENTRY XML_NotStandaloneHandler)(void *userData);
 …
 The handler should return 0 if processing should not continue because of
 a fatal error in the handling of the external entity.
 In this case the calling parser will return an XML_ERROR_EXTERNAL_ENTITY_HANDLING
+In this case the calling parser will return an ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING
 error.
 Note that unlike other handlers the first argument is the parser, not userData. */
 …
 } XML_Encoding;
-/* This is called for an encoding that is unknown to the parser.
-The encodingHandlerData argument is that which was passed as the
-second argument to XML_SetUnknownEncodingHandler.
-The name argument gives the name of the encoding as specified in
-the encoding declaration.
-If the callback can provide information about the encoding,
-it must fill in the XML_Encoding structure, and return 1.
-Otherwise it must return 0.
-If info does not describe a suitable encoding,
-then the parser will return an XML_UNKNOWN_ENCODING error. */
 typedef int (* EXPATENTRY XML_UnknownEncodingHandler)(void *encodingHandlerData,
                       const XML_Char *name,
                       XML_Encoding *info);
+                                                      const XML_Char *name,
+                                                      XML_Encoding *info);
 void XMLPARSEAPI XML_SetElementHandler(XML_Parser parser,
               XML_StartElementHandler start,
               XML_EndElementHandler end);
+                                       XML_StartElementHandler start,
+                                       XML_EndElementHandler end);
 void XMLPARSEAPI XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
 …
 void XMLPARSEAPI XML_SetCharacterDataHandler(XML_Parser parser,
                 XML_CharacterDataHandler handler);
+                                             XML_CharacterDataHandler handler);
 void XMLPARSEAPI XML_SetProcessingInstructionHandler(XML_Parser parser,
                     XML_ProcessingInstructionHandler handler);
+                                                     XML_ProcessingInstructionHandler handler);
 void XMLPARSEAPI XML_SetCommentHandler(XML_Parser parser,
                       XML_CommentHandler handler);
+                                       XML_CommentHandler handler);
 void XMLPARSEAPI XML_SetCdataSectionHandler(XML_Parser parser,
                XML_StartCdataSectionHandler start,
                XML_EndCdataSectionHandler end);
+                                            XML_StartCdataSectionHandler start,
+                                            XML_EndCdataSectionHandler end);
 void XMLPARSEAPI XML_SetStartCdataSectionHandler(XML_Parser parser,
 …
 };
-/* Controls parsing of parameter entities (including the external DTD
-subset). If parsing of parameter entities is enabled, then references
-to external parameter entities (including the external DTD subset)
-will be passed to the handler set with
-XML_SetExternalEntityRefHandler.  The context passed will be 0.
-Unlike external general entities, external parameter entities can only
-be parsed synchronously.  If the external parameter entity is to be
-parsed, it must be parsed during the call to the external entity ref
-handler: the complete sequence of XML_ExternalEntityParserCreate,
-XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
-this call.  After XML_ExternalEntityParserCreate has been called to
-create the parser for the external parameter entity (context must be 0
-for this call), it is illegal to make any calls on the old parser
-until XML_ParserFree has been called on the newly created parser.  If
-the library has been compiled without support for parameter entity
-parsing (ie without XML_DTD being defined), then
-XML_SetParamEntityParsing will return 0 if parsing of parameter
-entities is requested; otherwise it will return non-zero. */
 int XMLPARSEAPI XML_SetParamEntityParsing(XML_Parser parser,
+              enum XML_ParamEntityParsing parsing);
+enum XML_Error {
+  XML_ERROR_NONE,
+  XML_ERROR_NO_MEMORY,
+  XML_ERROR_SYNTAX,
+  XML_ERROR_NO_ELEMENTS,
+  XML_ERROR_INVALID_TOKEN,
+  XML_ERROR_UNCLOSED_TOKEN,
+  XML_ERROR_PARTIAL_CHAR,
+  XML_ERROR_TAG_MISMATCH,
+  XML_ERROR_DUPLICATE_ATTRIBUTE,
+  XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
+  XML_ERROR_PARAM_ENTITY_REF,
+  XML_ERROR_UNDEFINED_ENTITY,
+  XML_ERROR_RECURSIVE_ENTITY_REF,
+  XML_ERROR_ASYNC_ENTITY,
+  XML_ERROR_BAD_CHAR_REF,
+  XML_ERROR_BINARY_ENTITY_REF,
+  XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+  XML_ERROR_MISPLACED_XML_PI,
+  XML_ERROR_UNKNOWN_ENCODING,
+  XML_ERROR_INCORRECT_ENCODING,
+  XML_ERROR_UNCLOSED_CDATA_SECTION,
+  XML_ERROR_EXTERNAL_ENTITY_HANDLING,
+  XML_ERROR_NOT_STANDALONE,
+  XML_ERROR_UNEXPECTED_STATE
+};
+                                          enum XML_ParamEntityParsing parsing);
+#define ERROR_EXPAT_NONE        0   // explicitly added V0.9.9 (2001-02-14) [umoeller]
+#define ERROR_XML_FIRST         40000   // first error code used
+typedef enum _XMLERROR
+{
+    // ERROR_EXPAT_NONE,            // removed to adhere with APIRET V0.9.9 (2001-02-14) [umoeller]
+    ERROR_EXPAT_NO_MEMORY = ERROR_XML_FIRST,
+    ERROR_EXPAT_SYNTAX,
+    ERROR_EXPAT_NO_ELEMENTS,
+    ERROR_EXPAT_INVALID_TOKEN,
+    ERROR_EXPAT_UNCLOSED_TOKEN,
+    ERROR_EXPAT_PARTIAL_CHAR,
+    ERROR_EXPAT_TAG_MISMATCH,
+    ERROR_EXPAT_DUPLICATE_ATTRIBUTE,
+    ERROR_EXPAT_JUNK_AFTER_DOC_ELEMENT,
+    ERROR_EXPAT_PARAM_ENTITY_REF,
+    ERROR_EXPAT_UNDEFINED_ENTITY,
+    ERROR_EXPAT_RECURSIVE_ENTITY_REF,
+    ERROR_EXPAT_ASYNC_ENTITY,
+    ERROR_EXPAT_BAD_CHAR_REF,
+    ERROR_EXPAT_BINARY_ENTITY_REF,
+    ERROR_EXPAT_ATTRIBUTE_EXTERNAL_ENTITY_REF,
+    ERROR_EXPAT_MISPLACED_XML_PI,
+    ERROR_EXPAT_UNKNOWN_ENCODING,
+    ERROR_EXPAT_INCORRECT_ENCODING,
+    ERROR_EXPAT_UNCLOSED_CDATA_SECTION,
+    ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING,
+    ERROR_EXPAT_NOT_STANDALONE,
+    ERROR_EXPAT_UNEXPECTED_STATE,
+    ERROR_EXPAT_AFTER_LAST      // added V0.9.9 (2001-02-14) [umoeller];
+                                // xml.h builds on this
+} XMLERROR;
 /* If XML_Parse or XML_ParseBuffer have returned 0, then XML_GetErrorCode
 returns information about the error. */
 enum XML_Error  XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
+XMLERROR  XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
 /* These functions return information about the current parse location.
 …
 /* Returns a string describing the error. */
+const XML_LChar XMLPARSEAPI * XML_ErrorString(int code);
+// const XML_LChar XMLPARSEAPI * XML_ErrorString(int code);
+        // moved this to xml.c V0.9.9 (2001-02-16) [umoeller]
 /* Return a string containing the version number of this expat */

trunk/include/expat/expat_setup.h

-              r36
+              r38
         #define EXPATENTRY _Optlink
     #endif
+    #define XML_DTD 1
 #endif

trunk/include/expat/xmlrole.h

-              r36
+              r38
 #ifndef XmlRole_INCLUDED
 #define XmlRole_INCLUDED 1
+#include "expat\expat_setup.h"
+                        // V0.9.9 (2001-02-10) [umoeller]
+                        // to save the app from having to include this as well
 #include "expat\xmltok.h"

trunk/include/expat/xmltok.h

-              r36
+              r38
 #ifndef XmlTok_INCLUDED
 #define XmlTok_INCLUDED 1
+#include "expat\expat_setup.h"
+                        // V0.9.9 (2001-02-10) [umoeller]
+                        // to save the app from having to include this as well
 #ifdef __cplusplus
 …
                               const char *);
   void (* EXPATENTRY updatePosition)(const ENCODING *,
                          const char *ptr,
                          const char *end,
                          POSITION *);
+                                     const char *ptr,
+                                     const char *end,
+                                     POSITION *);
   int (* EXPATENTRY isPublicId)(const ENCODING *enc,
                     const char *ptr,

trunk/include/helpers/linklist.h

-              r35
+              r38
     typedef LSTQUERYFIRSTNODE *PLSTQUERYFIRSTNODE;
+    PLISTNODE XWPENTRY lstQueryLastNode(PLINKLIST pList);
+    typedef PLISTNODE XWPENTRY LSTQUERYLASTNODE(PLINKLIST pList);
+    typedef LSTQUERYLASTNODE *PLSTQUERYLASTNODE;
     PLISTNODE XWPENTRY lstNodeFromIndex(PLINKLIST pList, unsigned long ulIndex);
     typedef PLISTNODE XWPENTRY LSTNODEFROMINDEX(PLINKLIST pList, unsigned long ulIndex);

trunk/include/helpers/stringh.h

r23	r38
35	35
36	36	PSZ strhdup(const char *pszSource);
	37
	38	int strhcmp(const char p1, const char p2);
37	39
38	40	PSZ strhistr(const char string1, const char string2);

trunk/include/helpers/tree.h

-              r33
+              r38
     // --  -1: t1 < t2
     // --  +1: t1 > t2
     typedef int (FNTREE_COMPARE_NODES) (TREE *t1, TREE *t2);
     typedef int (FNTREE_COMPARE_DATA) (TREE *t1, void *pData);
+    typedef int XWPENTRY FNTREE_COMPARE_NODES(TREE *t1, TREE *t2);
+    typedef int XWPENTRY FNTREE_COMPARE_DATA(TREE *t1, void *pData);
     //  Define a function type for use with the tree traversal function
     typedef void (TREE_PROCESS) (TREE *t, void *pUser);
+    typedef void XWPENTRY TREE_PROCESS(TREE *t, void *pUser);
     //  Global variables

trunk/include/helpers/xml.h

-              r35
+              r38
  *@@added V0.9.6 (2000-10-29) [umoeller]
  *@@include #include <os2.h>
  *@@include #include "expat\expat.h"
+ *@@include #include "expat\expat.h"                // must come before xml.h
  *@@include #include "helpers\linklist.h"
+ *@@include #include "helpers\tree.h"
  *@@include #include "helpers\xstring.h"
  *@@include #include "helpers\xml.h"
 …
     #endif
+    #define ERROR_DOM_FIRST                14000
+    #define ERROR_DOM_INDEX_SIZE                   (ERROR_DOM_FIRST + 1)
+    #define ERROR_DOM_DOMSTRING_SIZE               (ERROR_DOM_FIRST + 2)
+    #define ERROR_DOM_HIERARCHY_REQUEST            (ERROR_DOM_FIRST + 3)
+    #define ERROR_DOM_WRONG_DOCUMENT               (ERROR_DOM_FIRST + 4)
+    #define ERROR_DOM_INVALID_CHARACTER            (ERROR_DOM_FIRST + 5)
+    #define ERROR_DOM_NO_DATA_ALLOWED              (ERROR_DOM_FIRST + 6)
+    #define ERROR_DOM_NO_MODIFICATION_ALLOWED      (ERROR_DOM_FIRST + 7)
+    #define ERROR_DOM_NOT_FOUND                    (ERROR_DOM_FIRST + 8)
+    #define ERROR_DOM_NOT_SUPPORTED                (ERROR_DOM_FIRST + 9)
+    #define ERROR_DOM_INUSE_ATTRIBUTE              (ERROR_DOM_FIRST + 10)
+    #define ERROR_DOM_PARSING                      (ERROR_DOM_FIRST + 11)
+    #define DOMNODE_ELEMENT         1          // node is an ELEMENT
+    #define DOMNODE_ATTRIBUTE       2          // node is an ATTRIBUTE
+    #define DOMNODE_TEXT            3          // node is a TEXT node
+    // #define DOMNODE_CDATA_SECTION   4
+    // #define DOMNODE_ENTITY_REFERENCE   5
+    // #define DOMNODE_ENTITY          6
+    // #define DOMNODE_PROCESSING_INSTRUCTION   7
+    #define DOMNODE_COMMENT         8          // node is a COMMENT
+    #define DOMNODE_DOCUMENT        9          // node is a document
+    #define DOMNODE_DOCUMENT_TYPE   10         // node is a DOCUMENTTYPE
+    // #define DOMNODE_DOCUMENT_FRAGMENT   11
+    // #define DOMNODE_NOTATION        12
+    typedef enum _DOMERROR
+    {
+        // validity errors:
+// START MATCHING ERROR MESSAGES (xmlDescribeError)
+        ERROR_DOM_UNDECLARED_ELEMENT = ERROR_EXPAT_AFTER_LAST,
+                // invalidity: element is undeclared
+        ERROR_DOM_ROOT_ELEMENT_MISNAMED,
+        ERROR_DOM_INVALID_ROOT_ELEMENT,
+        ERROR_DOM_INVALID_SUBELEMENT,
+                // subelement may not appear in its parent element
+        ERROR_DOM_DUPLICATE_ELEMENT_DECL,
+                // more than one declaration for an element type
+        ERROR_DOM_DUPLICATE_ATTRIBUTE_DECL,
+                // more than one declaration for an attribute type
+        ERROR_DOM_UNDECLARED_ATTRIBUTE,
+// END MATCHING ERROR MESSAGES (xmlDescribeError)
+        // error categories:
+        ERROR_DOM_PARSING,
+        ERROR_DOM_VALIDITY,
+        // additional DOM errors
+        ERROR_DOM_NODETYPE_NOT_SUPPORTED,
+                // invalid node type in xmlCreateNode
+        ERROR_DOM_NO_DOCUMENT,
+                // cannot find document node
+        ERROR_DOM_NO_ELEMENT,
+        ERROR_DOM_DUPLICATE_DOCTYPE,
+        ERROR_DOM_DOCTYPE_STRUCTURE,
+                // DOCTYPE is given and root element name does not match doctype name
+        ERROR_DOM_INTEGRITY,
+        ERROR_DOM_DUPLICATE_ATTRIBUTE
+    } DOMERROR;
+    /* ******************************************************************
+     *
+     *   Most basic node management
+     *
+     ********************************************************************/
+    // content model node types:
+    typedef enum _NODEBASETYPE
+    {
+        DOMNODE_ELEMENT,                // node is a DOM ELEMENT
+        DOMNODE_ATTRIBUTE,              // node is a DOM ATTRIBUTE
+        DOMNODE_TEXT,                   // node is a DOM TEXT node
+            // DOMNODE_CDATA_SECTION   4
+            // DOMNODE_ENTITY_REFERENCE   5
+            // DOMNODE_ENTITY          6
+        DOMNODE_PROCESSING_INSTRUCTION, // node is a DOM PI
+        DOMNODE_COMMENT,                // node is a DOM COMMENT
+        DOMNODE_DOCUMENT,               // node is a DOM document
+        DOMNODE_DOCUMENT_TYPE,          // node is a DOM DOCUMENTTYPE
+            // #define DOMNODE_DOCUMENT_FRAGMENT   11
+            // #define DOMNODE_NOTATION        12
+        // the following are all CMELEMENTPARTICLE nodes
+        ELEMENTPARTICLE_EMPTY,
+        ELEMENTPARTICLE_ANY,
+        ELEMENTPARTICLE_MIXED,
+        ELEMENTPARTICLE_CHOICE,
+        ELEMENTPARTICLE_SEQ,
+        ELEMENTPARTICLE_NAME,
+        ATTRIBUTE_DECLARATION_BASE,     // node is a CMATTRIBUTEDECLBASE
+        ATTRIBUTE_DECLARATION,          // node is a CMATTRIBUTEDECL
+        ATTRIBUTE_DECLARATION_ENUM      // node is a plain NODEBASE, part of an attr value enum
+    } NODEBASETYPE;
+    /*
+     *@@ NODEBASE:
+     *      "content model" node. With the DOM content models,
+     *      this represents an entry in a DTD or XML schema.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _NODEBASE
+    {
+        TREE            Tree;
+        NODEBASETYPE    ulNodeType;
+        XSTRING         strNodeName;
+                    // node name;
+                    // -- for the various DOMNODE_* items, see _DOMNODE;
+                    // -- for CMELEMENTPARTICLE nodes, this is the particle's name
+                    // -- for CMELEMENTDECLNODE nodes, element name being declared
+                    // -- for CMATTRIBUTEDECLBASE nodes, name of element to which this
+                    //          attrib decl belongs
+                    // -- for CMATTRIBUTEDECL nodes, name of attribute;
+                    // -- for ATTRIBUTE_DECLARATION_ENUM, attribute value in the
+                    //          possible values list.
+    } NODEBASE, *PNODEBASE;
+    /* ******************************************************************
+     *
+     *   DOM level 1
+     *
+     ********************************************************************/
     /*
      *@@ DOMNODE:
+     *      this represents one node in an XML document.
+     *
+     *      Per definition, each XML document is broken down into
+     *      DOM nodes. The document itself is represented by a
+     *      node with the DOMNODE_DOCUMENT type, which in turn
+     *      contains all the other nodes. This thus forms a tree
+     *      as shown with xmlParse.
+     *      this represents one @DOM node in an @XML document.
+     *
+     *      The document itself is represented by a node with the
+     *      DOMNODE_DOCUMENT type, which is the root of a tree as
+     *      shown with xmlParse.
+     *
      *      The contents of the members vary according
+     *      to ulNodeType:
+     *
+     +      ulNodeType      pszNodeName     pszNodeValue        listAttributeNodes
+     *      to ulNodeType (0 specifies that the field does not
+     *      apply to that type).
+     *
+     *      The first member of a DOMNODE is a NODEBASE to allow
+     *      inserting these things in a tree. NODEBASE.ulNodeType
+     *      _always_ specifies the various types that are using
+     *      that structure to allow for type-safety (if we watch out).
+     *      This is for faking inheritance.
+     *
+     *      Note that we also implement specialized sub-structures of
+     *      DOMNODE, whose first member is the DOMNODE (and therefore
+     *      a NODEBASE as well):
+     *
+     *      --  DOCUMENT nodes are given a _DOMDOCUMENTNODE structure.
+     *
+     *      --  DOCTYPE nodes are given a _DOMDOCTYPENODE structure.
+     *
+     *      Overview of member fields usage:
+     +
+     +      ELEMENT         tag name        0                   named node map
+     +      ulNodeType    | strNodeName | strNodeValue | llChildren | llAttributes
+     +      =======================================================================
+     +                    |             |              |            |
+     +      DOCUMENT      | name from   | 0            | 1 root     | 0
+     +                    | DOCTYPE or  |              | ELEMENT    |
+     +                    | NULL        |              |            |
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      ELEMENT       | tag name    | 0          8  | ELEMENT    | ATTRIBUTE
+     +                    |             |              | nodes      | nodes
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      ATTRIBUTE     | attribute   | attribute    | 0          | 0
+     +                    | name        | value        |            |
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      TEXT          | 0           | text         | 0          | 0
+     +                    |             | contents     |            |
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      COMMENT       | 0           | comment      | 0          | 0
+     +                    |             | contents     |            |
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      PI            | PI target   | PI data      | 0          | 0
+     +                    |             |              |            |
+     +                    |             |              |            |
+     +      --------------+-------------+--------------+------------+--------------
+     +                    |             |              |            |
+     +      DOCTYPE       | doctype     |              | 0          | 0
+     +                    | name        |              |            |
+     +                    |             |              |            |
+     +
+     +      ATTRIBUTE       attribute name  attribute value     0
+     +
+     +      TEXT            0               text contents       0
+     +
+     +      COMMENT         0               comment contents    0
+     +
+     +      DOCUMENT        0               0                   0
+     *      The xwphelpers implementation does not implement CDATA sections,
+     *      for which we have no need because @expat properly converts these
+     *      into plain @content.
+     *
+     *      In addition, W3C DOM specifies that the "node name" members contain
+     *      "#document", "#text", and "#comment" strings for DOCUMENT,
+     *      TEXT, and COMMENT nodes, respectively. I see no point in this other
+     *      than consuming memory, so these fields are empty with this implementation.
      */
     typedef struct _DOMNODE
+    {
+        ULONG       ulNodeType;
+                    // one of:
+                    // -- DOMNODE_ELEMENT
+                    // -- DOMNODE_ATTRIBUTE
+                    // -- DOMNODE_TEXT
+                    // -- DOMNODE_CDATA_SECTION
+                    // -- DOMNODE_ENTITY_REFERENCE
+                    // -- DOMNODE_ENTITY
+                    // -- DOMNODE_PROCESSING_INSTRUCTION
+                    // -- DOMNODE_COMMENT
+                    // -- DOMNODE_DOCUMENT: the root document. See @documents.
+                    // -- DOMNODE_DOCUMENT_TYPE
+                    // -- DOMNODE_DOCUMENT_FRAGMENT
+                    // -- DOMNODE_NOTATION
+        XSTRING     strNodeName;            // malloc()'d
+        XSTRING     strNodeValue;           // malloc()'d
+        NODEBASE        NodeBase;
+        // PXSTRING    pstrNodeName;            // ptr is NULL if none
+        PXSTRING        pstrNodeValue;           // ptr is NULL if none
         struct _DOMNODE *pParentNode;
                         // the parent node;
+                        // NULL for DOCUMENT, DOCUMENT_FRAGMENT and ATTR
+        LINKLIST    llChildNodes;     // of DOMNODE* pointers, no auto-free
+        LINKLIST    llAttributeNodes; // of DOMNODE* pointers, no auto-free
+                        // NULL for DOCUMENT, DOCUMENT_FRAGMENT.
+                        // The DOM spec says that attribs have no parent,
+                        // but even though the attribute is not added to
+                        // the "children" list of an element (but to the
+                        // attributes map instead), we specify the element
+                        // as the attribute's parent here.
+        struct _DOMNODE *pDocumentNode;
+                        // the document node, unless this is a DOCUMENT in itself.
+        LINKLIST        llChildren;     // of DOMNODE* pointers, no auto-free
+        TREE            *AttributesMap; // of DOMNODE* pointers
     } DOMNODE, *PDOMNODE;
+    #define XMLACTION_BREAKUP               1
+    #define XMLACTION_COPYASTEXT            2
+    typedef ULONG _Optlink FNVALIDATE(const char *pcszTag);
+    typedef FNVALIDATE *PFNVALIDATE;
+    PDOMNODE xmlCreateNode(PDOMNODE pParentNode,
+                           ULONG ulNodeType);
+    /*
+     *@@ DOMDOCTYPENODE:
+     *      specific _DOMNODE replacement structure which
+     *      is used for DOCTYPE nodes.
+     *
+     *      The DOMDOCTYPENODE is special (other than having
+     *      extra fields) in that it is stored both in
+     *      the document node's children list and in its
+     *      pDocType field.
+     *
+     *      DOMNODE.pstrNodeName is set to the name in the
+     *      DOCTYPE statement by xmlCreateDocumentTypeNode,
+     *      or is NULL if there's no DOCTYPE.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _DOMDOCTYPENODE
+    {
+        DOMNODE     DomNode;
+        XSTRING     strPublicID;
+        XSTRING     strSystemID;
+        BOOL        fHasInternalSubset;
+        TREE        *ElementDeclsTree;
+                    // tree with pointers to _CMELEMENTDECLNODE nodes
+        TREE        *AttribDeclBasesTree;
+                    // tree with pointers to _CMATTRIBUTEDEDECLBASE nodes
+    } DOMDOCTYPENODE, *PDOMDOCTYPENODE;
+    /*
+     *@@ DOMDOCUMENTNODE:
+     *      specific _DOMNODE replacement structure which
+     *      is used for DOCUMENT nodes.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _DOMDOCUMENTNODE
+    {
+        DOMNODE             DomNode;
+        PDOMDOCTYPENODE     pDocType;
+                        // != NULL if DOCTYPE was found
+    } DOMDOCUMENTNODE, *PDOMDOCUMENTNODE;
+    APIRET xmlCreateNode(PDOMNODE pParentNode,
+                         ULONG ulNodeType,
+                         PDOMNODE *ppNew);
     ULONG xmlDeleteNode(PDOMNODE pNode);
+    /* ******************************************************************
+     *
+     *   DOM level 3 content models
+     *
+     ********************************************************************/
+    // data types (XML schemes):
+    #define STRING_DATATYPE                1
+    #define BOOLEAN_DATATYPE               2
+    #define FLOAT_DATATYPE                 3
+    #define DOUBLE_DATATYPE                4
+    #define LONG_DATATYPE                  5
+    #define INT_DATATYPE                   6
+    #define SHORT_DATATYPE                 7
+    #define BYTE_DATATYPE                  8
+    /*
+     *@@ CMELEMENTPARTICLE:
+     *      element declaration particle in a
+     *      _CMELEMENTDECLNODE.
+     *
+     *      One of these structures is a full
+     *      (non-pointer) member in _CMELEMENTDECLNODE.
+     *      This struct in turn has a linked list with
+     *      possible subnodes. See _CMELEMENTDECLNODE.
+     *
+     *@@added V0.9.9 (2001-02-16) [umoeller]
+     */
+    typedef struct _CMELEMENTPARTICLE
+    {
+        NODEBASE          CMNode;         // has TREE* as first item in turn
+                    // NODEBASE.ulCMNodeType may be one of these:
+                    // -- ELEMENTPARTICLE_EMPTY:
+                    //          ulRepeater will be XML_CQUANT_NONE, rest is NULL
+                    // -- ELEMENTPARTICLE_ANY:
+                    //          ulRepeater will be XML_CQUANT_NONE, rest is NULL
+                    // -- ELEMENTPARTICLE_MIXED:
+                    //          mixed content (with PCDATA); if the list contains
+                    //          something, the element may have PCDATA and sub-elements
+                    //          mixed
+                    // -- ELEMENTPARTICLE_CHOICE:
+                    //          list is a choicelist
+                    // -- ELEMENTPARTICLE_SEQ:
+                    //          list is a seqlist
+                    // -- ELEMENTPARTICLE_NAME:
+                    //          used for terminal particles in a parent particle's
+                    //          list, which finally specifies the name of a sub-particle.
+                    //          This can never appear in a root particle.
+        ULONG           ulRepeater;
+                    // one of:
+                    // -- XML_CQUANT_NONE   --> all fields below are NULL
+                    // -- XML_CQUANT_OPT,
+                    // -- XML_CQUANT_REP,
+                    // -- XML_CQUANT_PLUS
+        PLINKLIST       pllSubNodes;
+                    // linked list of sub-CMELEMENTPARTICLE structs
+                    // (for mixed, choice, seq types);
+                    // if NULL, there's no sub-CMELEMENTPARTICLE
+    } CMELEMENTPARTICLE, *PCMELEMENTPARTICLE;
+    /*
+     *@@ CMELEMENTDECLNODE:
+     *      representation of an @element_declaration within a
+     *      _DOMDOCTYPENODE (a document @DTD).
+     *
+     *      This is complicated because element declarations
+     *      are complicated with nested lists and content
+     *      particles. For this, we introduce the representation
+     *      of a _CMELEMENTPARTICLE, which is contained in the
+     *      "Particle" member.
+     *
+     *      For minimal memory consumption, the _CMELEMENTDECLNODE
+     *      is an _CMELEMENTPARTICLE with extra fields, while the
+     *      list in _CMELEMENTPARTICLE points to plain
+     *      _CMELEMENTPARTICLE structs only.
+     *
+     *      For the "root" element declaration in the DTD,
+     *      Particle.NODEBASE.ulCMNodeType will always be one of the following:
+     *
+     *      -- ELEMENTPARTICLE_EMPTY: element must be empty.
+     *
+     *      -- ELEMENTPARTICLE_ANY: element can have any content.
+     *
+     *      -- ELEMENTPARTICLE_CHOICE: _CMELEMENTPARTICLE has a choicelist with
+     *                           more _CMELEMENTPARTICLE structs.
+     *
+     *      -- ELEMENTPARTICLE_SEQ: _CMELEMENTPARTICLE has a seqlist with
+     *                           more _CMELEMENTPARTICLE structs.
+     *
+     *      -- ELEMENTPARTICLE_MIXED: element can have mixed content including #PCDATA.
+     *            If there is no content particle list, then the element may
+     *            ONLY have PCDATA. If there's a content particle list, then the
+     *            element may have both sub-elements and PCDATA. Oh my.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _CMELEMENTDECLNODE
+    {
+        CMELEMENTPARTICLE   Particle;
+                    // root particle for this element decl; this may contain
+                    // sub-particles...
+                    // this has a NODEBASE as first member, which has TREE* as
+                    // first item in turn
+        TREE            *ParticleNamesTree;
+                    // tree sorted by element names with all sub-particles,
+                    // no matter how deeply nested; this is just for quickly
+                    // checking if an element name is allowed as a sub-element
+                    // at all. Tree items are _CMELEMENTPARTICLE nodes.
+    } CMELEMENTDECLNODE, *PCMELEMENTDECLNODE;
+    typedef enum _ATTRIBCONSTRAINT
+    {
+        CMAT_IMPLIED,
+        CMAT_REQUIRED,
+        CMAT_DEFAULT_VALUE,
+        CMAT_FIXED_VALUE
+    } ATTRIBCONSTRAINT;
+    typedef enum _ATTRIBTYPE
+    {
+        CMAT_CDATA,
+        CMAT_ID,
+        CMAT_IDREF,
+        CMAT_IDREFS,
+        CMAT_ENTITY,
+        CMAT_ENTITIES,
+        CMAT_NMTOKEN,
+        CMAT_NMTOKENS,
+        CMAT_ENUM
+    } ATTRIBTYPE;
+    /*
+     *@@ CMATTRIBUTEDECL:
+     *      single attribute declaration within the attribute
+     *      declarations tree in _CMATTRIBUTEDEDECLBASE.
+     *
+     *@@added V0.9.9 (2001-02-16) [umoeller]
+     */
+    typedef struct _CMATTRIBUTEDECL
+    {
+        NODEBASE          CMNode;         // has TREE* as first item in turn
+                    // CMNode.strName is attribute name
+        // XSTRING         strType;
+        ATTRIBTYPE      ulAttrType;
+                    // one of:
+                    // -- CMAT_CDATA
+                    // -- CMAT_ID
+                    // -- CMAT_IDREF
+                    // -- CMAT_IDREFS
+                    // -- CMAT_ENTITY
+                    // -- CMAT_ENTITIES
+                    // -- CMAT_NMTOKEN
+                    // -- CMAT_NMTOKENS
+                    // -- CMAT_ENUM: pllEnum lists the allowed values.
+        TREE            *ValuesTree;
+                    // enumeration of allowed values, if CMAT_ENUM;
+                    // tree entries are plain NODEBASEs
+        ATTRIBCONSTRAINT    ulConstraint;
+                    // one of:
+                    // -- CMAT_IMPLIED: attrib can have any value.
+                    // -- CMAT_REQUIRED: attrib must be specified.
+                    // -- CMAT_DEFAULT_VALUE: attrib is optional and has default
+                    //                        value as in pstrDefaultValue.
+                    // -- CMAT_FIXED_VALUE: attrib is optional, but must have
+                    //                        fixed value as in pstrDefaultValue.
+        PXSTRING        pstrDefaultValue;
+                    // default value of this attribute; NULL with implied or required
+    } CMATTRIBUTEDECL, *PCMATTRIBUTEDECL;
+    /*
+     *@@ CMATTRIBUTEDEDECLBASE:
+     *      representation of an @attribute_declaration.
+     *
+     *      I'd love to have stored the attribute declarations with
+     *      the element specifications, but the XML spec says that
+     *      attribute declarations are allowed even if no element
+     *      declaration exists for the element to which the attribute
+     *      belongs. Now, whatever this is good for... anyway, this
+     *      forces us to do a second tree in the _DOMDOCTYPENODE node
+     *      according to attribute's element names.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _CMATTRIBUTEDEDECLBASE
+    {
+        NODEBASE        CMNode;         // has TREE* as first item in turn
+                    // CMNode.strName is element name
+        TREE            *AttribDeclsTree;
+                            // root of tree with CMATTRIBUTEDECL;
+    } CMATTRIBUTEDEDECLBASE, *PCMATTRIBUTEDEDECLBASE;
+    /*
+     *@@ CMENTITYDECLNODE:
+     *
+     *      See @entity_declaration.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _CMENTITYDECLNODE
+    {
+        NODEBASE          CMNode;
+    } CMENTITYDECLNODE, *PCMENTITYDECLNODE;
+    /*
+     *@@ CMNOTATIONDECLNODE:
+     *
+     *      See @notation_declaration.
+     *
+     *@@added V0.9.9 (2001-02-14) [umoeller]
+     */
+    typedef struct _CMNOTATIONDECLNODE
+    {
+        NODEBASE          CMNode;
+    } CMNOTATIONDECLNODE, *PCMNOTATIONDECLNODE;
     /* ******************************************************************
 …
      *      DOM instance returned by xmlCreateDOM.
+     *
      *@@added V0.9.9 (2000-02-14) [umoeller]
+     *@@added V0.9.9 (2001-02-14) [umoeller]
      */
 …
          */
+        PDOMNODE        pDocumentNode;
+        enum XML_Error  Error;
+        PDOMDOCUMENTNODE pDocumentNode;
+        PDOMDOCTYPENODE pDocTypeNode;
+                        // != NULL only if the document has a DOCTYPE
+        APIRET          arcDOM;         // validation errors etc.
+        BOOL            fInvalid;       // TRUE after validation failed
         const char      *pcszErrorDescription;
         ULONG           ulErrorLine;
         ULONG           ulErrorColumn;
+        PXSTRING        pxstrFailingNode; // element or attribute name
         /*
 …
         PDOMNODE        pLastWasTextNode;
+        PCMATTRIBUTEDEDECLBASE pAttListDeclCache;
+                            // cache for attribute declarations according
+                            // to attdecl element name
     } XMLDOM, *PXMLDOM;
+    #define DF_PARSECOMMENTS        0x0001
+    #define DF_PARSEDTD             0x0002
     APIRET xmlCreateDOM(ULONG flParserFlags,
 …
     APIRET xmlFreeDOM(PXMLDOM pDom);
+    PCMELEMENTDECLNODE xmlFindElementDecl(PXMLDOM pDom,
+                                          const XSTRING *pstrElementName);
+    PCMATTRIBUTEDEDECLBASE xmlFindAttribDeclBase(PXMLDOM pDom,
+                                                 const XSTRING *pstrElementName);
+    PCMATTRIBUTEDECL xmlFindAttribDecl(PXMLDOM pDom,
+                                       const XSTRING *pstrElementName,
+                                       const XSTRING *pstrAttribName);
 #endif

trunk/include/helpers/xstring.h

-              r32
+              r38
     typedef XSTRCPY *PXSTRCPY;
+    ULONG XWPENTRY xstrcpys(PXSTRING pxstr, const XSTRING *pcstrSource);
+    typedef ULONG XWPENTRY XSTRCPYS(PXSTRING pxstr, const XSTRING *pcstrSource);
+    typedef XSTRCPYS *PXSTRCPYS;
     ULONG XWPENTRY xstrcat(PXSTRING pxstr, const char *pcszSource, ULONG ulSourceLength);
     typedef ULONG XWPENTRY XSTRCAT(PXSTRING pxstr, const char *pcszSource, ULONG ulSourceLength);
 …
     typedef ULONG XWPENTRY XSTRCATC(PXSTRING pxstr, CHAR c);
     typedef XSTRCATC *PXSTRCATC;
+    ULONG XWPENTRY xstrcats(PXSTRING pxstr, const XSTRING *pcstrSource);
+    typedef ULONG XWPENTRY XSTRCATS(PXSTRING pxstr, const XSTRING *pcstrSource);
+    typedef XSTRCATS *PXSTRCATS;
     /*

trunk/src/helpers/dosh.c

r33	r38
1828	1828	*
1829	1829	*@@added V0.9.7 (2000-12-02) [umoeller]
1830		*@@changed V0.9.9 (2000-02-06) [umoeller]: removed disable; this broke the WarpCenter
	1830	*@@changed V0.9.9 (2001-02-06) [umoeller]: removed disable; this broke the WarpCenter
1831	1831	*/
1832	1832

trunk/src/helpers/gpih.c

-              r29
+              r38
+ *
  *      Usage: All PM programs.
+ *
- *      A word about GPI rectangles: In general, graphics operations
- *      involving device coordinates (such as regions, bit maps and
- *      bit blts, and window management) use inclusive-exclusive
- *      rectangles.  All other graphics operations, such as GPI
- *      functions that define paths, use inclusive-inclusive rectangles.
+ *
- *      This can be a problem with mixing Win and Gpi functions. For
- *      example, WinQueryWindowRect returns an inclusive-exclusive
- *      rectangle (so that the xRight value is the same as the window
- *      width -- tested V0.9.7 (2000-12-20) [umoeller]).
+ *
- *      WinFillRect expects an inclusive-exclusive rectangle, so it
- *      will work with a rectangle from WinQueryWindowRect directly.
+ *
- *      By contrast, the GpiBox expects an inclusive-inclusive rectangle.
+ *
  *      Function prefixes (new with V0.81):
 …
  */
+/*
+ *@@gloss: GPI_rectangles GPI rectangles
+ *      OS/2 PM (and GPI) uses two types of rectangles. This is rarely
+ *      mentioned in the documentation, so a word is in order here.
+ *
+ *      In general, graphics operations
+ *      involving device coordinates (such as regions, bit maps and
+ *      bit blts, and window management) use inclusive-exclusive
+ *      rectangles.  All other graphics operations, such as GPI
+ *      functions that define paths, use inclusive-inclusive rectangles.
+ *
+ *      This can be a problem with mixing Win and Gpi functions. For
+ *      example, WinQueryWindowRect returns an inclusive-exclusive
+ *      rectangle (so that the xRight value is the same as the window
+ *      width -- tested V0.9.7 (2000-12-20) [umoeller]).
+ *
+ *      WinFillRect expects an inclusive-exclusive rectangle, so it
+ *      will work with a rectangle from WinQueryWindowRect directly.
+ *
+ *      By contrast, the GpiBox expects an inclusive-inclusive rectangle.
+ */
 /* ******************************************************************
+ *
 …
+ *
  *      The specified rectangle is inclusive, that is, the top
+ *      right corner specifies the top right pixel to be drawn.
+ *      right corner specifies the top right pixel to be drawn
+ *      (see @GPI_rectangles).
+ *
  *      This sets the current position to the bottom left corner
 …
  *      The specified rectangle is inclusive, that is, the top
  *      right corner specifies the top right pixel to be drawn.
+ *      This is different from WinFillRect.
+ *      This is different from WinFillRect
+ *      (see @GPI_rectangles).
+ *
  *      If (lColor != -1), the HPS's current foreground color
 …
  *      The specified rectangle is inclusive, that is, the top
  *      right corner specifies the top right pixel to be drawn.
+ *      This is different from WinFillRect.
+ *      This is different from WinFillRect
+ *      (see @GPI_rectangles).
+ *
  *      If usWidth > 1, the additional pixels will be drawn towards
 …
  *      The specified rectangle is inclusive, that is, the top
  *      right corner specifies the top right pixel to be drawn.
+ *      This is different from WinFillRect.
+ *      This is different from WinFillRect
+ *      (see @GPI_rectangles).
+ *
  *      If usWidth > 1, the additional pixels will be drawn towards

trunk/src/helpers/helpers_post.in

-              r35
+              r38
 $(OUTPUTDIR)\xml.obj:      $(@B).c $(HLPINC)\$(@B).h \
                $(PROJECTINC)\setup.h \
                $(HLPINC)\stringh.h
+               $(HLPINC)\linklist.h $(HLPINC)\stringh.h $(HLPINC)\tree.h $(HLPINC)\xstring.h
 $(OUTPUTDIR)\xprf.obj:  $(@B).c $(HLPINC)\$(@B).h \
 …
 $(INC)\expat\asciitab.h \
 $(INC)\expat\expat.h \
+$(INC)\expat\expat_setup.h \
 $(INC)\expat\iasciitab.h \
 $(INC)\expat\latin1tab.h \
 $(INC)\expat\nametab.h \
 $(INC)\expat\utf8tab.h \
-$(INC)\expat\winconfig.h \
 $(INC)\expat\xmlrole.h \
 $(INC)\expat\xmltok.h \

trunk/src/helpers/linklist.c

-              r35
+              r38
 PLISTNODE lstQueryFirstNode(PLINKLIST pList)
+{
+    if (pList)
+        if (pList->ulMagic == LINKLISTMAGIC)
+            return (pList->pFirst);
+    if (    (pList)
+         && (pList->ulMagic == LINKLISTMAGIC)
+       )
+        return (pList->pFirst);
+    return (0);
+}
+/*
+ *@@ lstQueryLastNode:
+ *      similar to lstQueryFirstNode, but this returns
+ *      the last node.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+PLISTNODE lstQueryLastNode(PLINKLIST pList)
+{
+    if (    (pList)
+         && (pList->ulMagic == LINKLISTMAGIC)
+       )
+        return (pList->pLast);
     return (0);

trunk/src/helpers/prfh.c

r33	r38
468	468	* -- PRFERR_WRITE: couldn't write data to target (PrfWriteProfileData error)
469	469	*
470		*@@added V0.9.9 (2000-02-06) [umoeller]
	470	*@@added V0.9.9 (2001-02-06) [umoeller]
471	471	*/
472	472

trunk/src/helpers/stringh.c

-              r23
+              r38
     else
         return (0);
+}
+/*
+ *@@ strhcmp:
+ *      better strcmp. This doesn't crash if any of the
+ *      string pointers are NULL, but returns a proper
+ *      value then.
+ *
+ *      Besides, this is guaranteed to only return -1, 0,
+ *      or +1, while strcmp can return any positive or
+ *      negative value.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+int strhcmp(const char *p1, const char *p2)
+{
+    if (p1 && p2)
+    {
+        int i = strcmp(p1, p2);
+        if (i < 0) return (-1);
+        if (i > 0) return (+1);
+    }
+    else if (p1)
+        // but p2 is NULL: p1 greater than p2 then
+        return (+1);
+    else if (p2)
+        // but p1 is NULL: p1 less than p2 then
+        return (-1);
+    // return 0 if strcmp returned 0 above or both strings are NULL
+    return (0);
+}

trunk/src/helpers/threads.c

-              r33
+              r38
  *@@changed V0.9.5 (2000-08-26) [umoeller]: now using PTHREADINFO
  *@@changed V0.9.7 (2000-12-18) [lafaix]: THRF_TRANSIENT support added
  *@@changed V0.9.9 (2000-02-06) [umoeller]: now returning TID
+ *@@changed V0.9.9 (2001-02-06) [umoeller]: now returning TID
  */
 …
                 ULONG ulData)        // in: user data to be stored in THREADINFO
+{
     ULONG ulrc = 0;     // V0.9.9 (2000-02-06) [umoeller]
+    ULONG ulrc = 0;     // V0.9.9 (2001-02-06) [umoeller]
     // (2000-12-18) [lafaix] TRANSIENT

trunk/src/helpers/tree.c

-              r33
+              r38
  * fnCompareIDs:
+ *
  *added V0.9.9 (2000-02-06) [umoeller]
+ *added V0.9.9 (2001-02-06) [umoeller]
  */
 …
  *          exists.
+ *
  *@@changed V0.9.9 (2000-02-06) [umoeller]: removed comparison func
+ *@@changed V0.9.9 (2001-02-06) [umoeller]: removed comparison func
  */
 …
  *      -- 1: current node first, then left node, then right node.
  *      -- 2: left node first, then right node, then current node.
+ *      -- other: left node first, then current node, then right node.
+ *      -- 0 or other: left node first, then current node, then right node.
+ *           This is the sorted order.
  */

trunk/src/helpers/xml.c

-              r35
+              r38
  *      layers:
+ *
+ *      --  The bottom layer is implemented by expat, which I have
+ *          ported to this library. See xmlparse.c for an introduction.
+ *      --  The bottom layer is implemented by @expat, which I have
+ *          ported and hacked to the xwphelpers. See xmlparse.c for
+ *          an introduction.
+ *
  *      --  Because expat requires so many callbacks and is non-validating,
 …
  *          (DOM) standardized by the W3C. That's this file.
+ *
+ *      To understand and use this code, you should be familiar with
+ *      the following:
+ *
+ *      -- XML parsers operate on XML @documents.
+ *
+ *      -- Each XML document has both a logical and a physical
+ *         structure.
+ *
+ *         Physically, the document is composed of units called
+ *         @entities.
+ *
+ *         Logically, the document is composed of @markup and
+ *         @content. Among other things, markup separates the content
+ *         into @elements.
+ *
+ *      -- The logical and physical structures must nest properly (be
+ *         @well-formed) for each entity, which results in the entire
+ *         XML document being well-formed as well.
+ *      <B>XML</B>
+ *
+ *      In order to understand XML myself, I have written a couple of
+ *      glossary entries for the complex XML terminology. See @XML
+ *      for a start.
+ *
  *      <B>Document Object Model (DOM)</B>
+ *
+ *      In short, DOM specifies that an XML document is broken
+ *      up into a tree of nodes, representing the various parts
+ *      of an XML document. The W3C calls this "a platform- and
+ *      language-neutral interface that allows programs and scripts
+ *      to dynamically access and update the content, structure
+ *      and style of documents. The Document Object Model provides
+ *      a standard set of objects for representing HTML and XML
+ *      documents, a standard model of how these objects can
+ *      be combined, and a standard interface for accessing and
+ *      manipulating them. Vendors can support the DOM as an
+ *      interface to their proprietary data structures and APIs,
+ *      and content authors can write to the standard DOM
+ *      interfaces rather than product-specific APIs, thus
+ *      increasing interoperability on the Web."
+ *
+ *      Example: Take this HTML table definition:
+ +
+ +          <TABLE>
+ +          <TBODY>
+ +          <TR>
+ +          <TD>Column 1-1</TD>
+ +          <TD>Column 1-2</TD>
+ +          </TR>
+ +          <TR>
+ +          <TD>Column 2-1</TD>
+ +          <TD>Column 2-2</TD>
+ +          </TR>
+ +          </TBODY>
+ +          </TABLE>
+ *
+ *      This function will create a tree as follows:
+ +
+ +                          ÚÄÄÄÄÄÄÄÄÄÄÄÄ¿
+ +                          ³   TABLE    ³        (only ELEMENT node in root DOCUMENT node)
+ +                          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                                ³
+ +                          ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿
+ +                          ³   TBODY    ³        (only ELEMENT node in root "TABLE" node)
+ +                          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                    ÚÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄ¿
+ +              ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿          ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿
+ +              ³   TR       ³          ³   TR       ³
+ +              ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                ÚÄÄÄÁÄÄÄÄÄÄ¿            ÚÄÄÄÁÄÄÄÄÄÄ¿
+ +            ÚÄÄÄÁÄ¿     ÚÄÄÁÄÄ¿     ÚÄÄÄÁÄ¿     ÚÄÄÁÄÄ¿
+ +            ³ TD  ³     ³ TD  ³     ³ TD  ³     ³ TD  ³
+ +            ÀÄÄÂÄÄÙ     ÀÄÄÂÄÄÙ     ÀÄÄÄÂÄÙ     ÀÄÄÂÄÄÙ
+ +         ÉÍÍÍÍÍÊÍÍÍÍ» ÉÍÍÍÍÊÍÍÍÍÍ» ÉÍÍÍÍÊÍÍÍÍÍ» ÉÍÍÊÍÍÍÍÍÍÍ»
+ +         ºColumn 1-1º ºColumn 1-2º ºColumn 2-1º ºColumn 2-2º    (one TEXT node in each parent node)
+ +         ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ
+ *      See @DOM for a general introduction.
+ *
  *      DOM really calls for object oriented programming so the various
  *      structs can inherit from each other. Since this implementation
+ *      was supposed to be a C-only interface, we do not implement
+ *      inheritance. Instead, each XML document is broken up into a tree
+ *      of DOMNODE's only, each of which has a special type.
+ *      was supposed to be a C-only interface, we cannot implement
+ *      inheritance at the language level. Instead, each XML document
+ *      is broken up into a tree of node structures only (see _DOMNODE),
+ *      each of which has a special type. The W3C DOM allows this
+ *      (and calls this the "flattened" view, as opposed to the
+ *      "inheritance view").
+ *
+ *      The W3C DOM specification prescribes tons of methods, which I
+ *      really had no use for, so I didn't implement them. This implementation
+ *      is only a DOM insofar as it uses nodes which represent @documents,
+ *      @elements, @attributes, @comments, and @processing_instructions.
+ *
+ *      Most notably, there are the following differences:
+ *
+ *      --  Not all node types are implemented. See _DOMNODE for
+ *          the supported types.
+ *
+ *      --  Only a small subset of the standardized methods is implemented,
+ *          and they are called differently to adhere to the xwphelpers
+ *          conventions.
+ *
+ *      --  DOM uses UTF-16 for its DOMString type. @expat gives UTF-8
+ *          strings to all the handlers though, so all data in the DOM nodes
+ *          is UTF-8 encoded. This still needs to be fixed.
+ *
+ *      --  DOM defines the DOMException class. This isn't supported in C.
+ *          Instead, we use special error codes which add to the standard
+ *          OS/2 error codes (APIRET). All our error codes are >= 40000
+ *          to avoid conflicts.
+ *
  *      It shouldn't be too difficult to write a C++ encapsulation
+ *      of this which implements all the methods required by the DOM
+ *      standard.
+ *
+ *      The main entry point into this is xmlParse or
+ *      xmlCreateDocumentFromString. See remarks there for details.
+ *
+ *      Limitations:
+ *
+ *      1)  This presently only parses ELEMENT, ATTRIBUTE, TEXT,
+ *          and COMMENT nodes.
+ *
+ *      2)  This doesn't use 16-bit characters, but 8-bit characters.
+ *      of this though which fully implements all the DOM methods.
+ *
+ *      However, we do implement node management as in the standard.
+ *      See xmlCreateNode and xmlDeleteNode.
+ *
+ *      The main entry point into this is xmlCreateDOM. See remarks
+ *      there for details.
+ *
+ *      <B>Validation</B>
+ *
+ *      @expat doesn't check XML documents for whether they are @valid.
+ *      In other words, expat is a non-validating XML processor.
+ *
+ *      By contrast, this pseudo-DOM implementation can validate. To
+ *      do this, you must pass DF_PARSEDTD to xmlCreateDOM (otherwise
+ *      the @DTD entries will not be stored in the DOM nodes). This
+ *      will not validate yet; to do this, explicitly call xmlValidate.
+ *
  *@@header "helpers\xml.h"
 …
 #include "helpers\linklist.h"
 #include "helpers\stringh.h"
+#include "helpers\tree.h"
 #include "helpers\xstring.h"
 #include "helpers\xml.h"
 …
 /* ******************************************************************
+ *
  *   Node management
+ *   Generic methods
+ *
  ********************************************************************/
+/*
+ *@@ CompareCMNodeNodes:
+ *      tree comparison func for CMNodes.
+ *      This works for all trees which contain structures
+ *      whose first item is a _NODEBASE because NODEBASE's first
+ *      member is a TREE.
+ *
+ *      Used in two places:
+ *
+ *      --  to insert _CMELEMENTDECLNODE nodes into
+ *          _DOMDOCTYPENODE.ElementDeclsTree;
+ *
+ *      --  to insert _CMELEMENTPARTICLE nodes into
+ *          _CMELEMENTDECLNODE.ElementNamesTree.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+int CompareCMNodeNodes(TREE *t1,
+                       TREE *t2)
+{
+    PNODEBASE   p1 = (PNODEBASE)t1,
+                p2 = (PNODEBASE)t2;
+    return (strhcmp(p1->strNodeName.psz, p2->strNodeName.psz));
+}
+/*
+ *@@ CompareCMNodeNodes:
+ *      tree comparison func for element declarations.
+ *      Used to find nodes in _DOMDOCTYPENODE.ElementDeclsTree.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+int CompareCMNodeData(TREE *t1,
+                           void *pData)
+{
+    PNODEBASE     p1 = (PNODEBASE)t1;
+    return (strhcmp(p1->strNodeName.psz, (const char*)pData));
+}
 /*
 …
  *      creates a new DOMNODE with the specified
  *      type and parent. Other than that, the
+ *      node is zeroed.
+ */
+PDOMNODE xmlCreateNode(PDOMNODE pParentNode,        // in: parent node or NULL if root
+                       ULONG ulNodeType)            // in: DOMNODE_* type
+{
+    PDOMNODE pNewNode = (PDOMNODE)malloc(sizeof(DOMNODE));
+    if (pNewNode)
+    {
+        memset(pNewNode, 0, sizeof(DOMNODE));
+        pNewNode->ulNodeType = ulNodeType;
+ *      node fields are zeroed.
+ *
+ *      If pParentNode is specified (which is required,
+ *      unless you are creating a document node),
+ *      its children list is automatically updated
+ *      (unless this is an attribute node, which updates
+ *      the attributes map).
+ *
+ *      This returns the following errors:
+ *
+ *      --  ERROR_NOT_ENOUGH_MEMORY
+ *
+ *      --  ERROR_DOM_NOT_SUPPORTED: invalid ulNodeType
+ *          specified.
+ *
+ *      --  ERROR_DOM_WRONG_DOCUMENT: cannot find the
+ *          document for this node. This happens if you do
+ *          not have a document node at the root of your tree.
+ */
+APIRET xmlCreateNode(PDOMNODE pParentNode,        // in: parent node or NULL if root
+                     ULONG ulNodeType,            // in: DOMNODE_* type
+                     PDOMNODE *ppNew)             // out: new node
+{
+    PDOMNODE pNewNode = NULL;
+    APIRET  arc = NO_ERROR;
+    ULONG   cb = 0;
+    switch (ulNodeType)
+    {
+        case DOMNODE_DOCUMENT:
+            cb = sizeof(DOMDOCUMENTNODE);
+        break;
+        case DOMNODE_DOCUMENT_TYPE:
+            cb = sizeof(DOMDOCTYPENODE);
+        break;
+        default:
+            cb = sizeof(DOMNODE);
+        break;
+    }
+    pNewNode = (PDOMNODE)malloc(cb);
+    if (!pNewNode)
+        arc = ERROR_NOT_ENOUGH_MEMORY;
+    else
+    {
+        memset(pNewNode, 0, cb);
+        pNewNode->NodeBase.ulNodeType = ulNodeType;
+        xstrInit(&pNewNode->NodeBase.strNodeName, 0);
         pNewNode->pParentNode = pParentNode;
         if (pParentNode)
+        {
             // parent specified:
+            // append this new node to the parent's
+            // list of child nodes
+            lstAppendItem(&pParentNode->llChildNodes,
+                          pNewNode);
+            // check if this is an attribute
+            if (ulNodeType == DOMNODE_ATTRIBUTE)
+            {
+                // attribute:
+                // add to parent's attributes list
+                if (treeInsertNode(&pParentNode->AttributesMap,
+                                   (TREE*)pNewNode,
+                                   CompareCMNodeNodes,
+                                   FALSE)      // no duplicates
+                        == TREE_DUPLICATE)
+                    arc = ERROR_DOM_DUPLICATE_ATTRIBUTE;
+                                // shouldn't happen, because expat takes care of this
+            }
+            else
+                // append this new node to the parent's
+                // list of child nodes
+                lstAppendItem(&pParentNode->llChildren,
+                              pNewNode);
+            if (!arc)
+            {
+                // set document pointer...
+                // if the parent node has a document pointer,
+                // we can copy that
+                if (pParentNode->pDocumentNode)
+                    pNewNode->pDocumentNode = pParentNode->pDocumentNode;
+                else
+                    // parent has no document pointer: then it is probably
+                    // the document itself... check
+                    if (pParentNode->NodeBase.ulNodeType == DOMNODE_DOCUMENT)
+                        pNewNode->pDocumentNode = pParentNode;
+                    else
+                        arc = ERROR_DOM_NO_DOCUMENT;
+            }
+        }
+        lstInit(&pNewNode->llChildNodes, FALSE);
+        lstInit(&pNewNode->llAttributeNodes, FALSE);
+    }
+    return (pNewNode);
+        lstInit(&pNewNode->llChildren, FALSE);
+        treeInit(&pNewNode->AttributesMap);
+    }
+    if (!arc)
+        *ppNew = pNewNode;
+    else
+        if (pNewNode)
+            free(pNewNode);
+    return (arc);
+}
 /*
  *@@ xmlDeleteNode:
+ *      deletes the specified node.
+ *      deletes the specified node and updates the
+ *      parent node's children list.
+ *
  *      If the node has child nodes, all of them are deleted
 …
  *      child nodes.
+ *
  *      Returns:
+ *
  *      -- 0: NO_ERROR.
  */
 ULONG xmlDeleteNode(PDOMNODE pNode)
+ *      This returns the following errors:
+ *
+ *      -- ERROR_DOM_NOT_FOUND
+ */
+APIRET xmlDeleteNode(PDOMNODE pNode)
+{
     ULONG ulrc = 0;
 …
     if (!pNode)
+    {
         ulrc = ERROR_DOM_NOT_FOUND;
+        ulrc = ERROR_INVALID_PARAMETER;
+    }
     else
+    {
+        PLISTNODE   pNodeThis;
         // recurse into child nodes
+        PLISTNODE   pNodeThis = lstQueryFirstNode(&pNode->llChildNodes);
+        while (pNodeThis)
+        {
+        while (pNodeThis  = lstQueryFirstNode(&pNode->llChildren))
             // recurse!!
             xmlDeleteNode((PDOMNODE)(pNodeThis->pItemData));
+            pNodeThis = pNodeThis->pNext;
+        }
+        // delete attribute nodes
+        pNodeThis = lstQueryFirstNode(&pNode->llAttributeNodes);
+        while (pNodeThis)
+        {
+            // recurse!!
+            xmlDeleteNode((PDOMNODE)(pNodeThis->pItemData));
+            pNodeThis = pNodeThis->pNext;
+        }
+                        // this updates llChildren
+        // recurse into attribute nodes
+        // while (pNodeThis = lstQueryFirstNode(&pNode->llAttributes))
+            // recurse!! ###
+            // xmlDeleteNode((PDOMNODE)(pNodeThis->pItemData));
+                        // this updates llAttributes
         if (pNode->pParentNode)
+        {
             // node has a parent:
+            // remove this node from the parent's list
+            // of child nodes before deleting this node
+            lstRemoveItem(&pNode->pParentNode->llChildNodes,
+                          pNode);
+            if (pNode->NodeBase.ulNodeType == DOMNODE_ATTRIBUTE)
+                // this is an attribute:
+                // remove from parent's attributes map
+                treeDelete(&pNode->pParentNode->AttributesMap,
+                           (TREE*)pNode);
+            else
+                // remove this node from the parent's list
+                // of child nodes before deleting this node
+                lstRemoveItem(&pNode->pParentNode->llChildren,
+                              pNode);
             pNode->pParentNode = NULL;
+        }
         xstrClear(&pNode->strNodeName);
         xstrClear(&pNode->strNodeValue);
         lstClear(&pNode->llChildNodes);
         lstClear(&pNode->llAttributeNodes);
+        xstrClear(&pNode->NodeBase.strNodeName);
+        xstrFree(pNode->pstrNodeValue);
+        lstClear(&pNode->llChildren);
+        // lstClear(&pNode->llAttributes); ###
         free(pNode);
 …
+}
+/*
+ *@@ xmlGetFirstChild:
+ *      returns the first child node of pDomNode.
+ *      See _DOMNODE for what a "child" can be for the
+ *      various node types.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+PDOMNODE xmlGetFirstChild(PDOMNODE pDomNode)
+{
+    PLISTNODE pListNode = lstQueryFirstNode(&pDomNode->llChildren);
+    if (pListNode)
+        return ((PDOMNODE)pListNode->pItemData);
+    return (0);
+}
+/*
+ *@@ xmlGetLastChild:
+ *      returns the last child node of pDomNode.
+ *      See _DOMNODE for what a "child" can be for the
+ *      various node types.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+PDOMNODE xmlGetLastChild(PDOMNODE pDomNode)
+{
+    PLISTNODE pListNode = lstQueryLastNode(&pDomNode->llChildren);
+    if (pListNode)
+        return ((PDOMNODE)pListNode->pItemData);
+    return (0);
+}
+/*
+ *@@ xmlDescribeError:
+ *      returns a string describing the error corresponding to code.
+ *      The code should be one of the enums that can be returned from
+ *      XML_GetErrorCode.
+ *
+ *@@changed V0.9.9 (2001-02-14) [umoeller]: adjusted for new error codes
+ *@@changed V0.9.9 (2001-02-16) [umoeller]: moved this here from xmlparse.c
+ */
+const char* xmlDescribeError(int code)
+{
+    static const char *message[] =
+    {
+        // start of expat (parser) errors
+        "Out of memory",
+        "Syntax error",
+        "No element found",
+        "Not well-formed (invalid token)",
+        "Unclosed token",
+        "Unclosed token",
+        "Mismatched tag",
+        "Duplicate attribute",
+        "Junk after root element",
+        "Illegal parameter entity reference",
+        "Undefined entity",
+        "Recursive entity reference",
+        "Asynchronous entity",
+        "Reference to invalid character number",
+        "Reference to binary entity",
+        "Reference to external entity in attribute",
+        "XML processing instruction not at start of external entity",
+        "Unknown encoding",
+        "Encoding specified in XML declaration is incorrect",
+        "Unclosed CDATA section",
+        "Error in processing external entity reference",
+        "Document is not standalone",
+        "Unexpected parser state - please send a bug report",
+        // end of expat (parser) errors
+        // start of validation errors
+        "Element has not been declared",
+        "Root element name does not match DOCTYPE name",
+        "Invalid or duplicate root element",
+        "Invalid sub-element in parent element",
+        "Duplicate element declaration",
+        "Duplicate attribute declaration",
+        "Undeclared attribute in element"
+    };
+    int code2 = code - ERROR_XML_FIRST;
+    if (    code2 >= 0
+         && code2 < sizeof(message) / sizeof(message[0])
+       )
+        return message[code2];
+    return 0;
+}
+/*
+ *@@ xmlSetError:
+ *      sets the DOM's error state and stores error information
+ *      and parser position.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+VOID xmlSetError(PXMLDOM pDom,
+                 APIRET arc,
+                 const char *pcszFailing,
+                 BOOL fValidityError)   // in: if TRUE, this is a validation error;
+                                        // if FALSE, this is a parser error
+{
+    pDom->arcDOM = arc;
+    pDom->pcszErrorDescription = xmlDescribeError(pDom->arcDOM);
+    pDom->ulErrorLine = XML_GetCurrentLineNumber(pDom->pParser);
+    pDom->ulErrorColumn = XML_GetCurrentColumnNumber(pDom->pParser);
+    if (pcszFailing)
+    {
+        if (!pDom->pxstrFailingNode)
+            pDom->pxstrFailingNode = xstrCreate(0);
+        xstrcpy(pDom->pxstrFailingNode, pcszFailing, 0);
+    }
+    if (fValidityError)
+        pDom->fInvalid = TRUE;
+}
 /* ******************************************************************
+ *
+ *   Specific DOM node methods
+ *
+ ********************************************************************/
+/*
+ *@@ xmlCreateElementNode:
+ *      creates a new element node with the specified name.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreateElementNode(PDOMNODE pParent,         // in: parent node (either document or element)
+                            const char *pcszElement,  // in: element name (null-terminated)
+                            PDOMNODE *ppNew)
+{
+    PDOMNODE pNew = NULL;
+    APIRET arc = xmlCreateNode(pParent,
+                               DOMNODE_ELEMENT,
+                               &pNew);
+    if (arc == NO_ERROR)
+    {
+        xstrcpy(&pNew->NodeBase.strNodeName, pcszElement, 0);
+        *ppNew = pNew;
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreateAttributeNode:
+ *      creates a new attribute node with the specified data.
+ *
+ *      NOTE: Attributes have no "parent" node, technically.
+ *      They are added to a special, separate list in @DOM_ELEMENT
+ *      nodes.
+ *
+ *      This returns the following errors:
+ *
+ *      --  Error codes from xmlCreateNode.
+ *
+ *      --  ERROR_DOM_NO_ELEMENT: pElement is invalid or does
+ *          not point to an @DOM_ELEMENT node.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreateAttributeNode(PDOMNODE pElement,        // in: element node
+                              const char *pcszName,     // in: attribute name (null-terminated)
+                              const char *pcszValue,    // in: attribute value (null-terminated)
+                              PDOMNODE *ppNew)
+{
+    APIRET arc = NO_ERROR;
+    if (    !pElement
+         || pElement->NodeBase.ulNodeType != DOMNODE_ELEMENT
+       )
+        arc = ERROR_DOM_NO_ELEMENT;
+    else
+    {
+        PDOMNODE pNew = NULL;
+        arc = xmlCreateNode(pElement,          // this takes care of adding to the list
+                            DOMNODE_ATTRIBUTE,
+                            &pNew);
+        if (arc == NO_ERROR)
+        {
+            xstrcpy(&pNew->NodeBase.strNodeName, pcszName, 0);
+            pNew->pstrNodeValue = xstrCreate(0);
+            xstrcpy(pNew->pstrNodeValue, pcszValue, 0);
+            *ppNew = pNew;
+        }
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreateTextNode:
+ *      creates a new text node with the specified content.
+ *
+ *      Note: This differs from the createText method
+ *      as specified by DOM, which has no ulLength parameter.
+ *      We need this for speed with @expat though.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreateTextNode(PDOMNODE pParent,         // in: parent element node
+                         const char *pcszText,     // in: ptr to start of text
+                         ULONG ulLength,           // in: length of *pcszText
+                         PDOMNODE *ppNew)
+{
+    PDOMNODE pNew = NULL;
+    APIRET arc = xmlCreateNode(pParent,
+                               DOMNODE_TEXT,
+                               &pNew);
+    if (arc == NO_ERROR)
+    {
+        PSZ pszNodeValue = (PSZ)malloc(ulLength + 1);
+        if (!pszNodeValue)
+        {
+            arc = ERROR_NOT_ENOUGH_MEMORY;
+            xmlDeleteNode(pNew);
+        }
+        else
+        {
+            memcpy(pszNodeValue, pcszText, ulLength);
+            pszNodeValue[ulLength] = '\0';
+            pNew->pstrNodeValue = xstrCreate(0);
+            xstrset(pNew->pstrNodeValue, pszNodeValue);
+            *ppNew = pNew;
+        }
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreateCommentNode:
+ *      creates a new comment node with the specified
+ *      content.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreateCommentNode(PDOMNODE pParent,         // in: parent element node
+                            const char *pcszText,     // in: comment (null-terminated)
+                            PDOMNODE *ppNew)
+{
+    PDOMNODE pNew = NULL;
+    APIRET arc = xmlCreateNode(pParent,
+                               DOMNODE_COMMENT,
+                               &pNew);
+    if (arc == NO_ERROR)
+    {
+        pNew->pstrNodeValue = xstrCreate(0);
+        xstrcpy(pNew->pstrNodeValue, pcszText, 0);
+        *ppNew = pNew;
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreatePINode:
+ *      creates a new processing instruction node with the
+ *      specified data.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreatePINode(PDOMNODE pParent,         // in: parent element node
+                       const char *pcszTarget,   // in: PI target (null-terminated)
+                       const char *pcszData,     // in: PI data (null-terminated)
+                       PDOMNODE *ppNew)
+{
+    PDOMNODE pNew = NULL;
+    APIRET arc = xmlCreateNode(pParent,
+                               DOMNODE_PROCESSING_INSTRUCTION,
+                               &pNew);
+    if (arc == NO_ERROR)
+    {
+        xstrcpy(&pNew->NodeBase.strNodeName, pcszTarget, 0);
+        pNew->pstrNodeValue = xstrCreate(0);
+        xstrcpy(pNew->pstrNodeValue, pcszData, 0);
+        *ppNew = pNew;
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreateDocumentTypeNode:
+ *      creates a new document type node with the
+ *      specified data.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+APIRET xmlCreateDocumentTypeNode(PDOMDOCUMENTNODE pDocumentNode,            // in: document node
+                                 const char *pcszDoctypeName,
+                                 const char *pcszSysid,
+                                 const char *pcszPubid,
+                                 int fHasInternalSubset,
+                                 PDOMDOCTYPENODE *ppNew)
+{
+    APIRET arc = NO_ERROR;
+    if (pDocumentNode->pDocType)
+        // we already have a doctype:
+        arc = ERROR_DOM_DUPLICATE_DOCTYPE;
+    else
+    {
+        // create doctype node
+        PDOMDOCTYPENODE pNew = NULL;
+        arc = xmlCreateNode((PDOMNODE)pDocumentNode,
+                            DOMNODE_DOCUMENT_TYPE,
+                            (PDOMNODE*)&pNew);
+        if (!arc)
+        {
+            // the node has already been added to the children
+            // list of the document node... in addition, set
+            // the doctype field in the document
+            pDocumentNode->pDocType = pNew;
+            // initialize the extra fields
+            xstrcpy(&pNew->strPublicID, pcszPubid, 0);
+            xstrcpy(&pNew->strSystemID, pcszSysid, 0);
+            pNew->fHasInternalSubset = fHasInternalSubset;
+            if (pcszDoctypeName)
+            {
+                ULONG ul = strlen(pcszDoctypeName);
+                if (ul)
+                {
+                    xstrcpy(&pDocumentNode->DomNode.NodeBase.strNodeName,
+                            pcszDoctypeName,
+                            ul);
+                }
+            }
+            treeInit(&pNew->ElementDeclsTree);
+            treeInit(&pNew->AttribDeclBasesTree);
+            *ppNew = pNew;
+        }
+    }
+    return (arc);
+}
+/*
+ *@@ xmlGetElementsByTagName:
+ *      returns a linked list of @DOM_ELEMENT nodes which
+ *      match the specified element name. The special name
+ *      "*" matches all elements.
+ *
+ *      The caller must free the list by calling lstFree.
+ *      Returns NULL if no such elements could be found.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+PLINKLIST xmlGetElementsByTagName(const char *pcszName)
+{
+    APIRET arc = NO_ERROR;
+    return (0);
+}
+/* ******************************************************************
+ *
+ *   Content model methods
+ *
+ ********************************************************************/
+/*
+ *@@ SetupParticleAndSubs:
+ *
+ *      This creates sub-particles and recurses to set them up,
+ *      if necessary.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+APIRET SetupParticleAndSubs(PCMELEMENTPARTICLE pParticle,
+                            PXMLCONTENT pModel,
+                            TREE **ppElementNamesTree) // in: ptr to _CMELEMENTDECLNODE.ElementNamesTree
+                                                       // (passed to all recursions)
+{
+    APIRET arc = NO_ERROR;
+    // set up member NODEBASE
+    switch (pModel->type)
+    {
+        case XML_CTYPE_EMPTY: // that's easy
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_EMPTY;
+        break;
+        case XML_CTYPE_ANY:   // that's easy
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_ANY;
+        break;
+        case XML_CTYPE_NAME:   // that's easy
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_NAME;
+            xstrInitCopy(&pParticle->CMNode.strNodeName, pModel->name, 0);
+            treeInsertNode(ppElementNamesTree,
+                           &pParticle->CMNode.Tree,
+                           CompareCMNodeNodes,
+                           TRUE);       // allow duplicates here
+        break;
+        case XML_CTYPE_MIXED:
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_MIXED;
+        break;
+        case XML_CTYPE_CHOICE:
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_CHOICE;
+        break;
+        case XML_CTYPE_SEQ:
+            pParticle->CMNode.ulNodeType = ELEMENTPARTICLE_SEQ;
+        break;
+    }
+    pParticle->ulRepeater = pModel->quant;
+    if (pModel->numchildren)
+    {
+        // these are the three cases where we have subnodes
+        // in the XMLCONTENT... go for these and recurse
+        ULONG ul;
+        pParticle->pllSubNodes = lstCreate(FALSE);
+        for (ul = 0;
+             ul < pModel->numchildren;
+             ul++)
+        {
+            PXMLCONTENT pSubModel = &pModel->children[ul];
+            PCMELEMENTPARTICLE pSubNew
+                = (PCMELEMENTPARTICLE)malloc(sizeof(*pSubNew));
+            if (!pSubNew)
+                arc = ERROR_NOT_ENOUGH_MEMORY;
+            else
+            {
+                memset(pSubNew, 0, sizeof(*pSubNew));
+                arc = SetupParticleAndSubs(pSubNew,
+                                           pSubModel,
+                                           ppElementNamesTree);
+                if (!arc)
+                    // no error: append sub-particle to this particle's
+                    // children list
+                    lstAppendItem(pParticle->pllSubNodes,
+                                  pSubNew);
+            }
+            if (arc)
+                break;
+        }
+    }
+    return (arc);
+}
+/*
+ *@@ xmlCreateElementDecl:
+ *      creates a new _CMELEMENTDECLNODE for the specified
+ *      _XMLCONTENT content model (which is the @expat structure).
+ *      This recurses, if necessary.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+APIRET xmlCreateElementDecl(const char *pcszName,
+                            PXMLCONTENT pModel,
+                            PCMELEMENTDECLNODE *ppNew)
+{
+    APIRET arc = NO_ERROR;
+    PCMELEMENTDECLNODE pNew = (PCMELEMENTDECLNODE)malloc(sizeof(*pNew));
+    if (!pNew)
+        arc = ERROR_NOT_ENOUGH_MEMORY;
+    else
+    {
+        memset(pNew, 0, sizeof(CMELEMENTDECLNODE));
+        // pNew->Particle.CMNode.ulNodeType = ELEMENT_DECLARATION;
+        xstrcpy(&pNew->Particle.CMNode.strNodeName, pcszName, 0);
+        treeInit(&pNew->ParticleNamesTree);
+        // set up the "particle" member and recurse into sub-particles
+        arc = SetupParticleAndSubs(&pNew->Particle,
+                                   pModel,
+                                   &pNew->ParticleNamesTree);
+        if (!arc)
+            *ppNew = pNew;
+        else
+            free(pNew);
+    }
+    return (arc);
+}
+/*
+ *@@ xmlFindElementDecl:
+ *      returns the _CMELEMENTDECLNODE for the element
+ *      with the specified name or NULL if there's none.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+PCMELEMENTDECLNODE xmlFindElementDecl(PXMLDOM pDom,
+                                      const XSTRING *pstrElementName)
+{
+    PCMELEMENTDECLNODE pElementDecl = NULL;
+    PDOMDOCTYPENODE pDocTypeNode = pDom->pDocTypeNode;
+    if (    (pDocTypeNode)
+         && (pstrElementName)
+         && (pstrElementName->ulLength)
+       )
+    {
+        pElementDecl = treeFindEQData(&pDocTypeNode->ElementDeclsTree,
+                                      (void*)pstrElementName->psz,
+                                      CompareCMNodeData);
+    }
+    return (pElementDecl);
+}
+/*
+ *@@ xmlFindAttribDeclBase:
+ *      returns the _CMATTRIBUTEDEDECLBASE for the specified
+ *      element name, or NULL if none exists.
+ *
+ *      To find a specific attribute declaration from both
+ *      an element and an attribute name, use xmlFindAttribDecl
+ *      instead.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+PCMATTRIBUTEDEDECLBASE xmlFindAttribDeclBase(PXMLDOM pDom,
+                                             const XSTRING *pstrElementName)
+{
+    PCMATTRIBUTEDEDECLBASE pAttribDeclBase = NULL;
+    PDOMDOCTYPENODE pDocTypeNode = pDom->pDocTypeNode;
+    if (    (pDocTypeNode)
+         && (pstrElementName)
+         && (pstrElementName->ulLength)
+       )
+    {
+        pAttribDeclBase = treeFindEQData(&pDocTypeNode->AttribDeclBasesTree,
+                                         (void*)pstrElementName->psz,
+                                         CompareCMNodeData);
+    }
+    return (pAttribDeclBase);
+}
+/*
+ *@@ xmlFindAttribDecl:
+ *      returns the _CMATTRIBUTEDEDECL for the specified
+ *      element and attribute name, or NULL if none exists.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+PCMATTRIBUTEDECL xmlFindAttribDecl(PXMLDOM pDom,
+                                   const XSTRING *pstrElementName,
+                                   const XSTRING *pstrAttribName)
+{
+    PCMATTRIBUTEDECL pAttribDecl = NULL;
+    if (pstrElementName && pstrAttribName)
+    {
+        PCMATTRIBUTEDEDECLBASE pAttribDeclBase = xmlFindAttribDeclBase(pDom,
+                                                                       pstrElementName);
+        if (pAttribDeclBase)
+        {
+            pAttribDecl = treeFindEQData(&pAttribDeclBase->AttribDeclsTree,
+                                         (void*)pstrAttribName->psz,
+                                         CompareCMNodeData);
+        }
+    }
+    return (pAttribDecl);
+}
+/*
+ *@@ ValidateElement:
+ *      validates the specified element against the document's
+ *      @DTD.
+ *
+ *      This sets arcDOM in XMLDOM on errors.
+ *
+ *      According to the XML spec, an element is valid if there
+ *      is a declaration matching the element declaration where the
+ *      element's name matches the element type, and _one_ of the
+ *      following holds: ###
+ *
+ *      (1) The declaration matches EMPTY and the element has no @content.
+ *
+ *      (2) The declaration matches (children) (see @element_declaration)
+ *          and the sequence of child elements belongs to the language
+ *          generated by the regular expression in the content model, with
+ *          optional @white_space between the start-tag and the first child
+ *          element, between child elements, or between the last
+ *          child element and the end-tag. Note that a CDATA section
+ *          is never considered "whitespace", even if it contains
+ *          white space only.
+ *
+ *      (3) The declaration matches (mixed) (see @element_declaration)
+ *          and the content consists of @content and child elements
+ *          whose types match names in the content model.
+ *
+ *      (4) The declaration matches ANY, and the types of any child
+ *          elements have been declared. (done)
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+VOID ValidateElement(PXMLDOM pDom,
+                     PDOMNODE pElement)
+{
+    // yes: get the element decl from the tree
+    PCMELEMENTDECLNODE pElementDecl = xmlFindElementDecl(pDom,
+                                                         &pElement->NodeBase.strNodeName);
+    if (!pElementDecl)
+    {
+        xmlSetError(pDom,
+                    ERROR_DOM_UNDECLARED_ELEMENT,
+                    pElement->NodeBase.strNodeName.psz,
+                    TRUE);
+    }
+    else
+    {
+        // element has been declared:
+        // check if it may appear in this element's parent...
+        PDOMNODE pParentElement = pElement->pParentNode;
+        if (!pParentElement)
+            pDom->arcDOM = ERROR_DOM_INTEGRITY;
+        else switch (pParentElement->NodeBase.ulNodeType)
+        {
+            case DOMNODE_DOCUMENT:
+            {
+                // if this is the root element, compare its name
+                // to the DOCTYPE name
+                if (pParentElement != (PDOMNODE)pDom->pDocumentNode)
+                    xmlSetError(pDom,
+                                ERROR_DOM_INVALID_ROOT_ELEMENT,
+                                pElement->NodeBase.strNodeName.psz,
+                                TRUE);
+                else if (strcmp(pDom->pDocumentNode->DomNode.NodeBase.strNodeName.psz,
+                                pElement->NodeBase.strNodeName.psz))
+                    // no match:
+                    xmlSetError(pDom,
+                                ERROR_DOM_ROOT_ELEMENT_MISNAMED,
+                                pElement->NodeBase.strNodeName.psz,
+                                TRUE);
+            break; }
+            case DOMNODE_ELEMENT:
+            {
+                // parent of element is another element:
+                // check the parent in the DTD and find out if
+                // this element may appear in the parent element
+                PCMELEMENTDECLNODE pParentElementDecl
+                        = xmlFindElementDecl(pDom,
+                                             &pParentElement->NodeBase.strNodeName);
+                if (!pParentElementDecl)
+                    pDom->arcDOM = ERROR_DOM_INTEGRITY;
+                else
+                {
+                    // now check the element names tree of the parent element decl
+                    // for whether this element is allowed as a sub-element at all
+                    PCMELEMENTPARTICLE pParticle
+                        = treeFindEQData(&pParentElementDecl->ParticleNamesTree,
+                                         (void*)pElement->NodeBase.strNodeName.psz,
+                                         CompareCMNodeData);
+                    if (!pParticle)
+                        // not found: then this element is not allowed within this
+                        // parent
+                        xmlSetError(pDom,
+                                    ERROR_DOM_INVALID_SUBELEMENT,
+                                    pElement->NodeBase.strNodeName.psz,
+                                    TRUE);
+                }
+            break; }
+        }
+    }
+}
+/*
+ *@@ ValidateAttribute:
+ *      validates the specified element against the document's
+ *      @DTD.
+ *
+ *      This sets arcDOM in XMLDOM on errors.
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+VOID ValidateAttribute(PXMLDOM pDom,
+                       PDOMNODE pAttrib)
+{
+    PDOMNODE pElement = pAttrib->pParentNode;
+    PCMATTRIBUTEDECL pAttribDecl = xmlFindAttribDecl(pDom,
+                                                     &pElement->NodeBase.strNodeName,
+                                                     &pAttrib->NodeBase.strNodeName);
+    if (!pAttribDecl)
+        xmlSetError(pDom,
+                    ERROR_DOM_UNDECLARED_ATTRIBUTE,
+                    pAttrib->NodeBase.strNodeName.psz,
+                    TRUE);
+}
+/* ******************************************************************
+ *
  *   Expat handlers
+ *
 …
 /*
  *@@ StartElementHandler:
  *      expat handler called when a new element is
+ *      @expat handler called when a new element is
  *      found.
+ *
 …
  */
 void EXPATENTRY StartElementHandler(void *data,           // in: our PXMLFILE really
+void EXPATENTRY StartElementHandler(void *pUserData,      // in: our PXMLDOM really
                                     const char *pcszElement,
                                     const char **papcszAttribs)
+{
+    PXMLDOM     pDom = (PXMLDOM)data;
+    ULONG       i;
+    PDOMNODE    pParent = NULL,
+                pNew = NULL;
+    PLISTNODE   pParentNode = lstPop(&pDom->llStack);
+    if (pParentNode)
+    {
+        // non-root level:
+        pParent = (PDOMNODE)pParentNode->pItemData;
+        pNew = xmlCreateNode(pParent,
+                             DOMNODE_ELEMENT);
+        if (pNew)
+            xstrcpy(&pNew->strNodeName, pcszElement, 0);
+        // push this on the stack so we can add child elements
+        lstPush(&pDom->llStack, pNew);
+        // now for the attribs
+        for (i = 0;
+             papcszAttribs[i];
+             i += 2)
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        ULONG       i;
+        PDOMNODE    pParent = NULL,
+                    pNew = NULL;
+        PLISTNODE   pParentNode = lstPop(&pDom->llStack);
+        if (!pParentNode)
+            pDom->arcDOM = ERROR_DOM_NO_DOCUMENT;
+        else
+        {
+            PDOMNODE    pAttrNode = xmlCreateNode(pNew,     // element
+                                                  DOMNODE_ATTRIBUTE);
+            if (pAttrNode)
+            // we have at least one node:
+            pParent = (PDOMNODE)pParentNode->pItemData;
+            pDom->arcDOM = xmlCreateElementNode(pParent,
+                                                pcszElement,
+                                                &pNew);
+            if (!pDom->arcDOM)
+            {
+                xstrcpy(&pAttrNode->strNodeName, papcszAttribs[i], 0);
+                xstrcpy(&pAttrNode->strNodeValue, papcszAttribs[i + 1], 0);
+                // shall we validate?
+                if (pDom->pDocTypeNode)
+                {
+                    // yes:
+                    ValidateElement(pDom,
+                                    pNew);
+                }
+                if (!pDom->arcDOM)
+                {
+                    // OK, node is valid:
+                    // push this on the stack so we can add child elements
+                    lstPush(&pDom->llStack, pNew);
+                    // now for the attribs
+                    for (i = 0;
+                         (papcszAttribs[i]) && (!pDom->arcDOM);
+                         i += 2)
+                    {
+                        PDOMNODE pAttrib;
+                        pDom->arcDOM = xmlCreateAttributeNode(pNew,                    // element,
+                                                              papcszAttribs[i],        // attr name
+                                                              papcszAttribs[i + 1],    // attr value
+                                                              &pAttrib);
+                        // shall we validate?
+                        if (pDom->pDocTypeNode)
+                        {
+                            ValidateAttribute(pDom,
+                                              pAttrib);
+                        }
+                    }
+                }
+            }
+        }
+    }
     pDom->pLastWasTextNode = NULL;
+        pDom->pLastWasTextNode = NULL;
+    }
+}
 /*
  *@@ EndElementHandler:
+ *
+ */
+void EXPATENTRY EndElementHandler(void *data,             // in: our PXMLFILE really
+ *      @expat handler for when parsing an element is done.
+ *      We pop the element off of our stack then.
+ */
+void EXPATENTRY EndElementHandler(void *pUserData,      // in: our PXMLDOM really
                                   const XML_Char *name)
+{
+    PXMLDOM     pDom = (PXMLDOM)data;
+    PLISTNODE   pNode = lstPop(&pDom->llStack);
+    if (pNode)
+        lstRemoveNode(&pDom->llStack, pNode);
+    pDom->pLastWasTextNode = NULL;
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        PLISTNODE   pNode = lstPop(&pDom->llStack);
+        if (pNode)
+            lstRemoveNode(&pDom->llStack, pNode);
+        pDom->pLastWasTextNode = NULL;
+    }
+}
 /*
  *@@ CharacterDataHandler:
+ *
+ */
+void EXPATENTRY CharacterDataHandler(void *userData,      // in: our PXMLFILE really
+ *      @expat handler for character data (@content).
+ *
+ *      Note: expat passes chunks of content without zero-terminating
+ *      them. We must concatenate the chunks to a full text node.
+ */
+void EXPATENTRY CharacterDataHandler(void *pUserData,      // in: our PXMLDOM really
                                      const XML_Char *s,
                                      int len)
+{
+    PXMLDOM     pDom = (PXMLDOM)userData;
+    ULONG       i;
+    if (len)
+    {
+        if (pDom->pLastWasTextNode)
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        ULONG       i;
+        if (len)
+        {
+            // we had a text node, and no elements or other
+            // stuff in between:
+            xstrcat(&pDom->pLastWasTextNode->strNodeValue,
+                    s,
+                    len);
+            if (pDom->pLastWasTextNode)
+            {
+                // we had a text node, and no elements or other
+                // stuff in between:
+                xstrcat(pDom->pLastWasTextNode->pstrNodeValue,
+                        s,
+                        len);
+            }
+            else
+            {
+                // we need a new text node:
+                PDOMNODE pNew,
+                         pParent;
+                // non-root level:
+                PLISTNODE pParentNode = lstPop(&pDom->llStack);
+                pParent = (PDOMNODE)pParentNode->pItemData;
+                pDom->arcDOM = xmlCreateTextNode(pParent,
+                                                 s,
+                                                 len,
+                                                 &pDom->pLastWasTextNode);
+            }
+        }
+    }
+}
+/*
+ *@@ CommentHandler:
+ *      @expat handler for @comments.
+ *
+ *      Note: This is only set if DF_PARSECOMMENTS is
+ *      flagged with xmlCreateDOM.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY CommentHandler(void *pUserData,      // in: our PXMLDOM really
+                               const XML_Char *data)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        PLISTNODE   pParentNode = lstPop(&pDom->llStack);
+        if (pParentNode)
+        {
+            // non-root level:
+            PDOMNODE pParent = (PDOMNODE)pParentNode->pItemData;
+            PDOMNODE pComment;
+            pDom->arcDOM = xmlCreateCommentNode(pParent,
+                                                data,
+                                                &pComment);
+        }
+    }
+}
+/*
+ *@@ StartDoctypeDeclHandler:
+ *      @expat handler that is called at the start of a DOCTYPE
+ *      declaration, before any external or internal subset is
+ *      parsed.
+ *
+ *      Both pcszSysid and pcszPubid may be NULL. "fHasInternalSubset"
+ *      will be non-zero if the DOCTYPE declaration has an internal subset.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY StartDoctypeDeclHandler(void *pUserData,
+                                        const XML_Char *pcszDoctypeName,
+                                        const XML_Char *pcszSysid,
+                                        const XML_Char *pcszPubid,
+                                        int fHasInternalSubset)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        // get the document node
+        PDOMDOCUMENTNODE pDocumentNode = pDom->pDocumentNode;
+        if (!pDocumentNode)
+            pDom->arcDOM = ERROR_DOM_NO_DOCUMENT;
         else
+        {
+            // we need a new text node:
+            PDOMNODE pNew,
+                     pParent;
+            // non-root level:
+            PLISTNODE pParentNode = lstPop(&pDom->llStack);
+            pParent = (PDOMNODE)pParentNode->pItemData;
+            pNew = xmlCreateNode(pParent,
+                                 DOMNODE_TEXT);
+            if (pNew)
+            pDom->arcDOM = xmlCreateDocumentTypeNode(pDocumentNode,
+                                                     pcszDoctypeName,
+                                                     pcszSysid,
+                                                     pcszPubid,
+                                                     fHasInternalSubset,
+                                                     &pDom->pDocTypeNode);
+            // push this on the stack so we can add child elements
+            lstPush(&pDom->llStack, pDom->pDocTypeNode);
+        }
+    }
+}
+/*
+ *@@ EndDoctypeDeclHandler:
+ *      @expat handler that is called at the end of a DOCTYPE
+ *      declaration, after parsing any external subset.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY EndDoctypeDeclHandler(void *pUserData)      // in: our PXMLDOM really
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    PLISTNODE pListNode = lstPop(&pDom->llStack);
+    if (!pListNode)
+        pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+    else
+    {
+        PDOMNODE pDomNode = (PDOMNODE)pListNode->pItemData;
+        if (pDomNode->NodeBase.ulNodeType != DOMNODE_DOCUMENT_TYPE)
+            pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+        lstRemoveNode(&pDom->llStack, pListNode);
+    }
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+    }
+}
+/*
+ *@@ NotationDeclHandler:
+ *      @expat handler for @notation_declarations.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY NotationDeclHandler(void *pUserData,      // in: our PXMLDOM really
+                                    const XML_Char *pcszNotationName,
+                                    const XML_Char *pcszBase,
+                                    const XML_Char *pcszSystemId,
+                                    const XML_Char *pcszPublicId)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+    }
+}
+/*
+ *@@ ExternalEntityRefHandler:
+ *      @expat handler for references to @external_entities.
+ *
+ *      This handler is also called for processing an external DTD
+ *      subset if parameter entity parsing is in effect.
+ *      (See XML_SetParamEntityParsing.)
+ *
+ *      The pcszContext argument specifies the parsing context in the
+ *      format expected by the context argument to
+ *      XML_ExternalEntityParserCreate; pcszContext is valid only until
+ *      the handler returns, so if the referenced entity is to be
+ *      parsed later, it must be copied.
+ *
+ *      The pcszBase parameter is the base to use for relative system
+ *      identifiers. It is set by XML_SetBase and may be null.
+ *
+ *      The pcszPublicId parameter is the public id given in the entity
+ *      declaration and may be null.
+ *
+ *      The pcszSystemId is the system identifier specified in the
+ *      entity declaration and is never null.
+ *
+ *      There are a couple of ways in which this handler differs
+ *      from others. First, this handler returns an integer. A
+ *      non-zero value should be returned for successful handling
+ *      of the external entity reference. Returning a zero indicates
+ *      failure, and causes the calling parser to return an
+ *      ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING error.
+ *
+ *      Second, instead of having pUserData as its first argument,
+ *      it receives the parser that encountered the entity reference.
+ *      This, along with the context parameter, may be used as
+ *      arguments to a call to XML_ExternalEntityParserCreate.
+ *      Using the returned parser, the body of the external entity
+ *      can be recursively parsed.
+ *
+ *      Since this handler may be called recursively, it should not
+ *      be saving information into global or static variables.
+ *
+ *      Your handler isn't actually responsible for parsing the entity,
+ *      but it is responsible for creating a subsidiary parser with
+ *      XML_ExternalEntityParserCreate that will do the job. That returns
+ *      an instance of XML_Parser that has handlers and other data
+ *      structures initialized from the parent parser. You may then use
+ *      XML_Parse or XML_ParseBuffer calls against that parser. Since
+ *      external entities may refer to other external entities, your
+ *      handler should be prepared to be called recursively.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+int EXPATENTRY ExternalEntityRefHandler(XML_Parser parser,
+                                        const XML_Char *pcszContext,
+                                        const XML_Char *pcszBase,
+                                        const XML_Char *pcszSystemId,
+                                        const XML_Char *pcszPublicId)
+{
+    int i = 1;
+    /* PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+    } */
+    return (i);
+}
+/*
+ *@@ ElementDeclHandler:
+ *      @expat handler for element declarations in a DTD. The
+ *      handler gets called with the name of the element in
+ *      the declaration and a pointer to a structure that contains
+ *      the element model.
+ *
+ *      It is the application's responsibility to free this data
+ *      structure. ###
+ *
+ *      The XML spec defines that no element may be declared more
+ *      than once.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY ElementDeclHandler(void *pUserData,      // in: our PXMLDOM really
+                                   const XML_Char *pcszName,
+                                   XMLCONTENT *pModel)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        // pop the last DOMNODE off the stack and check if it's a DOCTYPE
+        PLISTNODE pListNode = lstPop(&pDom->llStack);
+        if (!pListNode)
+            pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+        else
+        {
+            PDOMNODE pDomNode = (PDOMNODE)pListNode->pItemData;
+            if (pDomNode->NodeBase.ulNodeType != DOMNODE_DOCUMENT_TYPE)
+                pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+            else
+            {
+                PSZ pszNodeValue = (PSZ)malloc(len + 1);
+                memcpy(pszNodeValue, s, len);
+                pszNodeValue[len] = '\0';
+                xstrInitSet(&pNew->strNodeValue, pszNodeValue);
+                // OK, we're in a DOCTYPE node:
+                PDOMDOCTYPENODE pDocType = (PDOMDOCTYPENODE)pDomNode;
+                // create an element declaration and push it unto the
+                // declarations tree
+                PCMELEMENTDECLNODE pNew = NULL;
+                pDom->arcDOM = xmlCreateElementDecl(pcszName,
+                                                    pModel,
+                                                    &pNew);
+                                        // this recurses!!
+                if (pDom->arcDOM == NO_ERROR)
+                {
+                    // add this to the doctype's declarations tree
+                    if (treeInsertNode(&pDocType->ElementDeclsTree,
+                                       (TREE*)pNew,
+                                       CompareCMNodeNodes,
+                                       FALSE)
+                            == TREE_DUPLICATE)
+                        // element already declared:
+                        // according to the XML specs, this is a validity
+                        // constraint, so we report a validation error
+                        xmlSetError(pDom,
+                                    ERROR_DOM_DUPLICATE_ELEMENT_DECL,
+                                    pNew->Particle.CMNode.strNodeName.psz,
+                                    TRUE);
+                }
+            }
-            pDom->pLastWasTextNode = pNew;
+        }
+    }
+}
+/*
+ *@@ AddEnum:
+ *
+ *@@added V0.9.9 (2001-02-16) [umoeller]
+ */
+VOID AddEnum(PCMATTRIBUTEDECL pNew,
+             const char *p,
+             const char *pNext)
+{
+    PSZ pszType = strhSubstr(p, pNext);
+    PNODEBASE pCMNode = (PNODEBASE)malloc(sizeof(*pCMNode));
+    memset(pCMNode, 0, sizeof(*pCMNode));
+    pCMNode->ulNodeType = ATTRIBUTE_DECLARATION_ENUM;
+    xstrInitSet(&pCMNode->strNodeName, pszType);
+    treeInsertNode(&pNew->ValuesTree,
+                   (TREE*)pCMNode,
+                   CompareCMNodeNodes,
+                   FALSE);
+}
+/*
+ *@@ AttlistDeclHandler:
+ *      @expat handler for attlist declarations in the DTD.
+ *
+ *      This handler is called for each attribute. So a single attlist
+ *      declaration with multiple attributes declared will generate
+ *      multiple calls to this handler.
+ *
+ *      --  pcszElementName is the name of the  element for which the
+ *          attribute is being declared.
+ *
+ *      --  pcszAttribName has the attribute name being declared.
+ *
+ *      --  pcszAttribType is the attribute type.
+ *          It is the string representing the type in the declaration
+ *          with whitespace removed.
+ *
+ *      --  pcszDefault holds the default value. It will be
+ *          NULL in the case of "#IMPLIED" or "#REQUIRED" attributes.
+ *          You can distinguish these two cases by checking the
+ *          fIsRequired parameter, which will be true in the case of
+ *          "#REQUIRED" attributes. Attributes which are "#FIXED"
+ *          will have also have a TRUE fIsRequired, but they will have
+ *          the non-NULL fixed value in the pcszDefault parameter.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY AttlistDeclHandler(void *pUserData,      // in: our PXMLDOM really
+                                   const XML_Char *pcszElementName,
+                                   const XML_Char *pcszAttribName,
+                                   const XML_Char *pcszAttribType,
+                                   const XML_Char *pcszDefault,
+                                   int fIsRequired)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+        // pop the last DOMNODE off the stack and check if it's a DOCTYPE
+        PLISTNODE pListNode = lstPop(&pDom->llStack);
+        if (!pListNode)
+            pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+        else
+        {
+            PDOMNODE pDomNode = (PDOMNODE)pListNode->pItemData;
+            if (pDomNode->NodeBase.ulNodeType != DOMNODE_DOCUMENT_TYPE)
+                pDom->arcDOM = ERROR_DOM_DOCTYPE_STRUCTURE;
+            else
+            {
+                // OK, we're in a DOCTYPE node:
+                PDOMDOCTYPENODE pDocType = (PDOMDOCTYPENODE)pDomNode;
+                PCMATTRIBUTEDEDECLBASE    pThis = NULL,
+                                        pCache = pDom->pAttListDeclCache;
+                // check if this is for the same attlist as the previous
+                // call (we cache the pointer for speed)
+                if (    (pCache)
+                     && (!strhcmp(pCache->CMNode.strNodeName.psz,
+                                  pcszElementName))
+                   )
+                    // this attdecl is for the same element:
+                    // use that (we won't have to search the tree)
+                    pThis = pDom->pAttListDeclCache;
+                if (!pThis)
+                {
+                    // cache didn't match: look up attributes tree then
+                    pThis = treeFindEQData(&pDocType->AttribDeclBasesTree,
+                                           (void*)pcszElementName,
+                                           CompareCMNodeData);
+                    if (!pThis)
+                    {
+                        // still not found:
+                        // we need a new node then
+                        pThis = (PCMATTRIBUTEDEDECLBASE)malloc(sizeof(*pThis));
+                        if (!pThis)
+                            pDom->arcDOM = ERROR_NOT_ENOUGH_MEMORY;
+                        else
+                        {
+                            pThis->CMNode.ulNodeType = ATTRIBUTE_DECLARATION_BASE;
+                            xstrInitCopy(&pThis->CMNode.strNodeName, pcszElementName, 0);
+                            // initialize the subtree
+                            treeInit(&pThis->AttribDeclsTree);
+                            treeInsertNode(&pDocType->AttribDeclBasesTree,
+                                           (TREE*)pThis,
+                                           CompareCMNodeNodes,
+                                           FALSE);
+                        }
+                    }
+                    pDom->pAttListDeclCache = pThis;
+                }
+                if (pThis)
+                {
+                    // pThis now has either an existing or a new CMATTRIBUTEDEDECLBASE;
+                    // add a new attribute def (CMATTRIBUTEDEDECL) to that
+                    PCMATTRIBUTEDECL  pNew = (PCMATTRIBUTEDECL)malloc(sizeof(*pNew));
+                    if (!pNew)
+                        pDom->arcDOM = ERROR_NOT_ENOUGH_MEMORY;
+                    else
+                    {
+                        memset(pNew, 0, sizeof(*pNew));
+                        pNew->CMNode.ulNodeType = ATTRIBUTE_DECLARATION;
+                        xstrInitCopy(&pNew->CMNode.strNodeName,
+                                     pcszAttribName,
+);
+                        // fill the other fields
+                        /* xstrInitCopy(&pNew->strType,
+                                     pcszAttribType,
+); */
+                        treeInit(&pNew->ValuesTree);
+                        // check the type... expat is too lazy to parse this for
+                        // us, so we must check manually. Expat only normalizes
+                        // the "type" string to kick out whitespace, so we get:
+                        // (TYPE1|TYPE2|TYPE3)
+                        if (*pcszAttribType == '(')
+                        {
+                            // enumeration:
+                            const char *p = pcszAttribType + 1,
+                                       *pNext;
+                            while (pNext = strchr(p, '|'))
+                            {
+                                AddEnum(pNew, p, pNext);
+                                p = pNext + 1;
+                            }
+                            pNext = strchr(p, ')');
+                            AddEnum(pNew, p, pNext);
+                            pNew->ulAttrType = CMAT_ENUM;
+                        }
+                        else if (!strcmp(pcszAttribType, "CDATA"))
+                            pNew->ulAttrType = CMAT_CDATA;
+                        else if (!strcmp(pcszAttribType, "ID"))
+                            pNew->ulAttrType = CMAT_ID;
+                        else if (!strcmp(pcszAttribType, "IDREF"))
+                            pNew->ulAttrType = CMAT_IDREF;
+                        else if (!strcmp(pcszAttribType, "IDREFS"))
+                            pNew->ulAttrType = CMAT_IDREFS;
+                        else if (!strcmp(pcszAttribType, "ENTITY"))
+                            pNew->ulAttrType = CMAT_ENTITY;
+                        else if (!strcmp(pcszAttribType, "ENTITIES"))
+                            pNew->ulAttrType = CMAT_ENTITIES;
+                        else if (!strcmp(pcszAttribType, "NMTOKEN"))
+                            pNew->ulAttrType = CMAT_NMTOKEN;
+                        else if (!strcmp(pcszAttribType, "NMTOKENS"))
+                            pNew->ulAttrType = CMAT_NMTOKENS;
+                        if (pcszDefault)
+                        {
+                            // fixed or default:
+                            if (fIsRequired)
+                                // fixed:
+                                pNew->ulConstraint = CMAT_FIXED_VALUE;
+                            else
+                                pNew->ulConstraint = CMAT_DEFAULT_VALUE;
+                            pNew->pstrDefaultValue = xstrCreate(0);
+                            xstrcpy(pNew->pstrDefaultValue, pcszDefault, 0);
+                        }
+                        else
+                            // implied or required:
+                            if (fIsRequired)
+                                pNew->ulConstraint = CMAT_REQUIRED;
+                            else
+                                pNew->ulConstraint = CMAT_IMPLIED;
+                        if (treeInsertNode(&pThis->AttribDeclsTree,
+                                           (TREE*)pNew,
+                                           CompareCMNodeNodes,
+                                           FALSE)
+                                == TREE_DUPLICATE)
+                            xmlSetError(pDom,
+                                        ERROR_DOM_DUPLICATE_ATTRIBUTE_DECL,
+                                        pcszAttribName,
+                                        TRUE);
+                    }
+                }
+            }
+        }
+    }
+}
+/*
+ *@@ EntityDeclHandler:
+ *      @expat handler that will be called for all entity declarations.
+ *
+ *      The fIsParameterEntity argument will be non-zero in the case
+ *      of parameter entities and zero otherwise.
+ *
+ *      For internal entities (<!ENTITY foo "bar">), pcszValue will be
+ *      non-NULL and pcszSystemId, pcszPublicId, and pcszNotationName
+ *      will all be NULL. The value string is not NULL terminated; the
+ *      length is provided in the iValueLength parameter. Do not use
+ *      iValueLength to test for internal entities, since it is legal
+ *      to have zero-length values. Instead check for whether or not
+ *      pcszValue is NULL.
+ *
+ *      The pcszNotationName argument will have a non-NULL value only
+ *      for unparsed entity declarations.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+void EXPATENTRY EntityDeclHandler(void *pUserData,      // in: our PXMLDOM really
+                                  const XML_Char *pcszEntityName,
+                                  int fIsParameterEntity,
+                                  const XML_Char *pcszValue,
+                                  int iValueLength,
+                                  const XML_Char *pcszBase,
+                                  const XML_Char *pcszSystemId,
+                                  const XML_Char *pcszPublicId,
+                                  const XML_Char *pcszNotationName)
+{
+    PXMLDOM     pDom = (PXMLDOM)pUserData;
+    // continue parsing only if we had no errors so far
+    if (!pDom->arcDOM)
+    {
+    }
+}
 /* ******************************************************************
+ *
 …
 /*
  *@@ xmlCreateDOM:
+ *      creates an XMLDOM instance, which can be used for parsing
+ *      an XML document and building a @DOM tree from it at the
+ *      same time.
+ *
+ *      Pass the XMLDOM returned here to xmlParse afterwards.
+ *
+ *      ulFlags is any combination of the following:
+ *
+ *      --  DF_PARSECOMMENTS: XML @comments are to be returned in
+ *          the DOM tree. Otherwise they are silently ignored.
+ *
+ *      --  DF_PARSEDTD: add the @DTD of the document into the DOM tree
+ *          as well and validate the document.
+ *
  *      Usage:
 …
  *         call xmlFreeDOM, which will free all memory.
+ *
  *@@added V0.9.9 (2000-02-14) [umoeller]
+ *@@added V0.9.9 (2001-02-14) [umoeller]
  */
 …
     APIRET  arc = NO_ERROR;
     PXMLDOM pDom = (PXMLDOM)malloc(sizeof(XMLDOM));
+    PXMLDOM pDom = (PXMLDOM)malloc(sizeof(*pDom));
     if (!pDom)
         arc = ERROR_NOT_ENOUGH_MEMORY;
     else
+    {
+        PDOMNODE pDocument = NULL;
         memset(pDom, 0, sizeof(XMLDOM));
 …
         // create the document node
+        pDom->pDocumentNode = xmlCreateNode(NULL, // no parent
+                                            DOMNODE_DOCUMENT);
+        if (!pDom->pDocumentNode)
+            arc = ERROR_NOT_ENOUGH_MEMORY;
+        else
+        arc = xmlCreateNode(NULL, // no parent
+                            DOMNODE_DOCUMENT,
+                            &pDocument);
+        if (arc == NO_ERROR)
+        {
+            // store the document in the DOM
+            pDom->pDocumentNode = (PDOMDOCUMENTNODE)pDocument;
             // push the document on the stack so the handlers
             // will append to that
 …
                                             CharacterDataHandler);
+                // XML_SetProcessingInstructionHandler(XML_Parser parser,
+                //                          XML_ProcessingInstructionHandler handler);
+                if (flParserFlags & DF_PARSECOMMENTS)
+                    XML_SetCommentHandler(pDom->pParser,
+                                          CommentHandler);
+                if (flParserFlags & DF_PARSEDTD)
+                {
+                    XML_SetDoctypeDeclHandler(pDom->pParser,
+                                              StartDoctypeDeclHandler,
+                                              EndDoctypeDeclHandler);
+                    XML_SetNotationDeclHandler(pDom->pParser,
+                                               NotationDeclHandler);
+                    XML_SetExternalEntityRefHandler(pDom->pParser,
+                                                    ExternalEntityRefHandler);
+                    XML_SetElementDeclHandler(pDom->pParser,
+                                              ElementDeclHandler);
+                    XML_SetAttlistDeclHandler(pDom->pParser,
+                                              AttlistDeclHandler);
+                    XML_SetEntityDeclHandler(pDom->pParser,
+                                             EntityDeclHandler);
+                    XML_SetParamEntityParsing(pDom->pParser,
+                                              XML_PARAM_ENTITY_PARSING_ALWAYS);
+                }
+                // XML_SetXmlDeclHandler ... do we care for this? I guess not
                 // pass the XMLDOM as user data to the handlers
                 XML_SetUserData(pDom->pParser,
                                 pDom);
+            }
+        }
 …
  *      parses another piece of XML data.
+ *
  *      If (fIsLast == TRUE), the internal expat parser
+ *      If (fIsLast == TRUE), the internal @expat parser
  *      will be freed, but not the DOM itself.
+ *
 …
+ *
  *      This returns NO_ERROR if the chunk was successfully
+ *      parsed. Otherwise ERROR_DOM_PARSING is returned,
+ *      and you will find error information in the XMLDOM
+ *      fields.
+ *
+ *@@added V0.9.9 (2000-02-14) [umoeller]
+ *      parsed. Otherwise one of the following errors is
+ *      returned:
+ *
+ *      -- ERROR_INVALID_PARAMETER
+ *
+ *      -- ERROR_DOM_PARSING: an @expat parsing error occured.
+ *         This might also be memory problems.
+ *         With this error code, you will find specific
+ *         error information in the XMLDOM fields.
+ *
+ *      -- ERROR_DOM_PARSING: the document is not @valid.
+ *         This can only happen if @DTD parsing was enabled
+ *         with xmlCreateDOM.
+ *         With this error code, you will find specific
+ *         error information in the XMLDOM fields.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
  */
 …
         if (!fSuccess)
+        {
             // error:
             pDom->Error = XML_GetErrorCode(pDom->pParser);
             pDom->pcszErrorDescription = XML_ErrorString(pDom->Error);
             pDom->ulErrorLine = XML_GetCurrentLineNumber(pDom->pParser);
             pDom->ulErrorColumn = XML_GetCurrentColumnNumber(pDom->pParser);
+            // expat parsing error:
+            xmlSetError(pDom,
+                        XML_GetErrorCode(pDom->pParser),
+                        NULL,
+                        FALSE);
             if (pDom->pDocumentNode)
+            {
                 xmlDeleteNode(pDom->pDocumentNode);
+                xmlDeleteNode((PDOMNODE)pDom->pDocumentNode);
                 pDom->pDocumentNode = NULL;
+            }
 …
             arc = ERROR_DOM_PARSING;
+        }
+        if (!fSuccess && fIsLast)
+        else if (pDom->fInvalid)
+        {
+            // expat was doing OK, but the handlers' validation failed:
+            arc = ERROR_DOM_VALIDITY;
+                        // error info has already been set
+        }
+        else
+            // expat was doing OK, but maybe we have integrity errors
+            // from our DOM callbacks:
+            if (pDom->arcDOM)
+                arc = pDom->arcDOM;
+        if (arc != NO_ERROR || fIsLast)
+        {
             // last call or error: clean up
 …
  *      calling this function.
+ *
  *@@added V0.9.9 (2000-02-14) [umoeller]
+ *@@added V0.9.9 (2001-02-14) [umoeller]
  */

trunk/src/helpers/xmldefs.c

-              r36
+              r38
 /*
+ *@@category: Helpers\XML
+ *      see xml.c.
+ *@@gloss: expat expat
+ *      Expat is one of the most well-known XML processors (parsers).
+ *      I (umoeller) have ported expat to the XWorkplace Helpers
+ *      library. See xmlparse.c for an introduction to expat. See
+ *      xml.c for an introduction to XML support in the XWorkplace
+ *      Helpers in general.
+ */
+/*
+ *@@gloss: XML XML
+ *      XML is the Extensible Markup Language, as defined by
+ *      the W3C. XML isn't really a language, but a meta-language
+ *      for describing markup languages. It is a simplified subset
+ *      of SGML.
+ *
+ *      You should be familiar with the following:
+ *
+ *      -- XML parsers operate on XML @documents.
+ *
+ *      -- Each XML document has both a physical and a logical
+ *         structure.
+ *
+ *         Physically, the document is composed of units called
+ *         @entities.
+ *
+ *         Logically, the document is composed of @markup and
+ *         @content. Among other things, markup separates the content
+ *         into @elements.
+ *
+ *      -- The logical and physical structures must nest properly (be
+ *         @well-formed) for each entity, which results in the entire
+ *         XML document being well-formed as well.
  */
 /*
  *@@gloss: entities entities
+ *      An "entity" is an XML storage unit. In the simplest case, an
+ *      XML document has only one entity, which is an XML file.
+ *      Except for the document entity (which is nameless), all
+ *      entities are identified by their names.
+ *
+ *      Entities are marked as either parsed or unparsed.
+ *
+ *      An "entity" is an XML storage unit. It's a very abstract
+ *      concept, and the term doesn't make much sense, but it was
+ *      in SGML already, and XML chose to inherit it.
+ *
+ *      In the simplest case, an XML document has only one entity,
+ *      which is an XML file (or memory buffer from wherever).
  *      The document entity serves as the root of the entity tree
  *      and a starting-point for an XML processor. Unlike other
 …
  *      appear on a processor input stream without any identification
  *      at all.
+ *
+ *      Entities are defined to be either parsed or unparsed.
+ *
  *      Other than that, there are @internal_entities,
 …
  *          They must be escaped unless used in a @CDATA section.
+ *
  *      --  To allow values in an @attribute to contain both single and double
+ *      --  To allow values in @attributes to contain both single and double
  *          quotes, the apostrophe or single-quote character (') may be
  *          represented as "&amp;apos;", and the double-quote character
  *          (") as "&amp;quot;".
+ *
  *      In addition, a @character_reference is a special case of an entity reference.
+ *      A numeric @character_reference is a special case of an entity reference.
+ *
  *      An internal entity is always parsed.
 …
+ *
  *      Markup is either @elements, @entity_references, @comments, @CDATA
+ *      section delimiters, @DTD's, and
+ *      @processing_instructions.
+ *      section delimiters, @DTD's, or @processing_instructions.
+ *
  *      XML "text" consists of markup and @content.
 …
  *      or may not be interested in white space. Whitespace
  *      handling can therefore be handled differently for each
  *      element with the use of the special "xml:space" @attribute.
+ *      element with the use of the special "xml:space" @attributes.
  */
 …
  +           <P /> <IMG align="left" src="http://www.w3.org/Icons/WWW/w3c_home" />
+ *
  *      An @attribute contains additional an parameter to an element.
+ *      In addition, @attributes contains extra parameters to elements.
  *      If the element has attributes, they must be in the start-tag
  *      (or empty-element tag).
 …
 /*
  *@@gloss: attribute attribute
+ *@@gloss: attributes attributes
  *      "Attributes" are name-value pairs that have been associated
  *      with @elements. Attributes can only appear in start-tags
 …
  *      document's @content; an XML processor may, but
  *      need not, make it possible for an application to retrieve
  *      the text of comments (expat has a handler for this).
+ *      the text of comments (@expat has a handler for this).
+ *
  *      Comments may contain any text except "--" (double-hyphen).
 …
  *@@gloss: valid valid
  *      XML @documents are said to be "valid" if they have a @DTD
+ *      associated and they confirm to it.
+ *      associated and they confirm to it. While XML documents
+ *      must always be @well-formed, validation and validity is up
+ *      to the implementation (i.e. at option to the application).
+ *
  *      Validating processors must report violations of the constraints
 …
  *      referenced in the document.
+ *
+ *      Non-validating processors are required to check only the
+ *      document entity (see @entitites), including the entire
+ *      internal DTD subset, for whether it is @well-formed. While
+ *      they are  not required to check the document for validity,
+ *      Non-validating processors (such as @expat) are required to
+ *      check only the document entity (see @entitites), including the
+ *      entire internal DTD subset, for whether it is @well-formed.
+ *
+ *      While they are  not required to check the document for validity,
  *      they are required to process all the declarations they
  *      read in the internal DTD subset and in any parameter entity
 …
  *      entity that they do not read; that is to say, they must
  *      use the information in those declarations to normalize
  *      @attribute values, include the replacement text of
+ *      values of @attributes, include the replacement text of
  *      @internal_entities, and supply default attribute values.
  *      They must not process entity declarations or attribute-list
 …
 /*
  *@@gloss: encodings encodings
+ *      In an encoding declaration, the values "UTF-8", "UTF-16",
+ *      "ISO-10646-UCS-2", and "ISO-10646-UCS-4" should be used
+ *      for the various encodings and transformations of Unicode /
+ *      ISO/IEC 10646, the values "ISO-8859-1", "ISO-8859-2", ...
+ *      "ISO-8859-9" should be used for the parts of ISO 8859, and
+ *      the values "ISO-2022-JP", "Shift_JIS", and "EUC-JP" should
+ *      be used for the various encoded forms of JIS X-0208-1997.
+ *      XML supports a wide variety of character encodings. These
+ *      must be specified in the XML @text_declaration.
+ *
+ *      There are too many character encodings on the planet to
+ *      be listed here. The most common ones are:
+ *
+ *      --  "UTF-8", "UTF-16", "ISO-10646-UCS-2", and "ISO-10646-UCS-4"
+ *          should be used for the various encodings and transformations
+ *          of Unicode / ISO/IEC 10646.
+ *
+ *      --  "ISO-8859-x" (with "x" being a number from 1 to 9) represent
+ *          the various ISO 8859 ("Latin") encodings.
+ *
+ *      --  "ISO-2022-JP", "Shift_JIS", and "EUC-JP" should be used for
+ *          the various encoded forms of JIS X-0208-1997.
+ *
+ *      Example of a @text_declaration:
+ *
+ +          <?xml version="1.0" encoding="ISO-8859-2"?>
+ *
  *      All XML processors must be able to read @entities in either
+ *      UTF-8 or UTF-16.
+ *      UTF-8 or UTF-16. See XML_SetUnknownEncodingHandler for additional
+ *      encodings directly supported by @expat.
+ *
  *      Entities encoded in UTF-16 must begin with the ZERO WIDTH NO-BREAK
 …
  *      XML processors must be able to use this character to differentiate
  *      between UTF-8 and UTF-16 encoded documents.
+ *
- *      See XML_ParserCreate for the encodings directly supported
- *      by expat.
  */
 …
  *      nature of their content. They look like this:
+ +
  +          <!ELEMENT name contentmodel>
+ +          <!ELEMENT name contentspec>
+ +
+ *      The "name" of the element is obvious. The "contentmodel"
+ *      No element may be declared more than once.
+ *
+ *      The "name" of the element is obvious. The "contentspec"
  *      is not. This specifies what may appear in the element
+ *      and can be a list of:
+ *
+ *      --  "#PCDATA", meaning "parsed character data" -- in
+ *          other words, @content.
+ *
+ *      --  Another element name with a specification about
+ *          whether the element may or must appear once or
+ *          more than once.
+ *
+ *      --  "EMPTY" marks the element as being empty (i.e. no
+ *          start- and end-tags, but a single tag only).
+ *
+ *      The element specifyer can be:
+ *
+ *      --  None: the subelement _must_ appear exactly once.
+ *
+ *      --  "+": the subelement _must_ appear at _least_ once.
+ *
+ *      --  "?": the subelement _may_ appear exactly once.
+ *
+ *      --  "*": the subelement _may_ appear once or more than
+ *          once or not at all. Note that this must always be
+ *          specified with "#PCDATA".
+ *
+ *      The list items can be separated with:
+ *      and can be one of the following:
+ *
+ *      --  "EMPTY" marks the element as being empty (i.e.
+ *          having no content at all).
+ *
+ *      --  "ANY" does not impose any restrictions.
+ *
+ *      --  (mixed): a "list" which declares the element to have
+ *          mixed content. See below.
+ *
+ *      --  (children): a "list" which declares the element to
+ *          have child elements only, but no content. See below.
+ *
+ *      <B>(mixed): content with elements</B>
+ *
+ *      With the (mixed) contentspec, an element may either contain
+ *      @content only or @content with subelements.
+ *
+ *      While the (children) contentspec allows you to define sequences
+ *      and orders, this is not possible with (mixed).
+ *
+ *      "contentspec" must then be a pair of parentheses, optionally
+ *      followed by "*". In the brackets, there must be at least the
+ *      keyword "#PCDATA", optionally followed by "|" and element
+ *      names. Note that if no #PCDATA appears, the (children) model
+ *      is assumed (see below).
+ *
+ *      Examples:
+ *
+ +          <!ELEMENT name (#PCDATA)* >
+ +          <!ELEMENT name (#PCDATA | subname1 | subname2)* >
+ +          <!ELEMENT name (#PCDATA) >
+ *
+ *      Note that if you specify sub-element names, you must terminate
+ *      the contentspec with "*". Again, there's no way to specify
+ *      orders etc. with (mixed).
+ *
+ *      <B>(children): Element content only</B>
+ *
+ *      With the (children) contentspec, an element may contain
+ *      only other elements (and @whitespace), but no other @content.
+ *
+ *      This can become fairly complicated. "contentspec" then must be
+ *      a "list" followed by a "repeater".
+ *
+ *      A "repeater" can be:
+ *
+ *      --  Nothing: the preceding item _must_ appear exactly once.
+ *
+ *      --  "+": the preceding item _must_ appear at _least_ once.
+ *
+ *      --  "?": the preceding item _may_ appear exactly once.
+ *
+ *      --  "*": the preceding item _may_ appear once or more than
+ *          once or not at all.
+ *
+ *      Here's the most simple example (precluding that "SUBELEMENT"
+ *      is a valid "list" here):
+ *
+ +          <!ELEMENT name (SUBELEMENT)* >
+ *
+ *      In other words, in (children) mode, "contentspec" must always
+ *      be in brackets and is followed by a "repeater" (which can be
+ *      nothing).
+ *
+ *      About "lists"... since these declarations may nest, this is
+ *      where the recursive definition of a "content particle" comes
+ *      in:
+ *
+ *      --  A "content particle" is either a sub-element name or
+ *          a nested list, followed by a "repeater".
+ *
+ *      --  A "list" is defined as an enumeration of content particles,
+ *          enclosed in parentheses, where the content particles are
+ *          separated by list separators.
+ *
+ *      There are two types of list separators:
+ *
  *      --  Commas (",") indicate that the elements must appear
  *          in the same order.
+ *          in the specified order ("sequence").
+ *
  *      --  Vertical bars ("|") specify that the elements may
+ *          occur alternatively.
+ *
+ *      Examples:
+ +
+ +          <!ELEMENT oldjoke  (burns+, allen, applause?)>
+ +          <!ELEMENT burns    (#PCDATA | quote)*>
+ +          <!ELEMENT allen    (#PCDATA | quote)*>
+ +          <!ELEMENT quote    (#PCDATA)*>
+ +          <!ELEMENT applause EMPTY>
+ *
+ *      This defines that the element "oldjoke" must contain
+ *      "burns" and "allen" and may contain "applause".
+ *      Only "burns" may appear more than once.
+ *          occur alternatively ("choice").
+ *
+ *      The list separators cannot be mixed; the list must be
+ *      either completely "sequence" or "choice".
+ *
+ *      Examples of content particles:
+ *
+ +              SUBELEMENT+
+ +              list*
+ *
+ *      Examples of lists:
+ *
+ +          ( cp | cp | cp | cp )
+ +          ( cp , cp , cp , cp )
+ *
+ *      Full examples for (children):
+ *
+ +          <!ELEMENT oldjoke  ( burns+, allen, applause? ) >
+ +                             | |       +cp-+          | |
+ +                             | |                      | |
+ +                             | +------- list ---------+ |
+ +                             +-------contentspec--------+
+ *
+ *      This specifies a "seqlist" for the "oldjoke" element. The
+ *      list is not nested, so the content particles are element
+ *      names only.
+ *
+ *      Within "oldjoke", "burns" must appear first and can appear
+ *      once or several times.
+ *
+ *      Next must be "allen", exactly once (since there's no repeater).
+ *
+ *      Optionally ("?"), there can be "applause" at the end.
+ *
+ *      Now, a nested example:
+ *
+ +          <!ELEMENT WARPIN (REXX*, VARPROMPT*, MSG?, TITLE?, (GROUP | PCK)+), PAGE+) >
+ *
  */
 …
  *      in whole or in part within @parameter_entities.
  */
+/*
+ *@@gloss: DOM DOM
+ *      DOM is the "Document Object Model", as defined by the W3C.
+ *
+ *      The DOM is a programming interface for @XML @documents.
+ *      (XML is a metalanguage and describes the documents
+ *      themselves. DOM is a programming interface -- an API --
+ *      to access XML documents.)
+ *
+ *      The W3C calls this "a platform- and language-neutral
+ *      interface that allows programs and scripts to dynamically
+ *      access and update the content, structure and style of
+ *      documents. The Document Object Model provides
+ *      a standard set of objects for representing HTML and XML
+ *      documents, a standard model of how these objects can
+ *      be combined, and a standard interface for accessing and
+ *      manipulating them. Vendors can support the DOM as an
+ *      interface to their proprietary data structures and APIs,
+ *      and content authors can write to the standard DOM
+ *      interfaces rather than product-specific APIs, thus
+ *      increasing interoperability on the Web."
+ *
+ *      In short, DOM specifies that an XML document is broken
+ *      up into a tree of "nodes", representing the various parts
+ *      of an XML document. Such nodes represent @documents,
+ *      @elements, @attributes, @processing_instructions,
+ *      @comments, @content, and more.
+ *
+ *      See xml.c for an introduction to XML and DOM support in
+ *      the XWorkplace helpers.
+ *
+ *      Example: Take this HTML table definition:
+ +
+ +          <TABLE>
+ +          <TBODY>
+ +          <TR>
+ +          <TD>Column 1-1</TD>
+ +          <TD>Column 1-2</TD>
+ +          </TR>
+ +          <TR>
+ +          <TD>Column 2-1</TD>
+ +          <TD>Column 2-2</TD>
+ +          </TR>
+ +          </TBODY>
+ +          </TABLE>
+ *
+ *      In the DOM, this would be represented by a tree as follows:
+ +
+ +                          ÚÄÄÄÄÄÄÄÄÄÄÄÄ¿
+ +                          ³   TABLE    ³        (only ELEMENT node in root DOCUMENT node)
+ +                          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                                ³
+ +                          ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿
+ +                          ³   TBODY    ³        (only ELEMENT node in root "TABLE" node)
+ +                          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                    ÚÄÄÄÄÄÄÄÄÄÄÄÁÄÄÄÄÄÄÄÄÄÄÄ¿
+ +              ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿          ÚÄÄÄÄÄÁÄÄÄÄÄÄ¿
+ +              ³   TR       ³          ³   TR       ³
+ +              ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ          ÀÄÄÄÄÄÂÄÄÄÄÄÄÙ
+ +                ÚÄÄÄÁÄÄÄÄÄÄ¿            ÚÄÄÄÁÄÄÄÄÄÄ¿
+ +            ÚÄÄÄÁÄ¿     ÚÄÄÁÄÄ¿     ÚÄÄÄÁÄ¿     ÚÄÄÁÄÄ¿
+ +            ³ TD  ³     ³ TD  ³     ³ TD  ³     ³ TD  ³
+ +            ÀÄÄÂÄÄÙ     ÀÄÄÂÄÄÙ     ÀÄÄÄÂÄÙ     ÀÄÄÂÄÄÙ
+ +         ÉÍÍÍÍÍÊÍÍÍÍ» ÉÍÍÍÍÊÍÍÍÍÍ» ÉÍÍÍÍÊÍÍÍÍÍ» ÉÍÍÊÍÍÍÍÍÍÍ»
+ +         ºColumn 1-1º ºColumn 1-2º ºColumn 2-1º ºColumn 2-2º    (one TEXT node in each parent node)
+ +         ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ ÈÍÍÍÍÍÍÍÍÍÍŒ
+ */
+/*
+ *@@gloss: DOM_DOCUMENT DOCUMENT
+ *      representation of XML @documents in the @DOM.
+ *
+ *      The xwphelpers implementation has the following differences
+ *      to the DOM specs:
+ *
+ *      -- The "doctype" member points to the documents @DTD, or is NULL.
+ *         In our implementation, this is the pvExtra pointer, which points
+ *         to a _DOMDTD.
+ *
+ *      -- The "implementation" member points to a DOMImplementation object.
+ *         This is not supported here.
+ *
+ *      -- The "documentElement" member is a convenience pointer to the
+ *         document's root element. We don't supply this field; instead,
+ *         the llChildren list only contains a single ELEMENT node for the
+ *         root element.
+ *
+ *      -- The "createElement" method is implemented by xmlCreateElementNode.
+ *
+ *      -- The "createAttribute" method is implemented by xmlCreateAttributeNode.
+ *
+ *      -- The "createTextNode" method is implemented by xmlCreateTextNode,
+ *         which has an extra parameter though.
+ *
+ *      -- The "createComment" method is implemented by xmlCreateCommentNode.
+ *
+ *      -- The "createProcessingInstruction" method is implemented by
+ *         xmlCreatePINode.
+ *
+ *      -- The "createDocumentFragment", "createCDATASection", and
+ *         "createEntityReference" methods are not supported.
+ */

trunk/src/helpers/xmlparse.c

-              r36
+              r38
  *      SourceForge Oct 22, 2000.
+ *
+ *      Expat is a library, written in C, for parsing XML documents. It's
+ *      This was ported to and integrated with the xwphelpers
+ *      for V0.9.9 (2001-02-10) [umoeller]. See xml.c for a general
+ *      introduction to @XML support in the xwphelpers.
+ *
+ *      Expat is a library, written in C, for parsing XML @documents. It's
  *      the underlying XML parser for the open source Mozilla project,
  *      perl's XML::Parser, and other open-source XML parsers.
 …
  *      that comes with expat as an HTML file. I (umoeller)
  *      have integrated the docs into the sources and added a
+ *      couple of remarks on the way.
+ *
+ *      See XML_ParserCreate for an introduction to expat.
+ *      couple of remarks while trying to implement parsers.
+ *
+ *      See XML_ParserCreate for instructions how to parse XML.
+ *
+ *      Note that expat is a non-validating XML processor. Validation
+ *      is supported by the top layer of xwphelpers XML support. See
+ *      xml.c.
+ *
  *@@added V0.9.9 (2001-02-10) [umoeller]
+ *@@header "expat\expat.h"
  */
 …
  *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+/*
+ *@@category: Helpers\C helpers\XML\expat
+ *      expat XML parser. See xmlparse.c.
  */
 …
     typedef char ICHAR;
 #endif
 #ifndef XML_NS
 …
 } OPEN_INTERNAL_ENTITY, *POPEN_INTERNAL_ENTITY;
 typedef enum XML_Error Processor(XML_Parser parser,
+typedef XMLERROR Processor(XML_Parser parser,
                                  const char *start,
                                  const char *end,
 …
 static Processor externalEntityContentProcessor;
 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
+static XMLERROR handleUnknownEncoding(XML_Parser parser,
                                             const XML_Char * encodingName);
 static enum XML_Error processXmlDecl(XML_Parser parser,
+static XMLERROR processXmlDecl(XML_Parser parser,
                                      int isGeneralTextEntity,
                                      const char *,
                                      const char *);
 static enum XML_Error initializeEncoding(XML_Parser parser);
 static enum XML_Error doProlog(XML_Parser parser,
+static XMLERROR initializeEncoding(XML_Parser parser);
+static XMLERROR doProlog(XML_Parser parser,
                                const ENCODING * enc,
                                const char *s,
 …
                                const char *next,
                                const char **nextPtr);
 static enum XML_Error processInternalParamEntity(XML_Parser parser,
+static XMLERROR processInternalParamEntity(XML_Parser parser,
                                                  ENTITY * entity);
 static enum XML_Error doContent(XML_Parser parser,
+static XMLERROR doContent(XML_Parser parser,
                                 int startTagLevel,
                                 const ENCODING * enc,
 …
                                 const char *end,
                                 const char **endPtr);
 static enum XML_Error doCdataSection(XML_Parser parser,
+static XMLERROR doCdataSection(XML_Parser parser,
                                      const ENCODING *,
                                      const char **startPtr,
 …
 #ifdef XML_DTD
 static enum XML_Error doIgnoreSection(XML_Parser parser,
+static XMLERROR doIgnoreSection(XML_Parser parser,
                                       const ENCODING *,
                                       const char **startPtr,
 …
 #endif /* XML_DTD */
 static enum XML_Error storeAtts(XML_Parser parser,
+static XMLERROR storeAtts(XML_Parser parser,
                                 const ENCODING *,
                                 const char *s,
 …
                            XML_Parser parser);
 static enum XML_Error storeAttributeValue(XML_Parser parser,
+static XMLERROR storeAttributeValue(XML_Parser parser,
                                           const ENCODING *,
                                           int isCdata,
 …
                                           const char *,
                                           STRING_POOL *);
 static enum XML_Error appendAttributeValue(XML_Parser parser,
+static XMLERROR appendAttributeValue(XML_Parser parser,
                                            const ENCODING *,
                                            int isCdata,
 …
                                      const char *end);
 static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
 static enum XML_Error storeEntityValue(XML_Parser parser,
+static XMLERROR storeEntityValue(XML_Parser parser,
                                        const ENCODING * enc,
                                        const char *start,
 …
 static int nextScaffoldPart(XML_Parser parser);
 static XML_Content *build_model(XML_Parser parser);
+static XMLCONTENT *build_model(XML_Parser parser);
 static const XML_Char *poolCopyString(STRING_POOL * pool, const XML_Char * s);
 …
     PROLOG_STATE m_prologState;
     Processor *m_processor;
     enum XML_Error m_errorCode;
+    XMLERROR m_errorCode;
     const char *m_eventPtr;
     const char *m_eventEndPtr;
 …
  *@@ XML_ParserCreate:
  *      constructs a new parser. If encoding is non-null, it specifies
  *      a character encoding to use for the document. This overrides
  *      the document encoding declaration.
+ *      a character encoding to use for the document (see below).
+ *      This overrides the document encoding declaration.
+ *
  *      Expat is a stream-oriented parser. You register callback (or
 …
  *      the document. As the parser recognizes parts of the document,
  *      it will call the appropriate handler for that part (if you've
  *      registered one.) The document is fed to the parser in pieces,
+ *      registered one). The document is fed to the parser in pieces,
  *      so you can start parsing before you have all the document.
  *      This also allows you to parse really huge documents that won't
 …
+ *
  *      The things you're likely to want to keep on a stack are the
  *      currently opened element and it's attributes. You push this
+ *      currently opened element and its attributes. You push this
  *      information onto the stack in the start handler and you pop
  *      it off in the end handler.
+ *
  *      For some tasks, it is sufficient to just keep information on
  *      what the depth of the stack is (or would be if you had one.)
+ *      what the depth of the stack is (or would be if you had one).
  *      The outline program shown above presents one example. Another
  *      such task would be skipping over a complete element. When you
 …
  *      While XML is based on Unicode, and every XML processor is
  *      required to recognized UTF-8 and UTF-16 (1 and 2 byte
  *      encodings of Unicode), other encodings may be declared in
+ *      encodings of Unicode), other @encodings may be declared in
  *      XML documents or entities. For the main document, an XML
  *      declaration may contain an encoding declaration in its
+ *      @text_declaration:
+ *
+ +          <?xml version="1.0" encoding="ISO-8859-2"?>
+ *      @text_declaration. See @encodings for additional
+ *      information.
+ *
  *      With expat, you may also specify an encoding at the time
  *      of creating a parser. This is useful when the encoding
  *      information may come from a source outside the document
+ *      itself (like a higher level protocol.)
+ *
+ *      There are four built-in encodings in expat:
+ *
+ *      --   UTF-8: 8-bit encoding of Unicode.
+ *
+ *      --   UTF-16: 16-bit encoding of Unicode.
+ *
+ *      --   ISO-8859-1: that's "latin 1".
+ *
+ *      --   US-ASCII
+ *
+ *      Anything else discovered in an encoding declaration or in
+ *      the protocol encoding specified in the parser constructor,
+ *      triggers a call to the UnknownEncodingHandler (see
+ *      XML_SetUnknownEncodingHandler). This handler gets passed
+ *      the encoding name and a pointer to an XML_Encoding data
+ *      structure. Your handler must fill in this structure and
+ *      return 1 if it knows how to deal with the encoding. Otherwise
+ *      the handler should return 0. The handler also gets passed a
+ *      pointer to an optional application data structure that you may
+ *      indicate when you set the handler.
+ *      itself (like a higher level protocol).
+ *
+ *      See XML_SetUnknownEncodingHandler for encodings directly
+ *      supported by expat and for how to handle other encodings.
+ *
  *      One pitfall that novice expat users are likely to fall into is
 …
  *      <B>Handling External Entity References</B>
+ *
+ *      Expat does not read or parse external entities directly. Note that
+ *      any external @DTD is a special case of an external entity. If you've
+ *      set no ExternalEntityRefHandler (see XML_SetExternalEntityRefHandler),
+ *      then external entity references are silently ignored. Otherwise, it
+ *      calls your handler with the information needed to read and parse the
+ *      external entity.
+ *
+ *      <B>Parsing DTDs</B>
+ *      Expat does not read or parse @external_entities directly. Note that
+ *      any external @DTD is a special case of an external entity. For how to
+ *      handle external entities, see XML_SetExternalEntityRefHandler.
+ *
+ *      <B>Parsing Parameter Entities</B>
+ *
  *      In order to parse @parameter_entities, before starting the parse,
 …
     declNotationPublicId = 0;
     memset(&position, 0, sizeof(POSITION));
     errorCode = XML_ERROR_NONE;
+    errorCode = ERROR_EXPAT_NONE;
     eventPtr = 0;
     eventEndPtr = 0;
 …
  *      This handler must have the following prototype:
+ *
  +          void EXPATENTRY StartElementHandler(void *userData,
  +                                            const XML_Char *name,
  +                                            const XML_Char **atts);
+ +          void EXPATENTRY StartElementHandler(void *pUserData,
+ +                                              const XML_Char *name,
+ +                                              const XML_Char **atts);
+ +
  *      "data" is the user data pointer set with XML_SetUserData.
 …
  *      Handler prototype:
+ +
  +          void EXPATENTRY (void *userData,
  +                         const XML_Char *name);
+ +          void EXPATENTRY EndElementHandler(void *pUserData,
+ +                                            const XML_Char *name);
  */
 …
 /*
  *@@ XML_SetCharacterDataHandler:
  *      sets a character data (text) handler.
+ *      sets a character data (text, @content) handler.
+ *
  *      Handler prototype:
+ *
  +          void EXPATENTRY CharacterDataHandler(void *userData,
  +                                             const XML_Char *s,
  +                                             int len);
+ +          void EXPATENTRY CharacterDataHandler(void *pUserData,
+ +                                               const XML_Char *s,
+ +                                               int len);
+ +
  *      The string your handler receives is NOT zero terminated.
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY ProcessingInstructionHandler(void *userData,
  +                                                     const XML_Char *target,
  +                                                     const XML_Char *data);
+ +          void EXPATENTRY ProcessingInstructionHandler(void *pUserData,
+ +                                                       const XML_Char *target,
+ +                                                       const XML_Char *data);
+ +
  *      The target is the first word in the processing instruction. The data
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY CommentHandler(void *userData,
  +                                       const XML_Char *data);
+ +          void EXPATENTRY CommentHandler(void *pUserData,
+ +                                         const XML_Char *data);
+ *
  */
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY StartCdataSectionHandler(void *userData);
+ +          void EXPATENTRY StartCdataSectionHandler(void *pUserData);
+ *
  */
 …
  *      Handler prototype:
+ *
  *          void EXPATENTRY EndCdataSectionHandler(void *userData);
+ *          void EXPATENTRY EndCdataSectionHandler(void *pUserData);
  */
 …
  *      Handler prototype:
+ +
  +          void EXPATENTRY DefaultHandler(void *userData,
  +                                       const XML_Char *s,
  +                                       int len);
+ +          void EXPATENTRY DefaultHandler(void *pUserData,
+ +                                         const XML_Char *s,
+ +                                         int len);
+ *
  *      The characters are passed exactly as they were in the XML
 …
  *      turning off expansion of references to internally defined
  *      general entities. Instead these references are passed to
  *      the default handler.
+ *      the default handler. To avoid that, use XML_SetDefaultHandlerExpand.
  */
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY StartDoctypeDeclHandler(void *userData,
  +                                                const XML_Char *doctypeName,
  +                                                const XML_Char *sysid,
  +                                                const XML_Char *pubid,
  +                                                int has_internal_subset);
+ *
  *      Both sysid and pubid may be NULL. The has_internal_subset
+ +          void EXPATENTRY StartDoctypeDeclHandler(void *pUserData,
+ +                                                  const XML_Char *pcszDoctypeName,
+ +                                                  const XML_Char *pcszSysid,
+ +                                                  const XML_Char *pcszPubid,
+ +                                                  int fHasInternalSubset);
+ *
+ *      Both pcszSysid and pcszPubid may be NULL. "fHasInternalSubset"
  *      will be non-zero if the DOCTYPE declaration has an internal subset.
  */
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY EndDoctypeDeclHandler(void *userData);
+ +          void EXPATENTRY EndDoctypeDeclHandler(void *pUserData);
+ *
  */
 …
  *      Handler prototype:
+ +
  +      void EXPATENTRY NotationDeclHandler(void *userData,
  +                                        const XML_Char *notationName,
  +                                        const XML_Char *base,
  +                                        const XML_Char *systemId,
  +                                        const XML_Char *publicId);
+ +      void EXPATENTRY NotationDeclHandler(void *pUserData,
+ +                                          const XML_Char *pcszNotationName,
+ +                                          const XML_Char *pcszBase,
+ +                                          const XML_Char *pcszSystemId,
+ +                                          const XML_Char *pcszPublicId);
+ +
  */
 …
  *      Handler prototype:
+ *
  +      void EXPATENTRY StartNamespaceDeclHandler(void *userData,
  +                                              const XML_Char *prefix,
  +                                              const XML_Char *uri);
+ +      void EXPATENTRY StartNamespaceDeclHandler(void *pUserData,
+ +                                                const XML_Char *prefix,
+ +                                                const XML_Char *uri);
+ +
  */
 …
  *      Handler prototype:
+ +
  +      void EXPATENTRY EndNamespaceDeclHandler)(void *userData,
  +                                             const XML_Char *prefix);
+ +      void EXPATENTRY EndNamespaceDeclHandler(void *pUserData,
+ +                                              const XML_Char *prefix);
  */
 …
  *      not have standalone set to "yes" in an XML declaration.
  *      If this handler returns 0, then the parser will throw an
  *      XML_ERROR_NOT_STANDALONE error.
+ *      ERROR_EXPAT_NOT_STANDALONE error.
+ *
  *      Handler prototype:
+ *
  +          int EXPATENTRY NotStandaloneHandler(void *userData);
+ +          int EXPATENTRY NotStandaloneHandler(void *pUserData);
  */
 …
 /*
  *@@ XML_SetExternalEntityRefHandler:
+ *      sets an external entity reference handler. This handler is
+ *      also called for processing an external DTD subset if
+ *      parameter entity parsing is in effect.
+ *      sets a handler for references to @external_entities.
+ *
+ *      This handler is also called for processing an external DTD
+ *      subset if parameter entity parsing is in effect.
  *      (See XML_SetParamEntityParsing.)
+ *
+ *      Warning: If you have set no ExternalEntityRefHandler, then
+ *      external entity references are silently ignored. Otherwise,
+ *      they trigger a call to your handler with the information
+ *      needed to read and parse the external entity.
+ *
  *      Handler prototype:
+ +
  +      int EXPATENTRY ExternalEntityRefHandler(XML_Parser parser,
  +                                            const XML_Char *context,
  +                                            const XML_Char *base,
  +                                            const XML_Char *systemId,
  +                                            const XML_Char *publicId);
+ +                                              const XML_Char *pcszContext,
+ +                                              const XML_Char *pcszBase,
+ +                                              const XML_Char *pcszSystemId,
+ +                                              const XML_Char *pcszPublicId);
+ +
  *      The context argument specifies the parsing context in the
+ *      The pcszContext argument specifies the parsing context in the
  *      format expected by the context argument to
  *      XML_ExternalEntityParserCreate; context is valid only until
+ *      XML_ExternalEntityParserCreate; pcszContext is valid only until
  *      the handler returns, so if the referenced entity is to be
  *      parsed later, it must be copied.
+ *
  *      The base parameter is the base to use for relative system
+ *      The pcszBase parameter is the base to use for relative system
  *      identifiers. It is set by XML_SetBase and may be null.
+ *
  *      The publicId parameter is the public id given in the entity
+ *      The pcszPublicId parameter is the public id given in the entity
  *      declaration and may be null.
+ *
  *      The systemId is the system identifier specified in the
+ *      The pcszSystemId is the system identifier specified in the
  *      entity declaration and is never null.
+ *
 …
  *      of the external entity reference. Returning a zero indicates
  *      failure, and causes the calling parser to return an
  *      XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
+ *
  *      Second, instead of having userData as its first argument,
+ *      ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING error.
+ *
+ *      Second, instead of having pUserData as its first argument,
  *      it receives the parser that encountered the entity reference.
  *      This, along with the context parameter, may be used as
 …
  *      Your handler isn't actually responsible for parsing the entity,
  *      but it is responsible for creating a subsidiary parser with
  *      XML_ExternalEntityParserCreate that will do the job. This returns
+ *      XML_ExternalEntityParserCreate that will do the job. That returns
  *      an instance of XML_Parser that has handlers and other data
  *      structures initialized from the parent parser. You may then use
  *      XML_Parse or XML_ParseBuffer calls against this parser. Since
+ *      XML_Parse or XML_ParseBuffer calls against that parser. Since
  *      external entities may refer to other external entities, your
  *      handler should be prepared to be called recursively.
 …
 /*
  *@@ XML_SetUnknownEncodingHandler:
+ *      sets a handler to deal with encodings other than the
+ *      built in set (see XML_ParserCreate).
+ *      sets a handler to deal with @encodings other than the
+ *      built-in set.
+ *
+ *      There are four built-in encodings in expat:
+ *
+ *      --   UTF-8: 8-bit encoding of Unicode.
+ *
+ *      --   UTF-16: 16-bit encoding of Unicode.
+ *
+ *      --   ISO-8859-1: that's "latin 1".
+ *
+ *      --   US-ASCII
+ *
+ *      Anything else discovered in an encoding declaration or in
+ *      the protocol encoding specified in the parser constructor
+ *      triggers a call to the UnknownEncodingHandler.
+ *
  *      Handler prototype:
+ *
  +          int EXPATENTRY UnknownEncodingHandler(void *encodingHandlerData,
  +                                              const XML_Char *name,
  +                                              XML_Encoding *info);
+ +                                                const XML_Char *name,
+ +                                                XML_Encoding *info);
+ +
  *      The encodingHandlerData argument is that which was passed as the
 …
  *      1.  Every ASCII character that can appear in a well-formed XML
  *          document must be represented by a single byte, and that byte
  *          must correspond to it's ASCII encoding (except for the
+ *          must correspond to its ASCII encoding (except for the
  *          characters $@\^'{}~).
+ *
 …
  *          the built-in support for UTF-16 and UTF-8.)
+ *
  *      4.  No character may be encoded by more that one distinct
+ *      4.  No character may be encoded by more than one distinct
  *          sequence of bytes.
  */
 …
 /*
  *@@ XML_SetElementDeclHandler:
  *      sets a handler for element declarations in a DTD. The
+ *      sets a handler for an @element_declaration in a @DTD. The
  *      handler gets called with the name of the element in
  *      the declaration and a pointer to a structure that contains
 …
  *      This handler must have the following prototype:
+ *
+ +          void EXPATENTRY ElementDeclHandler(void *userData,
+ +                                           const XML_Char *name,
+ +                                           XML_Content *model);
+ *
+ *      The model argument is the root of a tree of XML_Content
+ *      nodes. If type equals XML_CTYPE_EMPTY or XML_CTYPE_ANY,
+ *      then quant will be XML_CQUANT_NONE, and the other fields
+ *      will be zero or NULL.
+ *
+ *      If type is XML_CTYPE_MIXED, then quant will be
+ *      XML_CQUANT_NONE or XML_CQUANT_REP and numchildren will
+ *      contain the number of elements that are allowed to be
+ *      mixed in and children points to an array of XML_Content
+ *      structures that will all have type XML_CTYPE_NAME with no
+ *      quantification. Only the root node can be type
+ *      XML_CTYPE_EMPTY, XML_CTYPE_ANY, or XML_CTYPE_MIXED.
+ *
+ *      For type XML_CTYPE_NAME, the name field points to the
+ *      name and the numchildren and children fields will be
+ *      zero and NULL. The quant field will indicate any
+ *      quantifiers placed on the name.
+ *
+ *      Types XML_CTYPE_CHOICE and XML_CTYPE_SEQ indicate a
+ *      choice or sequence respectively. The numchildren field
+ *      indicates how many nodes in the choice or sequence and
+ *      children points to the nodes.
+ +          void EXPATENTRY ElementDeclHandler(void *pUserData,
+ +                                             const XML_Char *name,
+ +                                             XMLCONTENT *model);
+ *
+ *      See _XMLCONTENT for details.
  */
 …
 /*
  *@@ XML_SetAttlistDeclHandler:
  *      sets a handler for attlist declarations in the DTD.
+ *      sets a handler for an @attribute_declaration in the @DTD.
+ *
  *      This handler must have the following prototype:
+ *
  +          void EXPATENTRY AttlistDeclHandler(void *userData,
  +                                           const XML_Char  *elname,
  +                                           const XML_Char  *attname,
  +                                           const XML_Char  *att_type,
  +                                           const XML_Char  *dflt,
  +                                           int     isrequired);
+ +          void EXPATENTRY AttlistDeclHandler(void *pUserData,
+ +                                             const XML_Char *pcszElementName,
+ +                                             const XML_Char *pcszAttribName,
+ +                                             const XML_Char *pcszAttribType,
+ +                                             const XML_Char *pcszDefault,
+ +                                             int fIsRequired);
+ *
  *      This handler is called for each attribute. So a single attlist
  *      declaration with multiple attributes declared will generate
+ *      multiple calls to this handler. The elname parameter
+ *      returns the name of the element for which the attribute
+ *      is being declared. The attribute name is in the attname
+ *      parameter. The attribute type is in the att_type parameter.
+ *      It is the string representing the type in the declaration
+ *      with whitespace removed.
+ *
+ *      The dflt parameter holds the default value. It will be
+ *      NULL in the case of "#IMPLIED" or "#REQUIRED" attributes.
+ *      You can distinguish these two cases by checking the
+ *      isrequired parameter, which will be true in the case of
+ *      "#REQUIRED" attributes. Attributes which are "#FIXED"
+ *      will have also have a true isrequired, but they will have
+ *      the non-NULL fixed value in the dflt parameter.
+ *      multiple calls to this handler.
+ *
+ *      --  pcszElementName is the name of the  element for which the
+ *          attribute is being declared.
+ *
+ *      --  pcszAttribName has the attribute name being declared.
+ *
+ *      --  pcszAttribType is the attribute type.
+ *          It is the string representing the type in the declaration
+ *          with whitespace removed.
+ *
+ *      --  pcszDefault holds the default value. It will be
+ *          NULL in the case of "#IMPLIED" or "#REQUIRED" attributes.
+ *          You can distinguish these two cases by checking the
+ *          fIsRequired parameter, which will be true in the case of
+ *          "#REQUIRED" attributes. Attributes which are "#FIXED"
+ *          will have also have a TRUE fIsRequired, but they will have
+ *          the non-NULL fixed value in the pcszDefault parameter.
  */
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY EntityDeclHandler(void *userData,
  +                                          const XML_Char *entityName,
  +                                          int is_parameter_entity,
  +                                          const XML_Char *value,
  +                                          int value_length,
  +                                          const XML_Char *base,
  +                                          const XML_Char *systemId,
  +                                          const XML_Char *publicId,
  +                                          const XML_Char *notationName);
+ +          void EXPATENTRY EntityDeclHandler(void *pUserData,
+ +                                            const XML_Char *pcszEntityName,
+ +                                            int fIsParameterEntity,
+ +                                            const XML_Char *pcszValue,
+ +                                            int iValueLength,
+ +                                            const XML_Char *pcszBase,
+ +                                            const XML_Char *pcszSystemId,
+ +                                            const XML_Char *pcszPublicId,
+ +                                            const XML_Char *pcszNotationName);
+ +
  *      The is_parameter_entity argument will be non-zero in the case
+ *      The fIsParameterEntity argument will be non-zero in the case
  *      of parameter entities and zero otherwise.
+ *
  *      For internal entities (<!ENTITY foo "bar">), value will be
  *      non-NULL and systemId, publicId, and notationName will all
  *      be NULL. The value string is not NULL terminated; the length
  *      is provided in the value_length parameter. Do not use
  *      value_length to test for internal entities, since it is legal
+ *      For internal entities (<!ENTITY foo "bar">), pcszValue will be
+ *      non-NULL and pcszSystemId, pcszPublicId, and pcszNotationName
+ *      will all be NULL. The value string is not NULL terminated; the
+ *      lengthis provided in the iValueLength parameter. Do not use
+ *      iValueLength to test for internal entities, since it is legal
  *      to have zero-length values. Instead check for whether or not
  *      value is NULL.
+ *
  *      The notationName argument will have a non-NULL value only for
  *      unparsed entity declarations.
+ *      pcszValue is NULL.
+ *
+ *      The pcszNotationName argument will have a non-NULL value only
+ *      for unparsed entity declarations.
  */
 …
  *      Handler prototype:
+ *
  +          void EXPATENTRY XmlDeclHandler(void           *userData,
  +                                       const XML_Char *version,
  +                                       const XML_Char *encoding,
  +                                       int            standalone);
+ +          void EXPATENTRY XmlDeclHandler(void *pUserData,
+ +                                         const XML_Char *pcszVersion,
+ +                                         const XML_Char *pcszEncoding,
+ +                                         int standalone);
+ *
  *      The way to distinguish is that the version parameter will
 …
 /*
  *@@ XML_SetParamEntityParsing:
+ *      this enables parsing of parameter entities, including the
+ *      external parameter entity that is the external DTD subset,
+ *      according to code. The choices for code are:
+ *      this enables parsing of @parameter_entities, including the
+ *      external parameter entity that is the external @DTD subset,
+ *      according to code.
+ *
+ *      If parsing of parameter entities is enabled, then references
+ *      to external parameter entities (including the external DTD
+ *      subset) will be passed to the handler set with
+ *      XML_SetExternalEntityRefHandler. The context passed will be 0.
+ *
+ *      Unlike external general entities, external parameter entities
+ *      can only be parsed synchronously. If the external parameter
+ *      entity is to be parsed, it must be parsed during the call to
+ *      the external entity ref handler: the complete sequence of
+ *      XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
+ *      XML_ParserFree calls must be made during this call.
+ *
+ *      After XML_ExternalEntityParserCreate has been called to create
+ *      the parser for the external parameter entity (context must be 0
+ *      for this call), it is illegal to make any calls on the old parser
+ *      until XML_ParserFree has been called on the newly created parser.
+ *      If the library has been compiled without support for parameter
+ *      entity parsing (ie without XML_DTD being defined), then
+ *      XML_SetParamEntityParsing will return 0 if parsing of parameter
+ *      entities is requested; otherwise it will return non-zero.
+ *
+ *      NOTE: The xwphelpers implementation #defines XML_DTD in
+ *      include\expat\expat_setup.h, which is included in all expat
+ *      files.
+ *
+ *      The choices for code are:
+ *
  *      --  XML_PARAM_ENTITY_PARSING_NEVER:
+ *          Don't parse parameter entities or the external subset
+ *          Don't parse parameter entities or the external subset.
+ *          This is the only choice if XML_DTD is not defined.
+ *
  *      --  XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE:
  *          Parse parameter entites and the external subset unless
+ *          Parse parameter entities and the external subset unless
  *          standalone was set to "yes" in the XML declaration.
+ *
 …
             return 1;
         positionPtr = bufferPtr;
+        errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
+        if (errorCode == XML_ERROR_NONE)
+        errorCode = processor(parser,
+                              bufferPtr,
+                              parseEndPtr = bufferEnd,
+);
+        if (errorCode == ERROR_EXPAT_NONE)
             return 1;
         eventEndPtr = eventPtr;
 …
         if (isFinal)
+        {
+            errorCode = processor(parser, s, parseEndPtr = s + len, 0);
+            if (errorCode == XML_ERROR_NONE)
+            errorCode = processor(parser,
+                                  s,
+                                  parseEndPtr = s + len,
+);
+            if (errorCode == ERROR_EXPAT_NONE)
                 return 1;
             eventEndPtr = eventPtr;
 …
+        }
         errorCode = processor(parser, s, parseEndPtr = s + len, &end);
         if (errorCode != XML_ERROR_NONE)
+        if (errorCode != ERROR_EXPAT_NONE)
+        {
             eventEndPtr = eventPtr;
 …
                 if (!buffer)
+                {
                     errorCode = XML_ERROR_NO_MEMORY;
+                    errorCode = ERROR_EXPAT_NO_MEMORY;
                     eventPtr = eventEndPtr = 0;
                     processor = errorProcessor;
 …
     errorCode = processor(parser, start, parseEndPtr = bufferEnd,
                           isFinal ? (const char **)0 : &bufferPtr);
     if (errorCode == XML_ERROR_NONE)
+    if (errorCode == ERROR_EXPAT_NONE)
+    {
         if (!isFinal)
 …
             if (newBuf == 0)
+            {
                 errorCode = XML_ERROR_NO_MEMORY;
+                errorCode = ERROR_EXPAT_NO_MEMORY;
                 return 0;
+            }
 …
  */
 enum XML_Error XML_GetErrorCode(XML_Parser parser)
+XMLERROR XML_GetErrorCode(XML_Parser parser)
+{
     return errorCode;
 …
  *      returns the line number of the position.
+ *
  *      To be called on parser errors. See XML_GetErrorCode.
+ *      Can be called on parser errors. See XML_GetErrorCode.
  */
 …
  *      line, of the position.
+ *
  *      To be called on parser errors. See XML_GetErrorCode.
+ *      Can be called on parser errors. See XML_GetErrorCode.
  */
 …
 /*
- *@@ XML_ErrorString:
- *      returns a string describing the error corresponding to code.
- *      The code should be one of the enums that can be returned from
- *      XML_GetErrorCode.
- */
-const XML_LChar* XML_ErrorString(int code)
+{
-    static const XML_LChar *message[] =
+    {
-,
-        XML_T("out of memory"),
-        XML_T("syntax error"),
-        XML_T("no element found"),
-        XML_T("not well-formed (invalid token)"),
-        XML_T("unclosed token"),
-        XML_T("unclosed token"),
-        XML_T("mismatched tag"),
-        XML_T("duplicate attribute"),
-        XML_T("junk after document element"),
-        XML_T("illegal parameter entity reference"),
-        XML_T("undefined entity"),
-        XML_T("recursive entity reference"),
-        XML_T("asynchronous entity"),
-        XML_T("reference to invalid character number"),
-        XML_T("reference to binary entity"),
-        XML_T("reference to external entity in attribute"),
-        XML_T("xml processing instruction not at start of external entity"),
-        XML_T("unknown encoding"),
-        XML_T("encoding specified in XML declaration is incorrect"),
-        XML_T("unclosed CDATA section"),
-        XML_T("error in processing external entity reference"),
-        XML_T("document is not standalone"),
-        XML_T("unexpected parser state - please send a bug report")
-    };
-    if (code > 0 && code < sizeof(message) / sizeof(message[0]))
-        return message[code];
-    return 0;
+}
-/*
  *@@ XML_ExpatVersion:
  *      returns the library version string (e.g. "expat_1.95.1").
 …
+}
 static enum XML_Error contentProcessor(XML_Parser parser,
+static XMLERROR contentProcessor(XML_Parser parser,
                                        const char *start,
                                        const char *end,
 …
+}
 static enum XML_Error externalEntityInitProcessor(XML_Parser parser,
+static XMLERROR externalEntityInitProcessor(XML_Parser parser,
                                                   const char *start,
                                                   const char *end,
                                                   const char **endPtr)
+{
     enum XML_Error result = initializeEncoding(parser);
     if (result != XML_ERROR_NONE)
+    XMLERROR result = initializeEncoding(parser);
+    if (result != ERROR_EXPAT_NONE)
         return result;
     processor = externalEntityInitProcessor2;
 …
+}
 static enum XML_Error externalEntityInitProcessor2(XML_Parser parser,
+static XMLERROR externalEntityInitProcessor2(XML_Parser parser,
                                                    const char *start,
                                                    const char *end,
 …
+            {
                 *endPtr = start;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             eventPtr = start;
             return XML_ERROR_UNCLOSED_TOKEN;
+            return ERROR_EXPAT_UNCLOSED_TOKEN;
         case XML_TOK_PARTIAL_CHAR:
             if (endPtr)
+            {
                 *endPtr = start;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             eventPtr = start;
             return XML_ERROR_PARTIAL_CHAR;
+            return ERROR_EXPAT_PARTIAL_CHAR;
+    }
     processor = externalEntityInitProcessor3;
 …
+}
 static enum XML_Error externalEntityInitProcessor3(XML_Parser parser,
+static XMLERROR externalEntityInitProcessor3(XML_Parser parser,
                                                    const char *start,
                                                    const char *end,
 …
         case XML_TOK_XML_DECL:
+            {
                 enum XML_Error result = processXmlDecl(parser, 1, start, next);
                 if (result != XML_ERROR_NONE)
+                XMLERROR result = processXmlDecl(parser, 1, start, next);
+                if (result != ERROR_EXPAT_NONE)
                     return result;
                 start = next;
 …
+            {
                 *endPtr = start;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             eventPtr = start;
             return XML_ERROR_UNCLOSED_TOKEN;
+            return ERROR_EXPAT_UNCLOSED_TOKEN;
         case XML_TOK_PARTIAL_CHAR:
             if (endPtr)
+            {
                 *endPtr = start;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             eventPtr = start;
             return XML_ERROR_PARTIAL_CHAR;
+            return ERROR_EXPAT_PARTIAL_CHAR;
+    }
     processor = externalEntityContentProcessor;
 …
+}
 static enum XML_Error externalEntityContentProcessor(XML_Parser parser,
+static XMLERROR externalEntityContentProcessor(XML_Parser parser,
                                                      const char *start,
                                                      const char *end,
 …
+}
 static enum XML_Error
+static XMLERROR
  doContent(XML_Parser parser,
            int startTagLevel,
 …
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                    return ERROR_EXPAT_NONE;
+                }
                 *eventEndPP = end;
 …
                     reportDefault(parser, enc, s, end);
                 if (startTagLevel == 0)
                     return XML_ERROR_NO_ELEMENTS;
+                    return ERROR_EXPAT_NO_ELEMENTS;
                 if (tagLevel != startTagLevel)
                     return XML_ERROR_ASYNC_ENTITY;
                 return XML_ERROR_NONE;
+                    return ERROR_EXPAT_ASYNC_ENTITY;
+                return ERROR_EXPAT_NONE;
             case XML_TOK_NONE:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                    return ERROR_EXPAT_NONE;
+                }
                 if (startTagLevel > 0)
+                {
                     if (tagLevel != startTagLevel)
                         return XML_ERROR_ASYNC_ENTITY;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_NO_ELEMENTS;
+                        return ERROR_EXPAT_ASYNC_ENTITY;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_NO_ELEMENTS;
             case XML_TOK_INVALID:
                 *eventPP = next;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_PARTIAL:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_UNCLOSED_TOKEN;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_UNCLOSED_TOKEN;
             case XML_TOK_PARTIAL_CHAR:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_PARTIAL_CHAR;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_PARTIAL_CHAR;
             case XML_TOK_ENTITY_REF:
+                {
 …
                                            next - enc->minBytesPerChar);
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     entity = (ENTITY*)lookup(&dtd.generalEntities, name, 0);
                     poolDiscard(&dtd.pool);
 …
+                    {
                         if (dtd.complete || dtd.standalone)
                             return XML_ERROR_UNDEFINED_ENTITY;
+                            return ERROR_EXPAT_UNDEFINED_ENTITY;
                         if (defaultHandler)
                             reportDefault(parser, enc, s, next);
 …
+                    }
                     if (entity->open)
                         return XML_ERROR_RECURSIVE_ENTITY_REF;
+                        return ERROR_EXPAT_RECURSIVE_ENTITY_REF;
                     if (entity->notation)
                         return XML_ERROR_BINARY_ENTITY_REF;
+                        return ERROR_EXPAT_BINARY_ENTITY_REF;
                     if (entity)
+                    {
                         if (entity->textPtr)
+                        {
                             enum XML_Error result;
+                            XMLERROR result;
                             OPEN_INTERNAL_ENTITY openEntity;
 …
                             entity->open = 0;
                             if (!context)
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
                             if (!externalEntityRefHandler(externalEntityRefHandlerArg,
                                                           context,
 …
                                                           entity->systemId,
                                                           entity->publicId))
                                 return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+                                return ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING;
                             poolDiscard(&tempPool);
+                        }
 …
                 if (!startElementHandler)
+                {
                     enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
+                    XMLERROR result = storeAtts(parser, enc, s, 0, 0);
                     if (result)
 …
                         tag = (TAG*)MALLOC(sizeof(TAG));
                         if (!tag)
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         tag->buf = (char*)MALLOC(INIT_TAG_BUF_SIZE);
                         if (!tag->buf)
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         tag->bufEnd = tag->buf + INIT_TAG_BUF_SIZE;
+                    }
 …
                             tag->buf = (char*)REALLOC(tag->buf, bufSize);
                             if (!tag->buf)
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
                             tag->bufEnd = tag->buf + bufSize;
+                        }
 …
                     if (startElementHandler)
+                    {
                         enum XML_Error result;
+                        XMLERROR result;
                         XML_Char *toPtr;
 …
                             tag->buf = (char*)REALLOC(tag->buf, bufSize);
                             if (!tag->buf)
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
                             tag->bufEnd = tag->buf + bufSize;
                             if (nextPtr)
 …
                 if (!startElementHandler)
+                {
                     enum XML_Error result = storeAtts(parser, enc, s, 0, 0);
+                    XMLERROR result = storeAtts(parser, enc, s, 0, 0);
                     if (result)
 …
+                {
                     const char *rawName = s + enc->minBytesPerChar;
                     enum XML_Error result;
+                    XMLERROR result;
                     BINDING *bindings = 0;
                     TAG_NAME name;
 …
                                        rawName + XmlNameLength(enc, rawName));
                     if (!name.str)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&tempPool);
                     result = storeAtts(parser, enc, s, &name, &bindings);
 …
             case XML_TOK_END_TAG:
                 if (tagLevel == startTagLevel)
                     return XML_ERROR_ASYNC_ENTITY;
+                    return ERROR_EXPAT_ASYNC_ENTITY;
                 else
+                {
 …
+                    {
                         *eventPP = rawName;
                         return XML_ERROR_TAG_MISMATCH;
+                        return ERROR_EXPAT_TAG_MISMATCH;
+                    }
                     --tagLevel;
 …
                     if (n < 0)
                         return XML_ERROR_BAD_CHAR_REF;
+                        return ERROR_EXPAT_BAD_CHAR_REF;
                     if (characterDataHandler)
+                    {
 …
                 break;
             case XML_TOK_XML_DECL:
                 return XML_ERROR_MISPLACED_XML_PI;
+                return ERROR_EXPAT_MISPLACED_XML_PI;
             case XML_TOK_DATA_NEWLINE:
                 if (characterDataHandler)
 …
             case XML_TOK_CDATA_SECT_OPEN:
+                {
                     enum XML_Error result;
+                    XMLERROR result;
                     if (startCdataSectionHandler)
 …
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                    return ERROR_EXPAT_NONE;
+                }
                 if (characterDataHandler)
 …
+                {
                     *eventPP = end;
                     return XML_ERROR_NO_ELEMENTS;
+                    return ERROR_EXPAT_NO_ELEMENTS;
+                }
                 if (tagLevel != startTagLevel)
+                {
                     *eventPP = end;
                     return XML_ERROR_ASYNC_ENTITY;
+                }
                 return XML_ERROR_NONE;
+                    return ERROR_EXPAT_ASYNC_ENTITY;
+                }
+                return ERROR_EXPAT_NONE;
             case XML_TOK_DATA_CHARS:
                 if (characterDataHandler)
 …
             case XML_TOK_PI:
                 if (!reportProcessingInstruction(parser, enc, s, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_COMMENT:
                 if (!reportComment(parser, enc, s, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             default:
 …
  * otherwise just check the attributes for well-formedness. */
 static enum XML_Error storeAtts(XML_Parser parser,
+static XMLERROR storeAtts(XML_Parser parser,
                                 const ENCODING * enc,
                                 const char *attStr,
 …
             tagNamePtr->str = poolCopyString(&dtd.pool, tagNamePtr->str);
             if (!tagNamePtr->str)
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
             elementType = (ELEMENT_TYPE*)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
             if (!elementType)
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
             if (ns && !setElementTypePrefix(parser, elementType))
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
+        }
         nDefaultAtts = elementType->nDefaultAtts;
 …
         atts = (PATTRIBUTE)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
         if (!atts)
             return XML_ERROR_NO_MEMORY;
+            return ERROR_EXPAT_NO_MEMORY;
         if (n > oldAttsSize)
             XmlGetAttributes(enc, attStr, n, atts);
 …
         if (!attId)
             return XML_ERROR_NO_MEMORY;
+            return ERROR_EXPAT_NO_MEMORY;
         /* detect duplicate attributes */
         if ((attId->name)[-1])
 …
             if (enc == encoding)
                 eventPtr = atts[i].name;
             return XML_ERROR_DUPLICATE_ATTRIBUTE;
+            return ERROR_EXPAT_DUPLICATE_ATTRIBUTE;
+        }
         (attId->name)[-1] = 1;
 …
         if (!atts[i].normalized)
+        {
             enum XML_Error result;
+            XMLERROR result;
             int isCdata = 1;
 …
             appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
             if (appAtts[attIndex] == 0)
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
             poolFinish(&tempPool);
+        }
 …
                 /* deal with namespace declarations here */
                 if (!addBinding(parser, attId->prefix, attId, appAtts[attIndex], bindingsPtr))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 --attIndex;
+            }
 …
+                    {
                         if (!addBinding(parser, da->id->prefix, da->id, da->value, bindingsPtr))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
+                    }
                     else
 …
+                    {
                         if (!poolAppendChar(&tempPool, b->uri[j]))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
+                    }
                     while (*s++ != ':')
 …
+                    {
                         if (!poolAppendChar(&tempPool, *s))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
+                    }
                     while (*s++);
 …
+                        {
                             if (!poolAppendChar(&tempPool, *s))
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
+                        }
                         while (*s++);
 …
         ((XML_Char*)(appAtts[i]))[-1] = 0;
     if (!tagNamePtr)
         return XML_ERROR_NONE;
+        return ERROR_EXPAT_NONE;
     for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)
         binding->attId->name[-1] = 0;
 …
         binding = elementType->prefix->binding;
         if (!binding)
             return XML_ERROR_NONE;
+            return ERROR_EXPAT_NONE;
         localPart = tagNamePtr->str;
         while (*localPart++ != XML_T(':'))
 …
+    }
     else
         return XML_ERROR_NONE;
+        return ERROR_EXPAT_NONE;
     tagNamePtr->localPart = localPart;
     tagNamePtr->uriLen = binding->uriLen;
 …
         if (!uri)
             return XML_ERROR_NO_MEMORY;
+            return ERROR_EXPAT_NO_MEMORY;
         binding->uriAlloc = n + EXPAND_SPARE;
         memcpy(uri, binding->uri, binding->uriLen * sizeof(XML_Char));
 …
     memcpy(binding->uri + binding->uriLen, localPart, i * sizeof(XML_Char));
     tagNamePtr->str = binding->uri;
     return XML_ERROR_NONE;
+    return ERROR_EXPAT_NONE;
+}
 …
  * the whole file is parsed with one call. */
 static enum XML_Error cdataSectionProcessor(XML_Parser parser,
+static XMLERROR cdataSectionProcessor(XML_Parser parser,
                                      const char *start,
                                      const char *end,
                                      const char **endPtr)
+{
     enum XML_Error result = doCdataSection(parser, encoding, &start, end, endPtr);
+    XMLERROR result = doCdataSection(parser, encoding, &start, end, endPtr);
     if (start)
 …
  * the section is not yet closed. */
 static enum XML_Error doCdataSection(XML_Parser parser,
+static XMLERROR doCdataSection(XML_Parser parser,
                               const ENCODING * enc,
                               const char **startPtr,
 …
                     reportDefault(parser, enc, s, next);
                 *startPtr = next;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
             case XML_TOK_DATA_NEWLINE:
                 if (characterDataHandler)
 …
             case XML_TOK_INVALID:
                 *eventPP = next;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_PARTIAL_CHAR:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_PARTIAL_CHAR;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_PARTIAL_CHAR;
             case XML_TOK_PARTIAL:
             case XML_TOK_NONE:
 …
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_UNCLOSED_CDATA_SECTION;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_UNCLOSED_CDATA_SECTION;
             default:
                 *eventPP = next;
                 return XML_ERROR_UNEXPECTED_STATE;
+                return ERROR_EXPAT_UNEXPECTED_STATE;
+        }
         *eventPP = s = next;
 …
  * the whole file is parsed with one call. */
 static enum XML_Error ignoreSectionProcessor(XML_Parser parser,
+static XMLERROR ignoreSectionProcessor(XML_Parser parser,
                                       const char *start,
                                       const char *end,
                                       const char **endPtr)
+{
     enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, endPtr);
+    XMLERROR result = doIgnoreSection(parser, encoding, &start, end, endPtr);
     if (start)
 …
  * the section is not yet closed. */
 static enum XML_Error doIgnoreSection(XML_Parser parser,
+static XMLERROR doIgnoreSection(XML_Parser parser,
                                const ENCODING * enc,
                                const char **startPtr,
 …
                 reportDefault(parser, enc, s, next);
             *startPtr = next;
             return XML_ERROR_NONE;
+            return ERROR_EXPAT_NONE;
         case XML_TOK_INVALID:
             *eventPP = next;
             return XML_ERROR_INVALID_TOKEN;
+            return ERROR_EXPAT_INVALID_TOKEN;
         case XML_TOK_PARTIAL_CHAR:
             if (nextPtr)
+            {
                 *nextPtr = s;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             return XML_ERROR_PARTIAL_CHAR;
+            return ERROR_EXPAT_PARTIAL_CHAR;
         case XML_TOK_PARTIAL:
         case XML_TOK_NONE:
 …
+            {
                 *nextPtr = s;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             return XML_ERROR_SYNTAX;    /* XML_ERROR_UNCLOSED_IGNORE_SECTION */
+            return ERROR_EXPAT_SYNTAX;    /* ERROR_EXPAT_UNCLOSED_IGNORE_SECTION */
         default:
             *eventPP = next;
             return XML_ERROR_UNEXPECTED_STATE;
+            return ERROR_EXPAT_UNEXPECTED_STATE;
+    }
     /* not reached */
 …
 #endif /* XML_DTD */
 static enum XML_Error  initializeEncoding(XML_Parser parser)
+static XMLERROR  initializeEncoding(XML_Parser parser)
+{
     const char *s;
 …
 #endif
     if ((ns ? XmlInitEncodingNS : XmlInitEncoding) (&initEncoding, &encoding, s))
         return XML_ERROR_NONE;
+        return ERROR_EXPAT_NONE;
     return handleUnknownEncoding(parser, protocolEncodingName);
+}
 static enum XML_Error  processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
+static XMLERROR  processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
                 const char *s, const char *next)
+{
 …
                               &newEncoding,
                               &standalone))
         return XML_ERROR_SYNTAX;
+        return ERROR_EXPAT_SYNTAX;
     if (!isGeneralTextEntity && standalone == 1)
+    {
 …
                                      + XmlNameLength(encoding, encodingName));
             if (!storedEncName)
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
             poolFinish(&temp2Pool);
+        }
 …
                                       versionend - encoding->minBytesPerChar);
             if (!storedversion)
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
+        }
         xmlDeclHandler(handlerArg, storedversion, storedEncName, standalone);
 …
+            {
                 eventPtr = encodingName;
                 return XML_ERROR_INCORRECT_ENCODING;
+                return ERROR_EXPAT_INCORRECT_ENCODING;
+            }
             encoding = newEncoding;
 …
         else if (encodingName)
+        {
             enum XML_Error result;
+            XMLERROR result;
             if (!storedEncName)
 …
                                      + XmlNameLength(encoding, encodingName));
                 if (!storedEncName)
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
+            }
             result = handleUnknownEncoding(parser, storedEncName);
             poolClear(&tempPool);
             if (result == XML_ERROR_UNKNOWN_ENCODING)
+            if (result == ERROR_EXPAT_UNKNOWN_ENCODING)
                 eventPtr = encodingName;
             return result;
 …
         poolClear(&temp2Pool);
     return XML_ERROR_NONE;
+}
 static enum XML_Error handleUnknownEncoding(XML_Parser parser,
+    return ERROR_EXPAT_NONE;
+}
+static XMLERROR handleUnknownEncoding(XML_Parser parser,
                                             const XML_Char* encodingName)
+{
 …
                 if (info.release)
                     info.release(info.data);
                 return XML_ERROR_NO_MEMORY;
+                return ERROR_EXPAT_NO_MEMORY;
+            }
             enc = (ns
 …
                 unknownEncodingRelease = info.release;
                 encoding = enc;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
+        }
 …
             info.release(info.data);
+    }
     return XML_ERROR_UNKNOWN_ENCODING;
+}
 static enum XML_Error prologInitProcessor(XML_Parser parser,
+    return ERROR_EXPAT_UNKNOWN_ENCODING;
+}
+static XMLERROR prologInitProcessor(XML_Parser parser,
                      const char *s,
                      const char *end,
                      const char **nextPtr)
+{
     enum XML_Error result = initializeEncoding(parser);
     if (result != XML_ERROR_NONE)
+    XMLERROR result = initializeEncoding(parser);
+    if (result != ERROR_EXPAT_NONE)
         return result;
     processor = prologProcessor;
 …
+}
 static enum XML_Error prologProcessor(XML_Parser parser,
+static XMLERROR prologProcessor(XML_Parser parser,
                  const char *s,
                  const char *end,
 …
+}
 static enum XML_Error doProlog(XML_Parser parser,
+static XMLERROR doProlog(XML_Parser parser,
           const ENCODING * enc,
           const char *s,
 …
+            {
                 *nextPtr = s;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
+            }
             switch (tok)
 …
                 case XML_TOK_INVALID:
                     *eventPP = next;
                     return XML_ERROR_INVALID_TOKEN;
+                    return ERROR_EXPAT_INVALID_TOKEN;
                 case XML_TOK_PARTIAL:
                     return XML_ERROR_UNCLOSED_TOKEN;
+                    return ERROR_EXPAT_UNCLOSED_TOKEN;
                 case XML_TOK_PARTIAL_CHAR:
                     return XML_ERROR_PARTIAL_CHAR;
+                    return ERROR_EXPAT_PARTIAL_CHAR;
                 case XML_TOK_NONE:
 #ifdef XML_DTD
                     if (enc != encoding)
                         return XML_ERROR_NONE;
+                        return ERROR_EXPAT_NONE;
                     if (parentParser)
+                    {
                         if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)
                             == XML_ROLE_ERROR)
                             return XML_ERROR_SYNTAX;
+                            return ERROR_EXPAT_SYNTAX;
                         hadExternalDoctype = 0;
                         return XML_ERROR_NONE;
+                        return ERROR_EXPAT_NONE;
+                    }
 #endif /* XML_DTD */
                     return XML_ERROR_NO_ELEMENTS;
+                    return ERROR_EXPAT_NO_ELEMENTS;
                 default:
                     tok = -tok;
 …
             case XML_ROLE_XML_DECL:
+                {
                     enum XML_Error result = processXmlDecl(parser, 0, s, next);
                     if (result != XML_ERROR_NONE)
+                    XMLERROR result = processXmlDecl(parser, 0, s, next);
+                    if (result != ERROR_EXPAT_NONE)
                         return result;
                     enc = encoding;
 …
                     doctypeName = poolStoreString(&tempPool, enc, s, next);
                     if (!doctypeName)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&tempPool);
                     doctypeSysid = 0;
 …
             case XML_ROLE_TEXT_DECL:
+                {
                     enum XML_Error result = processXmlDecl(parser, 1, s, next);
                     if (result != XML_ERROR_NONE)
+                    XMLERROR result = processXmlDecl(parser, 1, s, next);
+                    if (result != ERROR_EXPAT_NONE)
                         return result;
                     enc = encoding;
 …
                     doctypePubid = poolStoreString(&tempPool, enc, s + 1, next - 1);
                     if (!doctypePubid)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&tempPool);
+                }
 …
                                                sizeof(ENTITY));
                 if (!declEntity)
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
 #endif /* XML_DTD */
                 /* fall through */
             case XML_ROLE_ENTITY_PUBLIC_ID:
                 if (!XmlIsPublicId(enc, s, next, eventPP))
                     return XML_ERROR_SYNTAX;
+                    return ERROR_EXPAT_SYNTAX;
                 if (declEntity)
+                {
 …
                     if (!tem)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     normalizePublicId(tem);
                     declEntity->publicId = tem;
 …
                                                       entity->systemId,
                                                       entity->publicId))
                             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+                            return ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING;
+                    }
 #endif /* XML_DTD */
 …
                         && notStandaloneHandler
                         && !notStandaloneHandler(handlerArg))
                         return XML_ERROR_NOT_STANDALONE;
+                        return ERROR_EXPAT_NOT_STANDALONE;
+                }
                 if (endDoctypeDeclHandler)
 …
                 declElementType = getElementType(parser, enc, s, next);
                 if (!declElementType)
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_ROLE_ATTRIBUTE_NAME:
                 declAttributeId = getAttributeId(parser, enc, s, next);
                 if (!declAttributeId)
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 declAttributeIsCdata = 0;
                 declAttributeType = 0;
 …
+                    }
                     if (!poolAppendString(&tempPool, prefix))
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     if (!poolAppend(&tempPool, enc, s, next))
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     declAttributeType = tempPool.start;
+                }
 …
                                    declAttributeIsCdata, declAttributeIsId, 0,
                                         parser))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 if (attlistDeclHandler && declAttributeType)
+                {
 …
                         if (!poolAppendChar(&tempPool, ')')
                             || !poolAppendChar(&tempPool, '\0'))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         declAttributeType = tempPool.start;
                         poolFinish(&tempPool);
 …
+                {
                     const XML_Char *attVal;
                     enum XML_Error result
+                    XMLERROR result
                     = storeAttributeValue(parser, enc, declAttributeIsCdata,
                                           s + enc->minBytesPerChar,
 …
                     /* ID attributes aren't allowed to have a default */
                         && !defineAttribute(declElementType, declAttributeId, declAttributeIsCdata, 0, attVal, parser))
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     if (attlistDeclHandler && declAttributeType)
+                    {
 …
                             if (!poolAppendChar(&tempPool, ')')
                                 || !poolAppendChar(&tempPool, '\0'))
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
                             declAttributeType = tempPool.start;
                             poolFinish(&tempPool);
 …
             case XML_ROLE_ENTITY_VALUE:
+                {
                     enum XML_Error result = storeEntityValue(parser, enc,
+                    XMLERROR result = storeEntityValue(parser, enc,
                                                      s + enc->minBytesPerChar,
                                                  next - enc->minBytesPerChar);
 …
                     else
                         poolDiscard(&dtd.pool);
                     if (result != XML_ERROR_NONE)
+                    if (result != ERROR_EXPAT_NONE)
                         return result;
+                }
 …
                     doctypeSysid = poolStoreString(&tempPool, enc, s + 1, next - 1);
                     if (!doctypeSysid)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&tempPool);
+                }
 …
                     && notStandaloneHandler
                     && !notStandaloneHandler(handlerArg))
                     return XML_ERROR_NOT_STANDALONE;
+                    return ERROR_EXPAT_NOT_STANDALONE;
                 hadExternalDoctype = 1;
 #ifndef XML_DTD
 …
                     declEntity->publicId = 0;
                     if (!declEntity)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
+                }
                 /* fall through */
 …
                                                  next - enc->minBytesPerChar);
                     if (!declEntity->systemId)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     declEntity->base = curBase;
                     poolFinish(&dtd.pool);
 …
                     declEntity->notation = poolStoreString(&dtd.pool, enc, s, next);
                     if (!declEntity->notation)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&dtd.pool);
                     if (unparsedEntityDeclHandler)
 …
                     name = poolStoreString(&dtd.pool, enc, s, next);
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     if (dtd.complete)
+                    {
                         declEntity = (ENTITY*)lookup(&dtd.generalEntities, name, sizeof(ENTITY));
                         if (!declEntity)
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         if (declEntity->name != name)
+                        {
 …
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     declEntity = (ENTITY*)lookup(&dtd.paramEntities,
                                                    name, sizeof(ENTITY));
                     if (!declEntity)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     if (declEntity->name != name)
+                    {
 …
                     declNotationName = poolStoreString(&tempPool, enc, s, next);
                     if (!declNotationName)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     poolFinish(&tempPool);
+                }
 …
             case XML_ROLE_NOTATION_PUBLIC_ID:
                 if (!XmlIsPublicId(enc, s, next, eventPP))
                     return XML_ERROR_SYNTAX;
+                    return ERROR_EXPAT_SYNTAX;
                 if (declNotationName)
+                {
 …
                     if (!tem)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     normalizePublicId(tem);
                     declNotationPublicId = tem;
 …
                     if (!systemId)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     *eventEndPP = s;
                     notationDeclHandler(handlerArg,
 …
+                {
                     case XML_TOK_PARAM_ENTITY_REF:
                         return XML_ERROR_PARAM_ENTITY_REF;
+                        return ERROR_EXPAT_PARAM_ENTITY_REF;
                     case XML_TOK_XML_DECL:
                         return XML_ERROR_MISPLACED_XML_PI;
+                        return ERROR_EXPAT_MISPLACED_XML_PI;
                     default:
                         return XML_ERROR_SYNTAX;
+                        return ERROR_EXPAT_SYNTAX;
+                }
 #ifdef XML_DTD
             case XML_ROLE_IGNORE_SECT:
+                {
                     enum XML_Error result;
+                    XMLERROR result;
                     if (defaultHandler)
 …
                         groupConnector = (char*)MALLOC(groupSize = 32);
                     if (!groupConnector)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
+                }
                 groupConnector[prologState.level] = 0;
 …
                     if (myindex < 0)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     dtd.scaffIndex[dtd.scaffLevel] = myindex;
                     dtd.scaffLevel++;
 …
             case XML_ROLE_GROUP_SEQUENCE:
                 if (groupConnector[prologState.level] == '|')
                     return XML_ERROR_SYNTAX;
+                    return ERROR_EXPAT_SYNTAX;
                 groupConnector[prologState.level] = ',';
                 break;
             case XML_ROLE_GROUP_CHOICE:
                 if (groupConnector[prologState.level] == ',')
                     return XML_ERROR_SYNTAX;
+                    return ERROR_EXPAT_SYNTAX;
                 if (dtd.in_eldecl
                     && !groupConnector[prologState.level]
 …
                                            next - enc->minBytesPerChar);
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     entity = (ENTITY*)lookup(&dtd.paramEntities, name, 0);
                     poolDiscard(&dtd.pool);
 …
+                    {
                         /* FIXME what to do if !dtd.complete? */
                         return XML_ERROR_UNDEFINED_ENTITY;
+                        return ERROR_EXPAT_UNDEFINED_ENTITY;
+                    }
                     if (entity->open)
                         return XML_ERROR_RECURSIVE_ENTITY_REF;
+                        return ERROR_EXPAT_RECURSIVE_ENTITY_REF;
                     if (entity->textPtr)
+                    {
                         enum XML_Error result;
+                        XMLERROR result;
                         result = processInternalParamEntity(parser, entity);
                         if (result != XML_ERROR_NONE)
+                        if (result != ERROR_EXPAT_NONE)
                             return result;
                         break;
+                    }
                     if (role == XML_ROLE_INNER_PARAM_ENTITY_REF)
                         return XML_ERROR_PARAM_ENTITY_REF;
+                        return ERROR_EXPAT_PARAM_ENTITY_REF;
                     if (externalEntityRefHandler)
+                    {
 …
+                        {
                             entity->open = 0;
                             return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
+                            return ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING;
+                        }
                         entity->open = 0;
 …
                     && notStandaloneHandler
                     && !notStandaloneHandler(handlerArg))
                     return XML_ERROR_NOT_STANDALONE;
+                    return ERROR_EXPAT_NOT_STANDALONE;
                 dtd.complete = 0;
                 if (defaultHandler)
 …
                     declElementType = getElementType(parser, enc, s, next);
                     if (!declElementType)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     dtd.scaffLevel = 0;
                     dtd.scaffCount = 0;
 …
                     if (elementDeclHandler)
+                    {
                         XML_Content *content = (XML_Content*)MALLOC(sizeof(XML_Content));
+                        XMLCONTENT *content = (XMLCONTENT*)MALLOC(sizeof(XMLCONTENT));
                         if (!content)
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         content->quant = XML_CQUANT_NONE;
                         content->name = 0;
 …
                     if (myindex < 0)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     dtd.scaffold[myindex].type = XML_CTYPE_NAME;
                     dtd.scaffold[myindex].quant = quant;
                     el = getElementType(parser, enc, s, nxt);
                     if (!el)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     dtd.scaffold[myindex].name = el->name;
                     dtd.contentStringLen += nxt - s + 1;
 …
                         if (elementDeclHandler)
+                        {
                             XML_Content *model = build_model(parser);
+                            XMLCONTENT *model = build_model(parser);
                             if (!model)
                                 return XML_ERROR_NO_MEMORY;
+                                return ERROR_EXPAT_NO_MEMORY;
                             *eventEndPP = s;
                             elementDeclHandler(handlerArg, declElementType->name, model);
 …
                     case XML_TOK_PI:
                         if (!reportProcessingInstruction(parser, enc, s, next))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         break;
                     case XML_TOK_COMMENT:
                         if (!reportComment(parser, enc, s, next))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         break;
+                }
 …
+}
 static enum XML_Error epilogProcessor(XML_Parser parser,
+static XMLERROR epilogProcessor(XML_Parser parser,
                                const char *s,
                                const char *end,
 …
                 if (nextPtr)
                     *nextPtr = end;
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
             case XML_TOK_PROLOG_S:
                 if (defaultHandler)
 …
             case XML_TOK_PI:
                 if (!reportProcessingInstruction(parser, encoding, s, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_COMMENT:
                 if (!reportComment(parser, encoding, s, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_INVALID:
                 eventPtr = next;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_PARTIAL:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_UNCLOSED_TOKEN;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_UNCLOSED_TOKEN;
             case XML_TOK_PARTIAL_CHAR:
                 if (nextPtr)
+                {
                     *nextPtr = s;
                     return XML_ERROR_NONE;
+                }
                 return XML_ERROR_PARTIAL_CHAR;
+                    return ERROR_EXPAT_NONE;
+                }
+                return ERROR_EXPAT_PARTIAL_CHAR;
             default:
                 return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
+                return ERROR_EXPAT_JUNK_AFTER_DOC_ELEMENT;
+        }
         eventPtr = s = next;
 …
 #ifdef XML_DTD
 static enum XML_Error processInternalParamEntity(XML_Parser parser, ENTITY * entity)
+static XMLERROR processInternalParamEntity(XML_Parser parser, ENTITY * entity)
+{
     const char *s, *end, *next;
     int tok;
     enum XML_Error result;
+    XMLERROR result;
     OPEN_INTERNAL_ENTITY openEntity;
 …
 #endif /* XML_DTD */
 static enum XML_Error errorProcessor(XML_Parser parser,
+static XMLERROR errorProcessor(XML_Parser parser,
                               const char *s,
                               const char *end,
 …
+}
 static enum XML_Error storeAttributeValue(XML_Parser parser,
+static XMLERROR storeAttributeValue(XML_Parser parser,
                                           const ENCODING * enc,
                                           int isCdata,
 …
                                           STRING_POOL * pool)
+{
     enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
+    XMLERROR result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
     if (result)
 …
         poolChop(pool);
     if (!poolAppendChar(pool, XML_T('\0')))
         return XML_ERROR_NO_MEMORY;
     return XML_ERROR_NONE;
+}
 static enum XML_Error appendAttributeValue(XML_Parser parser, const ENCODING * enc, int isCdata,
+        return ERROR_EXPAT_NO_MEMORY;
+    return ERROR_EXPAT_NONE;
+}
+static XMLERROR appendAttributeValue(XML_Parser parser, const ENCODING * enc, int isCdata,
                       const char *ptr, const char *end,
                       STRING_POOL * pool)
 …
+        {
             case XML_TOK_NONE:
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
             case XML_TOK_INVALID:
                 if (enc == encoding)
                     eventPtr = next;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_PARTIAL:
                 if (enc == encoding)
                     eventPtr = ptr;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_CHAR_REF:
+                {
 …
                         if (enc == encoding)
                             eventPtr = ptr;
                         return XML_ERROR_BAD_CHAR_REF;
+                        return ERROR_EXPAT_BAD_CHAR_REF;
+                    }
                     if (!isCdata
 …
                         if (enc == encoding)
                             eventPtr = ptr;
                         return XML_ERROR_BAD_CHAR_REF;
+                        return ERROR_EXPAT_BAD_CHAR_REF;
+                    }
                     for (i = 0; i < n; i++)
+                    {
                         if (!poolAppendChar(pool, buf[i]))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
+                    }
+                }
 …
             case XML_TOK_DATA_CHARS:
                 if (!poolAppend(pool, enc, ptr, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_TRAILING_CR:
 …
                     break;
                 if (!poolAppendChar(pool, 0x20))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_ENTITY_REF:
 …
+                    {
                         if (!poolAppendChar(pool, ch))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         break;
+                    }
 …
                                            next - enc->minBytesPerChar);
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     entity = (ENTITY*)lookup(&dtd.generalEntities, name, 0);
                     poolDiscard(&temp2Pool);
 …
                             if (enc == encoding)
                                 eventPtr = ptr;
                             return XML_ERROR_UNDEFINED_ENTITY;
+                            return ERROR_EXPAT_UNDEFINED_ENTITY;
+                        }
+                    }
 …
                         if (enc == encoding)
                             eventPtr = ptr;
                         return XML_ERROR_RECURSIVE_ENTITY_REF;
+                        return ERROR_EXPAT_RECURSIVE_ENTITY_REF;
+                    }
                     else if (entity->notation)
 …
                         if (enc == encoding)
                             eventPtr = ptr;
                         return XML_ERROR_BINARY_ENTITY_REF;
+                        return ERROR_EXPAT_BINARY_ENTITY_REF;
+                    }
                     else if (!entity->textPtr)
 …
                         if (enc == encoding)
                             eventPtr = ptr;
                         return XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+                        return ERROR_EXPAT_ATTRIBUTE_EXTERNAL_ENTITY_REF;
+                    }
                     else
+                    {
                         enum XML_Error result;
+                        XMLERROR result;
                         const XML_Char *textEnd = entity->textPtr + entity->textLen;
 …
                 if (enc == encoding)
                     eventPtr = ptr;
                 return XML_ERROR_UNEXPECTED_STATE;
+                return ERROR_EXPAT_UNEXPECTED_STATE;
+        }
         ptr = next;
 …
+}
 static enum XML_Error storeEntityValue(XML_Parser parser,
+static XMLERROR storeEntityValue(XML_Parser parser,
                                 const ENCODING * enc,
                                 const char *entityTextPtr,
 …
                 if (parentParser || enc != encoding)
+                {
                     enum XML_Error result;
+                    XMLERROR result;
                     const XML_Char *name;
                     ENTITY *entity;
 …
                                            next - enc->minBytesPerChar);
                     if (!name)
                         return XML_ERROR_NO_MEMORY;
+                        return ERROR_EXPAT_NO_MEMORY;
                     entity = (ENTITY*)lookup(&dtd.paramEntities, name, 0);
                     poolDiscard(&tempPool);
 …
                         if (enc == encoding)
                             eventPtr = entityTextPtr;
                         return XML_ERROR_UNDEFINED_ENTITY;
+                        return ERROR_EXPAT_UNDEFINED_ENTITY;
+                    }
                     if (entity->open)
 …
                         if (enc == encoding)
                             eventPtr = entityTextPtr;
                         return XML_ERROR_RECURSIVE_ENTITY_REF;
+                        return ERROR_EXPAT_RECURSIVE_ENTITY_REF;
+                    }
                     if (entity->systemId)
 …
                         if (enc == encoding)
                             eventPtr = entityTextPtr;
                         return XML_ERROR_PARAM_ENTITY_REF;
+                        return ERROR_EXPAT_PARAM_ENTITY_REF;
+                    }
                     entity->open = 1;
 …
 #endif /* XML_DTD */
                 eventPtr = entityTextPtr;
                 return XML_ERROR_SYNTAX;
+                return ERROR_EXPAT_SYNTAX;
             case XML_TOK_NONE:
                 return XML_ERROR_NONE;
+                return ERROR_EXPAT_NONE;
             case XML_TOK_ENTITY_REF:
             case XML_TOK_DATA_CHARS:
                 if (!poolAppend(pool, enc, entityTextPtr, next))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 break;
             case XML_TOK_TRAILING_CR:
 …
             case XML_TOK_DATA_NEWLINE:
                 if (pool->end == pool->ptr && !poolGrow(pool))
                     return XML_ERROR_NO_MEMORY;
+                    return ERROR_EXPAT_NO_MEMORY;
                 *(pool->ptr)++ = 0xA;
                 break;
 …
                         if (enc == encoding)
                             eventPtr = entityTextPtr;
                         return XML_ERROR_BAD_CHAR_REF;
+                        return ERROR_EXPAT_BAD_CHAR_REF;
+                    }
                     n = XmlEncode(n, (ICHAR*)buf);
 …
                         if (enc == encoding)
                             eventPtr = entityTextPtr;
                         return XML_ERROR_BAD_CHAR_REF;
+                        return ERROR_EXPAT_BAD_CHAR_REF;
+                    }
                     for (i = 0; i < n; i++)
+                    {
                         if (pool->end == pool->ptr && !poolGrow(pool))
                             return XML_ERROR_NO_MEMORY;
+                            return ERROR_EXPAT_NO_MEMORY;
                         *(pool->ptr)++ = buf[i];
+                    }
 …
                 if (enc == encoding)
                     eventPtr = entityTextPtr;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             case XML_TOK_INVALID:
                 if (enc == encoding)
                     eventPtr = next;
                 return XML_ERROR_INVALID_TOKEN;
+                return ERROR_EXPAT_INVALID_TOKEN;
             default:
                 if (enc == encoding)
                     eventPtr = entityTextPtr;
                 return XML_ERROR_UNEXPECTED_STATE;
+                return ERROR_EXPAT_UNEXPECTED_STATE;
+        }
         entityTextPtr = next;
 …
+}
+/* Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
+ * The new DTD has already been initialized. */
+/*
+ * Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
+ * The new DTD has already been initialized.
+ *
+ */
 static int dtdCopy(DTD * newDtd, const DTD * oldDtd, XML_Parser parser)
 …
 static void build_node(XML_Parser parser,
             int src_node,
             XML_Content * dest,
             XML_Content ** contpos,
+            XMLCONTENT * dest,
+            XMLCONTENT ** contpos,
             char **strpos)
+{
 …
 }                               /* End build_node */
 static XML_Content * build_model(XML_Parser parser)
+{
     XML_Content *ret;
     XML_Content *cpos;
+static XMLCONTENT * build_model(XML_Parser parser)
+{
+    XMLCONTENT *ret;
+    XMLCONTENT *cpos;
     char *str;
     int allocsize = dtd.scaffCount * sizeof(XML_Content) + dtd.contentStringLen;
     ret = (XML_Content*)MALLOC(allocsize);
+    int allocsize = dtd.scaffCount * sizeof(XMLCONTENT) + dtd.contentStringLen;
+    ret = (XMLCONTENT*)MALLOC(allocsize);
     if (!ret)
         return 0;

trunk/src/helpers/xmlrole.c

r36	r38
1	1
2	2	/*
3		*@@sourcefile xmlrole.c
	3	*sourcefile xmlrole.c
4	4	* part of the expat implementation. See xmlparse.c.
5	5	*

trunk/src/helpers/xmltok.c

r36	r38
1	1
2	2	/*
3		*@@sourcefile xmltok.c
	3	*sourcefile xmltok.c
4	4	* part of the expat implementation. See xmlparse.c.
5	5	*

trunk/src/helpers/xmltok_impl.c

r36	r38
1	1
2	2	/*
3		*@@sourcefile xmltok_impl.c
	3	*sourcefile xmltok_impl.c
4	4	* part of the expat implementation. See xmlparse.c.
5	5	*

trunk/src/helpers/xmltok_ns.c

r36	r38
1	1
2	2	/*
3		*@@sourcefile xmltok_ns.c
	3	*sourcefile xmltok_ns.c
4	4	* part of the expat implementation. See xmlparse.c.
5	5	*

trunk/src/helpers/xstring.c

-              r32
+              r38
+ *
  *@@added V0.9.6 (2000-11-01) [umoeller]
+ *@@changed V0.9.9 (2001-02-14) [umoeller]: fixed NULL target crash
  */
 …
               PSZ pszNew)                   // in: heap PSZ to use
+{
+    if (!pxstr)
+        return (0);         // V0.9.9 (2001-02-14) [umoeller]
     xstrClear(pxstr);
     pxstr->psz = pszNew;
 …
  *@@changed V0.9.7 (2001-01-15) [umoeller]: added ulSourceLength
  *@@changed V0.9.9 (2001-01-28) [lafaix]: fixed memory leak and NULL source behavior
+ *@@changed V0.9.9 (2001-02-14) [umoeller]: fixed NULL target crash
  */
 …
     // xstrClear(pxstr);        NOOOO! this frees the string, we want to keep the memory
+    if (pxstr)
+    {
+        if (pcszSource)
+    if (!pxstr)
+        return (0);         // V0.9.9 (2001-02-14) [umoeller]
+    if (pcszSource)
+    {
+        // source specified:
+        if (ulSourceLength == 0)
+            // but not length:
+            ulSourceLength = strlen(pcszSource);
+    }
+    else
+        ulSourceLength = 0;
+    if (ulSourceLength)
+    {
+        // we do have a source string:
+        ULONG cbNeeded = ulSourceLength + 1;
+        if (cbNeeded > pxstr->cbAllocated)
+        {
+            // source specified:
+            if (ulSourceLength == 0)
+                // but not length:
+                ulSourceLength = strlen(pcszSource);
+            // we need more memory than we have previously
+            // allocated:
+            if (pxstr->psz)
+                free(pxstr->psz); // V0.9.9 (2001-01-28) [lafaix]
+            pxstr->cbAllocated = cbNeeded;
+            pxstr->psz = (PSZ)malloc(cbNeeded);
+        }
+        else
+            ulSourceLength = 0;
+        if (ulSourceLength)
+        {
+            // we do have a source string:
+            ULONG cbNeeded = ulSourceLength + 1;
+            if (cbNeeded > pxstr->cbAllocated)
+            {
+                // we need more memory than we have previously
+                // allocated:
+                if (pxstr->psz)
+                    free(pxstr->psz); // V0.9.9 (2001-01-28) [lafaix]
+                pxstr->cbAllocated = cbNeeded;
+                pxstr->psz = (PSZ)malloc(cbNeeded);
+            }
+            // else: we have enough memory
+            // strcpy(pxstr->psz, pcszSource);
+            memcpy(pxstr->psz,
+                   pcszSource,
+                   ulSourceLength + 1); // V0.9.9 (2001-01-31) [umoeller]
+        }
+        else
+        {
+            // no source specified or source is empty:
+            if (pxstr->cbAllocated)
+                // we did have a string: set to empty,
+                // but leave allocated memory intact
+                *(pxstr->psz) = 0;
+            // else
+                // we had no string previously: in that case
+                // psz and ulLength and cbAllocated are all still NULL
+        }
+        // in all cases, set new length
+        pxstr->ulLength = ulSourceLength;
+    }
+        // else: we have enough memory
+        // strcpy(pxstr->psz, pcszSource);
+        memcpy(pxstr->psz,
+               pcszSource,
+               ulSourceLength + 1); // V0.9.9 (2001-01-31) [umoeller]
+    }
+    else
+    {
+        // no source specified or source is empty:
+        if (pxstr->cbAllocated)
+            // we did have a string: set to empty,
+            // but leave allocated memory intact
+            *(pxstr->psz) = 0;
+        // else
+            // we had no string previously: in that case
+            // psz and ulLength and cbAllocated are all still NULL
+    }
+    // in all cases, set new length
+    pxstr->ulLength = ulSourceLength;
     return (pxstr->ulLength);
+}
+/*
+ *@@ xstrcpys:
+ *      shortcut to xstrcpy if the source is an XSTRING also.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+ULONG xstrcpys(PXSTRING pxstr,
+               const XSTRING *pcstrSource)
+{
+    if (!pcstrSource)
+        return (0);
+    return (xstrcpy(pxstr, pcstrSource->psz, pcstrSource->ulLength));
+}
 …
 /*
+ *@@ xstrcats:
+ *      shortcut to xstrcat if the source is an XSTRING also.
+ *
+ *@@added V0.9.9 (2001-02-14) [umoeller]
+ */
+ULONG xstrcats(PXSTRING pxstr,
+               const XSTRING *pcstrSource)
+{
+    if (!pcstrSource)
+        return (0);
+    return (xstrcat(pxstr, pcstrSource->psz, pcstrSource->ulLength));
+}
+/*
  *@@ xstrrpl:
  *      replaces cReplLen characters in pxstr, starting
 …
  *@@added V0.9.7 (2001-01-15) [umoeller]
  *@@changed V0.9.9 (2001-01-29) [lafaix]: fixed unnecessary allocation when pxstr was big enough
+  *@@changed V0.9.9 (2001-02-14) [umoeller]: fixed NULL target crash
  */
 …
     // security checks...
+    if (    (ulFirstReplOfs + cReplLen <= pxstr->ulLength)
+    if (    (pxstr)         // V0.9.9 (2001-02-14) [umoeller]
+         && (ulFirstReplOfs + cReplLen <= pxstr->ulLength)
          && (pstrReplaceWith)
          // && (pstrReplaceWith->ulLength)      no, this can be empty
 …
             ULONG   cTailLength = pxstr->ulLength - ulFirstReplOfs - cReplLen;
             // first, we move the end to its new location (memmove
             // handles overlap if needed)
+            // first, we move the end to its new location
+            // (memmove handles overlap if needed)
             memmove(pFound + cReplaceLen,
                     pFound + cReplLen,
 …
+ *
  *@@added V0.9.6 (2000-11-12) [umoeller]
+ *@@changed V0.9.9 (2001-02-14) [umoeller]: fixed NULL string crashs
  */
 …
+{
     PSZ     pReturn = 0;
+    ULONG   ulFoundLen = pstrFind->ulLength;
+    if ((pxstr->ulLength) && (ulFoundLen))
+    {
+        const char *p = pxstr->psz + ulOfs;
+        do  // while p
+    if (pxstr && pstrFind)      // V0.9.9 (2001-02-14) [umoeller]
+    {
+        ULONG   ulFoundLen = pstrFind->ulLength;
+        if ((pxstr->ulLength) && (ulFoundLen))
+        {
+            // p = strstr(p, pstrFind->psz);
+            p = (PSZ)strhmemfind(p,         // in: haystack
+                                 pxstr->ulLength - (p - pxstr->psz),
+                                            // remaining length of haystack
+                                 pstrFind->psz,
+                                 ulFoundLen,
+                                 pShiftTable,
+                                 pfRepeatFind);
+            if (p)
+            const char *p = pxstr->psz + ulOfs;
+            do  // while p
+            {
                 // string found:
                 // check if that's a word
                 if (strhIsWord(pxstr->psz,
                                p,
                                ulFoundLen,
                                pcszBeginChars,
                                pcszEndChars))
+                p = (PSZ)strhmemfind(p,         // in: haystack
+                                     pxstr->ulLength - (p - pxstr->psz),
+                                                // remaining length of haystack
+                                     pstrFind->psz,
+                                     ulFoundLen,
+                                     pShiftTable,
+                                     pfRepeatFind);
+                if (p)
+                {
+                    // valid end char:
+                    pReturn = (PSZ)p;
+                    break;
+                    // string found:
+                    // check if that's a word
+                    if (strhIsWord(pxstr->psz,
+                                   p,
+                                   ulFoundLen,
+                                   pcszBeginChars,
+                                   pcszEndChars))
+                    {
+                        // valid end char:
+                        pReturn = (PSZ)p;
+                        break;
+                    }
+                    p += ulFoundLen;
+                }
+                p += ulFoundLen;
+            }
+        } while (p);
+    }
+            } while (p);
+        }
+    }
     return (pReturn);
+}

Context Navigation

Legend:

trunk/include/expat/expat.h

trunk/include/expat/expat_setup.h

trunk/include/expat/xmlrole.h

trunk/include/expat/xmltok.h

trunk/include/helpers/linklist.h

trunk/include/helpers/stringh.h

trunk/include/helpers/tree.h

trunk/include/helpers/xml.h

trunk/include/helpers/xstring.h

trunk/src/helpers/dosh.c

trunk/src/helpers/gpih.c

trunk/src/helpers/helpers_post.in

trunk/src/helpers/linklist.c

trunk/src/helpers/prfh.c

trunk/src/helpers/stringh.c

trunk/src/helpers/threads.c

trunk/src/helpers/tree.c

trunk/src/helpers/xml.c

trunk/src/helpers/xmldefs.c

trunk/src/helpers/xmlparse.c

trunk/src/helpers/xmlrole.c

trunk/src/helpers/xmltok.c

trunk/src/helpers/xmltok_impl.c

trunk/src/helpers/xmltok_ns.c

trunk/src/helpers/xstring.c

Download in other formats: