Changeset 97


Ignore:
Timestamp:
Aug 12, 2001, 5:34:51 PM (24 years ago)
Author:
umoeller
Message:

XML updates.

Location:
trunk
Files:
15 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/encodings/base.h

    r37 r97  
    77 */
    88
    9 /*
    10  *@@ XWPENCODINGMAP:
    11  *      entry in an 8-bit to Unicode conversion table.
    12  */
     9#if __cplusplus
     10extern "C" {
     11#endif
    1312
    14 typedef struct _XWPENCODINGMAP
    15 {
    16     unsigned short      usFrom;
    17     unsigned short      usUni;
    18 } XWPENCODINGMAP, *PXWPENCODINGMAP;
     13#ifndef ENC_BASE_HEADER_INCLUDED
     14    #define ENC_BASE_HEADER_INCLUDED
    1915
    20 /*
    21  *@@ XWPENCODINGID:
    22  *      enum identifying each encoding set which is
    23  *      generally supported. Each ID corresponds to
    24  *      one header file in include\encodings\.
    25  */
     16    /*
     17     *@@ XWPENCODINGMAP:
     18     *      entry in an 8-bit to Unicode conversion table.
     19     */
    2620
    27 typedef enum _XWPENCODINGID
    28 {
    29     enc_cp437,
    30     enc_cp737,
    31     enc_cp775,
    32     enc_cp850,
    33     enc_cp852,
    34     enc_cp855,
    35     enc_cp857,
    36     enc_cp860,
    37     enc_cp861,
    38     enc_cp862,
    39     enc_cp863,
    40     enc_cp864,
    41     enc_cp865,
    42     enc_cp866,
    43     enc_cp869,
    44     enc_cp874,
    45     enc_cp932,
    46     enc_cp936,
    47     enc_cp949,
    48     enc_cp950,
    49     enc_cp1250,
    50     enc_cp1251,
    51     enc_cp1252,
    52     enc_cp1253,
    53     enc_cp1254,
    54     enc_cp1255,
    55     enc_cp1256,
    56     enc_cp1257,
    57     enc_cp1258,
    58     enc_iso8859_1,
    59     enc_iso8859_2,
    60     enc_iso8859_3,
    61     enc_iso8859_4,
    62     enc_iso8859_5,
    63     enc_iso8859_6,
    64     enc_iso8859_7,
    65     enc_iso8859_8,
    66     enc_iso8859_9,
    67     enc_iso8859_10,
    68     enc_iso8859_13,
    69     enc_iso8859_14,
    70     enc_iso8859_15
    71 } XWPENCODINGID;
     21    typedef struct _XWPENCODINGMAP
     22    {
     23        unsigned short      usFrom;
     24        unsigned short      usUni;
     25    } XWPENCODINGMAP, *PXWPENCODINGMAP;
    7226
     27    /*
     28     *@@ XWPENCODINGID:
     29     *      enum identifying each encoding set which is
     30     *      generally supported. Each ID corresponds to
     31     *      one header file in include\encodings\.
     32     */
    7333
     34    typedef enum _XWPENCODINGID
     35    {
     36        enc_cp437,
     37        enc_cp737,
     38        enc_cp775,
     39        enc_cp850,
     40        enc_cp852,
     41        enc_cp855,
     42        enc_cp857,
     43        enc_cp860,
     44        enc_cp861,
     45        enc_cp862,
     46        enc_cp863,
     47        enc_cp864,
     48        enc_cp865,
     49        enc_cp866,
     50        enc_cp869,
     51        enc_cp874,
     52        enc_cp932,
     53        enc_cp936,
     54        enc_cp949,
     55        enc_cp950,
     56        enc_cp1250,
     57        enc_cp1251,
     58        enc_cp1252,
     59        enc_cp1253,
     60        enc_cp1254,
     61        enc_cp1255,
     62        enc_cp1256,
     63        enc_cp1257,
     64        enc_cp1258,
     65        enc_iso8859_1,
     66        enc_iso8859_2,
     67        enc_iso8859_3,
     68        enc_iso8859_4,
     69        enc_iso8859_5,
     70        enc_iso8859_6,
     71        enc_iso8859_7,
     72        enc_iso8859_8,
     73        enc_iso8859_9,
     74        enc_iso8859_10,
     75        enc_iso8859_13,
     76        enc_iso8859_14,
     77        enc_iso8859_15
     78    } XWPENCODINGID;
     79
     80    unsigned long encDecodeUTF8(const char **ppch);
     81
     82#endif
     83
     84#if __cplusplus
     85}
     86#endif
     87

  • trunk/include/expat/ascii.h

    r36 r97  
    7070
    7171#define ASCII_TAB 0x09
    72 #define ASCII_SPACE 0x20
     72#define ASCII_SPACE 0x20 
    7373#define ASCII_EXCL 0x21
    7474#define ASCII_QUOT 0x22

  • trunk/include/expat/expat.h

    r71 r97  
    1414
    1515#ifndef XMLPARSEAPI
    16 #  ifdef __declspec
    17 #    define XMLPARSEAPI __declspec(dllimport)
    18 #  else
    19 #    define XMLPARSEAPI /* nothing */
    20 #  endif
    21 #endif  /* not defined XMLPARSEAPI */
     16    #ifdef EXPATENTRY
     17        #define XMLPARSEAPI(type) type EXPATENTRY
     18            // V0.9.14 (2001-08-09) [umoeller]
     19    #else
     20        #define XMLPARSEAPI(type) type
     21    #endif
     22#endif
    2223
    2324#ifdef __cplusplus
    … …  
    105106                    // -- XML_CQUANT_PLUS   plus sign
    106107
    107     const XML_Char              *name;
     108    XML_Char                    *name;
    108109
    109110    unsigned int                numchildren;
    110111
    111112    struct _XMLCONTENT          *children;
    112 
    113113} XMLCONTENT, *PXMLCONTENT;
    114114
    … …  
    119119*/
    120120
    121 typedef void (* EXPATENTRY XML_ElementDeclHandler) (void *userData,
    122                                                     const XML_Char *name,
    123                                                     XMLCONTENT *model);
    124 
    125 void XMLPARSEAPI XML_SetElementDeclHandler(XML_Parser parser,
     121typedef void (*XML_ElementDeclHandler) (void *userData,
     122                                        const XML_Char *name,
     123                                        XMLCONTENT *model);
     124
     125XMLPARSEAPI(void)
     126XML_SetElementDeclHandler(XML_Parser parser,
    126127              XML_ElementDeclHandler eldecl);
    127128
    … …  
    136137 */
    137138
    138 typedef void (* EXPATENTRY XML_AttlistDeclHandler) (void *userData,
    139                     const XML_Char  *elname,
    140                     const XML_Char  *attname,
    141                     const XML_Char  *att_type,
    142                     const XML_Char  *dflt,
    143                     int     isrequired);
    144 
    145 void XMLPARSEAPI XML_SetAttlistDeclHandler(XML_Parser parser,
     139typedef void (*XML_AttlistDeclHandler) (void           *userData,
     140                                        const XML_Char *elname,
     141                                        const XML_Char *attname,
     142                                        const XML_Char *att_type,
     143                                        const XML_Char *dflt,
     144                                        int     isrequired);
     145
     146XMLPARSEAPI(void)
     147XML_SetAttlistDeclHandler(XML_Parser parser,
    146148              XML_AttlistDeclHandler attdecl);
    147149
    … …  
    155157  */
    156158
    157 typedef void (* EXPATENTRY XML_XmlDeclHandler) (void        *userData,
    158                     const XML_Char  *version,
    159                     const XML_Char  *encoding,
    160                     int         standalone);
    161 
    162 void XMLPARSEAPI XML_SetXmlDeclHandler(XML_Parser parser,
     159typedef void (*XML_XmlDeclHandler) (void        *userData,
     160                                    const XML_Char  *version,
     161                                    const XML_Char  *encoding,
     162                                    int          standalone);
     163
     164XMLPARSEAPI(void)
     165XML_SetXmlDeclHandler(XML_Parser parser,
    163166              XML_XmlDeclHandler xmldecl);
    164167
    … …  
    170173} XML_Memory_Handling_Suite;
    171174
    172 /* Constructs a new parser; encoding is the encoding specified by the external
    173 protocol or null if there is none specified. */
    174 
    175 XML_Parser XMLPARSEAPI XML_ParserCreate(const XML_Char *encoding);
    176 
    177 /* Constructs a new parser and namespace processor.  Element type names
    178 and attribute names that belong to a namespace will be expanded;
     175/* Constructs a new parser; encoding is the encoding specified by the
     176external protocol or null if there is none specified. */
     177
     178XMLPARSEAPI(XML_Parser)
     179XML_ParserCreate(const XML_Char *encoding);
     180
     181/* Constructs a new parser and namespace processor.  Element type
     182names and attribute names that belong to a namespace will be expanded;
    179183unprefixed attribute names are never expanded; unprefixed element type
    180184names are expanded only if there is a default namespace. The expanded
    181 name is the concatenation of the namespace URI, the namespace separator character,
    182 and the local part of the name.  If the namespace separator is '\0' then
    183 the namespace URI and the local part will be concatenated without any
    184 separator.  When a namespace is not declared, the name and prefix will be
    185 passed through without expansion. */
    186 
    187 XML_Parser XMLPARSEAPI XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
     185name is the concatenation of the namespace URI, the namespace
     186separator character, and the local part of the name.  If the namespace
     187separator is '\0' then the namespace URI and the local part will be
     188concatenated without any separator.  When a namespace is not declared,
     189the name and prefix will be passed through without expansion. */
     190
     191XMLPARSEAPI(XML_Parser)
     192XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
    188193
    189194
    … …  
    198203*/
    199204
    200 XML_Parser XMLPARSEAPI XML_ParserCreate_MM(const XML_Char *encoding,
     205XMLPARSEAPI(XML_Parser)
     206XML_ParserCreate_MM(const XML_Char *encoding,
    201207            const XML_Memory_Handling_Suite *memsuite,
    202208            const XML_Char *namespaceSeparator);
    … …  
    205211   names and values are 0 terminated. */
    206212
    207 typedef void (* EXPATENTRY XML_StartElementHandler)(void *userData,
    208                                                  const XML_Char *name,
    209                                                  const XML_Char **atts);
    210 
    211 typedef void (* EXPATENTRY XML_EndElementHandler)(void *userData,
    212                                                const XML_Char *name);
     213typedef void (*XML_StartElementHandler)(void *userData,
     214                                        const XML_Char *name,
     215                                        const XML_Char **atts);
     216
     217typedef void (*XML_EndElementHandler)(void *userData,
     218                                      const XML_Char *name);
    213219
    214220
    215221/* s is not 0 terminated. */
    216 typedef void (* EXPATENTRY XML_CharacterDataHandler)(void *userData,
    217                                                   const XML_Char *s,
    218                                                   int len);
     222typedef void (*XML_CharacterDataHandler)(void *userData,
     223                                         const XML_Char *s,
     224                                         int len);
    219225
    220226/* target and data are 0 terminated */
    221 typedef void (* EXPATENTRY XML_ProcessingInstructionHandler)(void *userData,
    222                                                           const XML_Char *target,
    223                                                           const XML_Char *data);
     227typedef void (*XML_ProcessingInstructionHandler)(void *userData,
     228                                                 const XML_Char *target,
     229                                                 const XML_Char *data);
    224230
    225231/* data is 0 terminated */
    226 typedef void (* EXPATENTRY XML_CommentHandler)(void *userData, const XML_Char *data);
    227 
    228 typedef void (* EXPATENTRY XML_StartCdataSectionHandler)(void *userData);
    229 typedef void (* EXPATENTRY XML_EndCdataSectionHandler)(void *userData);
     232typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
     233
     234typedef void (*XML_StartCdataSectionHandler)(void *userData);
     235typedef void (*XML_EndCdataSectionHandler)(void *userData);
    230236
    231237/* This is called for any characters in the XML document for
    … …  
    242248multiple calls. */
    243249
    244 typedef void (* EXPATENTRY XML_DefaultHandler)(void *userData,
    245                                             const XML_Char *s,
    246                                             int len);
     250typedef void (*XML_DefaultHandler)(void *userData,
     251                                   const XML_Char *s,
     252                                   int len);
    247253
    248254/* This is called for the start of the DOCTYPE declaration, before
    249255   any DTD or internal subset is parsed. */
    250256
    251 typedef void (* EXPATENTRY XML_StartDoctypeDeclHandler)(void *userData,
    252                                                      const XML_Char *doctypeName,
    253                                                      const XML_Char *sysid,
    254                                                      const XML_Char *pubid,
    255                                                      int has_internal_subset);
     257typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
     258                                            const XML_Char *doctypeName,
     259                                            const XML_Char *sysid,
     260                                            const XML_Char *pubid,
     261                                            int has_internal_subset);
    256262
    257263/* This is called for the start of the DOCTYPE declaration when the
    258264closing > is encountered, but after processing any external subset. */
    259 typedef void (* EXPATENTRY XML_EndDoctypeDeclHandler)(void *userData);
     265typedef void (*XML_EndDoctypeDeclHandler)(void *userData);
    260266
    261267/* This is called for entity declarations. The is_parameter_entity
    … …  
    275281*/
    276282
    277 typedef void (* EXPATENTRY XML_EntityDeclHandler)(void *userData,
    278                                                const XML_Char *entityName,
    279                                                int is_parameter_entity,
    280                                                const XML_Char *value,
    281                                                int value_length,
    282                                                const XML_Char *base,
    283                                                const XML_Char *systemId,
    284                                                const XML_Char *publicId,
    285                                                const XML_Char *notationName);
    286 
    287 void XMLPARSEAPI XML_SetEntityDeclHandler(XML_Parser parser,
    288                                           XML_EntityDeclHandler handler);
     283typedef void (*XML_EntityDeclHandler) (void *userData,
     284                                       const XML_Char *entityName,
     285                                       int is_parameter_entity,
     286                                       const XML_Char *value,
     287                                       int value_length,
     288                                       const XML_Char *base,
     289                                       const XML_Char *systemId,
     290                                       const XML_Char *publicId,
     291                                       const XML_Char *notationName);
     292
     293XMLPARSEAPI(void)
     294XML_SetEntityDeclHandler(XML_Parser parser,
     295             XML_EntityDeclHandler handler);
    289296
    290297/* OBSOLETE -- OBSOLETE -- OBSOLETE
    … …  
    296303The other arguments may be. */
    297304
    298 typedef void (* EXPATENTRY XML_UnparsedEntityDeclHandler)(void *userData,
    299                           const XML_Char *entityName,
    300                           const XML_Char *base,
    301                           const XML_Char *systemId,
    302                           const XML_Char *publicId,
    303                           const XML_Char *notationName);
     305typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,
     306                                              const XML_Char *entityName,
     307                                              const XML_Char *base,
     308                                              const XML_Char *systemId,
     309                                              const XML_Char *publicId,
     310                                              const XML_Char *notationName);
    304311
    305312/* This is called for a declaration of notation.
    … …  
    307314The notationName will never be null.  The other arguments can be. */
    308315
    309 typedef void (* EXPATENTRY XML_NotationDeclHandler)(void *userData,
    310                     const XML_Char *notationName,
    311                     const XML_Char *base,
    312                     const XML_Char *systemId,
    313                     const XML_Char *publicId);
     316typedef void (*XML_NotationDeclHandler)(void *userData,
     317                                        const XML_Char *notationName,
     318                                        const XML_Char *base,
     319                                        const XML_Char *systemId,
     320                                        const XML_Char *publicId);
    314321
    315322/* When namespace processing is enabled, these are called once for
    … …  
    319326For an xmlns="" attribute, uri will be null. */
    320327
    321 typedef void (* EXPATENTRY XML_StartNamespaceDeclHandler)(void *userData,
    322                           const XML_Char *prefix,
    323                           const XML_Char *uri);
    324 
    325 typedef void (* EXPATENTRY XML_EndNamespaceDeclHandler)(void *userData,
    326                         const XML_Char *prefix);
     328typedef void (*XML_StartNamespaceDeclHandler)(void *userData,
     329                                              const XML_Char *prefix,
     330                                              const XML_Char *uri);
     331
     332typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
     333                                            const XML_Char *prefix);
    327334
    328335/* This is called if the document is not standalone (it has an
    … …  
    332339ERROR_EXPAT_NOT_STANDALONE error. */
    333340
    334 typedef int (* EXPATENTRY XML_NotStandaloneHandler)(void *userData);
     341typedef int (*XML_NotStandaloneHandler)(void *userData);
    335342
    336343/* This is called for a reference to an external parsed general entity.
    … …  
    340347The parser argument is the parser parsing the entity containing the reference;
    341348it can be passed as the parser argument to XML_ExternalEntityParserCreate.
    342 The systemId argument is the system identifier as specified in the entity declaration;
    343 it will not be null.
     349The systemId argument is the system identifier as specified in the entity
     350declaration; it will not be null.
    344351The base argument is the system identifier that should be used as the base for
    345352resolving systemId if systemId was relative; this is set by XML_SetBase;
    346353it may be null.
    347 The publicId argument is the public identifier as specified in the entity declaration,
    348 or null if none was specified; the whitespace in the public identifier
    349 will have been normalized as required by the XML spec.
     354The publicId argument is the public identifier as specified in the entity
     355declaration, or null if none was specified; the whitespace in the public
     356identifier will have been normalized as required by the XML spec.
    350357The context argument specifies the parsing context in the format
    351358expected by the context argument to
    … …  
    354361The handler should return 0 if processing should not continue because of
    355362a fatal error in the handling of the external entity.
    356 In this case the calling parser will return an ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING
    357 error.
    358 Note that unlike other handlers the first argument is the parser, not userData. */
    359 
    360 typedef int (* EXPATENTRY XML_ExternalEntityRefHandler)(XML_Parser parser,
    361                         const XML_Char *context,
    362                         const XML_Char *base,
    363                         const XML_Char *systemId,
    364                         const XML_Char *publicId);
     363In this case the calling parser will return an
     364ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING error.
     365Note that unlike other handlers the first argument is the parser, not
     366userData. */
     367
     368typedef int (*XML_ExternalEntityRefHandler)(void *userData,     // added V0.9.14 (2001-08-09) [umoeller]
     369                                            XML_Parser parser,
     370                                            const XML_Char *context,
     371                                            const XML_Char *base,
     372                                            const XML_Char *systemId,
     373                                            const XML_Char *publicId);
    365374
    366375/* This structure is filled in by the XML_UnknownEncodingHandler
    … …  
    369378The map[b] member gives information about byte sequences
    370379whose first byte is b.
    371 If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar value c.
     380If map[b] is c where c is >= 0, then b by itself encodes the Unicode scalar
     381value c.
    372382If map[b] is -1, then the byte sequence is malformed.
    373383If map[b] is -n, where n >= 2, then b is the first byte of an n-byte
    … …  
    3974072. No character may require more than 4 bytes to encode.
    398408
    399 3. All characters encoded must have Unicode scalar values <= 0xFFFF,
    400 (ie characters that would be encoded by surrogates in UTF-16
    401 are  not allowed).  Note that this restriction doesn't apply to
    402 the built-in support for UTF-8 and UTF-16.
     4093. All characters encoded must have Unicode scalar values <= 0xFFFF, (i.e.,
     410characters that would be encoded by surrogates in UTF-16 are  not
     411allowed).  Note that this restriction doesn't apply to the built-in
     412support for UTF-8 and UTF-16.
    403413
    4044144. No Unicode character may be encoded by more than one distinct sequence
    405415of bytes. */
    406416
    407 /*
    408  *@@ XML_Encoding:
    409  *      structure passed with the UnknownEncodingHandler (see
    410  *      XML_SetUnknownEncodingHandler).
    411  *
    412  *      The map array contains information for every possible
    413  *      possible leading byte in a byte sequence.
    414  *
    415  *      --  If the corresponding value is >= 0, then it's a single byte
    416  *          sequence and the byte encodes that Unicode value.
    417  *
    418  *      --  If the value is -1, then that byte is invalid as the
    419  *          initial byte in a sequence.
    420  *
    421  *      --  If the value is -2, -3, or -4, then the byte is the beginning
    422  *          of a 2, 3, or 4 byte sequence, respectively. The actual
    423  *          conversion is then accomplished by a call to the function
    424  *          pointed at by "convert". This function should return the
    425  *          Unicode scalar value for the sequence or -1 if the sequence
    426  *          is malformed.
    427  *
    428  *          The "convert" pointer may be null if there are only
    429  *          single byte codes. The data parameter passed to the
    430  *          convert function is the data pointer from
    431  *          XML_Encoding. The string s is NOT null terminated and
    432  *          points at the sequence of bytes to be converted.
    433  *
    434  *      The function pointed at by "release" is called by the parser
    435  *      when it is finished with the encoding. It may be null.
    436  */
    437 
    438 typedef struct _XML_Encoding
    439 {
    440   int           map[256];
    441   void          *data;
    442   int           (* EXPATENTRY convert)(void *data, const char *s);
    443   void          (* EXPATENTRY release)(void *data);
     417typedef struct {
     418  int map[256];
     419  void *data;
     420  int (*convert)(void *data, const char *s);
     421  void (*release)(void *data);
    444422} XML_Encoding;
    445423
    446 typedef int (* EXPATENTRY XML_UnknownEncodingHandler)(void *encodingHandlerData,
    447                                                       const XML_Char *name,
    448                                                       XML_Encoding *info);
    449 
    450 void XMLPARSEAPI XML_SetElementHandler(XML_Parser parser,
    451                                        XML_StartElementHandler start,
    452                                        XML_EndElementHandler end);
    453 
    454 void XMLPARSEAPI XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
    455 
    456 void XMLPARSEAPI XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
    457 
    458 void XMLPARSEAPI XML_SetCharacterDataHandler(XML_Parser parser,
    459                                              XML_CharacterDataHandler handler);
    460 
    461 void XMLPARSEAPI XML_SetProcessingInstructionHandler(XML_Parser parser,
    462                                                      XML_ProcessingInstructionHandler handler);
    463 void XMLPARSEAPI XML_SetCommentHandler(XML_Parser parser,
    464                                        XML_CommentHandler handler);
    465 
    466 void XMLPARSEAPI XML_SetCdataSectionHandler(XML_Parser parser,
    467                                             XML_StartCdataSectionHandler start,
    468                                             XML_EndCdataSectionHandler end);
    469 
    470 void XMLPARSEAPI XML_SetStartCdataSectionHandler(XML_Parser parser,
     424/* This is called for an encoding that is unknown to the parser.
     425The encodingHandlerData argument is that which was passed as the
     426second argument to XML_SetUnknownEncodingHandler.
     427The name argument gives the name of the encoding as specified in
     428the encoding declaration.
     429If the callback can provide information about the encoding,
     430it must fill in the XML_Encoding structure, and return 1.
     431Otherwise it must return 0.
     432If info does not describe a suitable encoding,
     433then the parser will return an XML_UNKNOWN_ENCODING error. */
     434
     435typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
     436                                          const XML_Char *name,
     437                                          XML_Encoding *info);
     438
     439XMLPARSEAPI(void)
     440XML_SetElementHandler(XML_Parser parser,
     441              XML_StartElementHandler start,
     442              XML_EndElementHandler end);
     443
     444XMLPARSEAPI(void)
     445XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
     446
     447XMLPARSEAPI(void)
     448XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
     449
     450XMLPARSEAPI(void)
     451XML_SetCharacterDataHandler(XML_Parser parser,
     452                XML_CharacterDataHandler handler);
     453
     454XMLPARSEAPI(void)
     455XML_SetProcessingInstructionHandler(XML_Parser parser,
     456                    XML_ProcessingInstructionHandler handler);
     457XMLPARSEAPI(void)
     458XML_SetCommentHandler(XML_Parser parser,
     459                      XML_CommentHandler handler);
     460
     461XMLPARSEAPI(void)
     462XML_SetCdataSectionHandler(XML_Parser parser,
     463               XML_StartCdataSectionHandler start,
     464               XML_EndCdataSectionHandler end);
     465
     466XMLPARSEAPI(void)
     467XML_SetStartCdataSectionHandler(XML_Parser parser,
    471468                                XML_StartCdataSectionHandler start);
    472469
    473 void XMLPARSEAPI XML_SetEndCdataSectionHandler(XML_Parser parser,
     470XMLPARSEAPI(void)
     471XML_SetEndCdataSectionHandler(XML_Parser parser,
    474472                              XML_EndCdataSectionHandler end);
    475473
    476 /* This sets the default handler and also inhibits expansion of internal entities.
    477 The entity reference will be passed to the default handler. */
    478 
    479 void XMLPARSEAPI XML_SetDefaultHandler(XML_Parser parser,
     474/* This sets the default handler and also inhibits expansion of
     475internal entities.  The entity reference will be passed to the default
     476handler. */
     477
     478XMLPARSEAPI(void)
     479XML_SetDefaultHandler(XML_Parser parser,
    480480              XML_DefaultHandler handler);
    481481
    482 /* This sets the default handler but does not inhibit expansion of internal entities.
    483 The entity reference will not be passed to the default handler. */
    484 
    485 void XMLPARSEAPI XML_SetDefaultHandlerExpand(XML_Parser parser,
     482/* This sets the default handler but does not inhibit expansion of
     483internal entities.  The entity reference will not be passed to the
     484default handler. */
     485
     486XMLPARSEAPI(void)
     487XML_SetDefaultHandlerExpand(XML_Parser parser,
    486488                    XML_DefaultHandler handler);
    487489
    488 void XMLPARSEAPI XML_SetDoctypeDeclHandler(XML_Parser parser,
     490XMLPARSEAPI(void)
     491XML_SetDoctypeDeclHandler(XML_Parser parser,
    489492              XML_StartDoctypeDeclHandler start,
    490493              XML_EndDoctypeDeclHandler end);
    491494
    492 void XMLPARSEAPI XML_SetStartDoctypeDeclHandler(XML_Parser parser,
     495XMLPARSEAPI(void)
     496XML_SetStartDoctypeDeclHandler(XML_Parser parser,
    493497                   XML_StartDoctypeDeclHandler start);
    494498
    495 void XMLPARSEAPI XML_SetEndDoctypeDeclHandler(XML_Parser parser,
     499XMLPARSEAPI(void)
     500XML_SetEndDoctypeDeclHandler(XML_Parser parser,
    496501                 XML_EndDoctypeDeclHandler end);
    497502
    498 void XMLPARSEAPI XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
     503XMLPARSEAPI(void)
     504XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
    499505                 XML_UnparsedEntityDeclHandler handler);
    500506
    501 void XMLPARSEAPI XML_SetNotationDeclHandler(XML_Parser parser,
     507XMLPARSEAPI(void)
     508XML_SetNotationDeclHandler(XML_Parser parser,
    502509               XML_NotationDeclHandler handler);
    503510
    504 void XMLPARSEAPI XML_SetNamespaceDeclHandler(XML_Parser parser,
     511XMLPARSEAPI(void)
     512XML_SetNamespaceDeclHandler(XML_Parser parser,
    505513                XML_StartNamespaceDeclHandler start,
    506514                XML_EndNamespaceDeclHandler end);
    507515
    508 void XMLPARSEAPI XML_SetStartNamespaceDeclHandler(XML_Parser parser,
     516XMLPARSEAPI(void)
     517XML_SetStartNamespaceDeclHandler(XML_Parser parser,
    509518                 XML_StartNamespaceDeclHandler start);
    510519
    511 void XMLPARSEAPI XML_SetEndNamespaceDeclHandler(XML_Parser parser,
     520XMLPARSEAPI(void)
     521XML_SetEndNamespaceDeclHandler(XML_Parser parser,
    512522                   XML_EndNamespaceDeclHandler end);
    513523
    514 void XMLPARSEAPI XML_SetNotStandaloneHandler(XML_Parser parser,
     524XMLPARSEAPI(void)
     525XML_SetNotStandaloneHandler(XML_Parser parser,
    515526                XML_NotStandaloneHandler handler);
    516527
    517 void XMLPARSEAPI XML_SetExternalEntityRefHandler(XML_Parser parser,
     528XMLPARSEAPI(void)
     529XML_SetExternalEntityRefHandler(XML_Parser parser,
    518530                XML_ExternalEntityRefHandler handler);
    519531
    … …  
    521533as the first argument to the external entity ref handler instead
    522534of the parser object. */
    523 void XMLPARSEAPI XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
    524 
    525 void XMLPARSEAPI XML_SetUnknownEncodingHandler(XML_Parser parser,
     535XMLPARSEAPI(void)
     536XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);
     537
     538XMLPARSEAPI(void)
     539XML_SetUnknownEncodingHandler(XML_Parser parser,
    526540                  XML_UnknownEncodingHandler handler,
    527541                  void *encodingHandlerData);
    … …  
    530544processing instruction or character data.  It causes the corresponding
    531545markup to be passed to the default handler. */
    532 void  XML_DefaultCurrent(XML_Parser parser);
     546XMLPARSEAPI(void)
     547XML_DefaultCurrent(XML_Parser parser);
    533548
    534549/* If do_nst is non-zero, and namespace processing is in effect, and
    … …  
    543558*/
    544559
    545 void XMLPARSEAPI XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
     560XMLPARSEAPI(void)
     561XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
    546562
    547563/* This value is passed as the userData argument to callbacks. */
    548 void XMLPARSEAPI XML_SetUserData(XML_Parser parser, void *userData);
     564XMLPARSEAPI(void)
     565XML_SetUserData(XML_Parser parser, void *userData);
    549566
    550567/* Returns the last value set by XML_SetUserData or null. */
    … …  
    555572or XML_ParseBuffer. */
    556573
    557 int XMLPARSEAPI XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
     574XMLPARSEAPI(int)
     575XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
    558576
    559577/* If this function is called, then the parser will be passed
    … …  
    561579The userData will still be accessible using XML_GetUserData. */
    562580
    563 void XMLPARSEAPI XML_UseParserAsHandlerArg(XML_Parser parser);
    564 
    565 /* Sets the base to be used for resolving relative URIs in system identifiers in
    566 declarations.  Resolving relative identifiers is left to the application:
    567 this value will be passed through as the base argument to the
    568 XML_ExternalEntityRefHandler, XML_NotationDeclHandler
     581XMLPARSEAPI(void)
     582XML_UseParserAsHandlerArg(XML_Parser parser);
     583
     584/* Sets the base to be used for resolving relative URIs in system
     585identifiers in declarations.  Resolving relative identifiers is left
     586to the application: this value will be passed through as the base
     587argument to the XML_ExternalEntityRefHandler, XML_NotationDeclHandler
    569588and XML_UnparsedEntityDeclHandler. The base argument will be copied.
    570589Returns zero if out of memory, non-zero otherwise. */
    571590
    572 int XMLPARSEAPI XML_SetBase(XML_Parser parser, const XML_Char *base);
    573 
    574 const XML_Char  XMLPARSEAPI * XML_GetBase(XML_Parser parser);
     591XMLPARSEAPI(int)
     592XML_SetBase(XML_Parser parser, const XML_Char *base);
     593
     594XMLPARSEAPI(const XML_Char *)
     595XML_GetBase(XML_Parser parser);
    575596
    576597/* Returns the number of the attribute/value pairs passed in last call
    … …  
    580601XML_StartElementHandler. */
    581602
    582 int XMLPARSEAPI XML_GetSpecifiedAttributeCount(XML_Parser parser);
     603XMLPARSEAPI(int)
     604XML_GetSpecifiedAttributeCount(XML_Parser parser);
    583605
    584606/* Returns the index of the ID attribute passed in the last call to
    … …  
    587609into the atts array passed to the XML_StartElementHandler. */
    588610
    589 int XMLPARSEAPI XML_GetIdAttributeIndex(XML_Parser parser);
     611XMLPARSEAPI(int)
     612XML_GetIdAttributeIndex(XML_Parser parser);
    590613
    591614/* Parses some input. Returns 0 if a fatal error is detected.
    592615The last call to XML_Parse must have isFinal true;
    593616len may be zero for this call (or any other). */
    594 int XMLPARSEAPI XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
    595 
    596 void XMLPARSEAPI * XML_GetBuffer(XML_Parser parser, int len);
    597 
    598 int XMLPARSEAPI XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
    599 
    600 /* Creates an XML_Parser object that can parse an external general entity;
    601 context is a '\0'-terminated string specifying the parse context;
    602 encoding is a '\0'-terminated string giving the name of the externally specified encoding,
    603 or null if there is no externally specified encoding.
    604 The context string consists of a sequence of tokens separated by formfeeds (\f);
    605 a token consisting of a name specifies that the general entity of the name
    606 is open; a token of the form prefix=uri specifies the namespace for a particular
    607 prefix; a token of the form =uri specifies the default namespace.
    608 This can be called at any point after the first call to an ExternalEntityRefHandler
    609 so longer as the parser has not yet been freed.
    610 The new parser is completely independent and may safely be used in a separate thread.
    611 The handlers and userData are initialized from the parser argument.
    612 Returns 0 if out of memory.  Otherwise returns a new XML_Parser object. */
    613 XML_Parser XMLPARSEAPI XML_ExternalEntityParserCreate(XML_Parser parser,
     617XMLPARSEAPI(int)
     618XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
     619
     620XMLPARSEAPI(void *)
     621XML_GetBuffer(XML_Parser parser, int len);
     622
     623XMLPARSEAPI(int)
     624XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
     625
     626/* Creates an XML_Parser object that can parse an external general
     627entity; context is a '\0'-terminated string specifying the parse
     628context; encoding is a '\0'-terminated string giving the name of the
     629externally specified encoding, or null if there is no externally
     630specified encoding.  The context string consists of a sequence of
     631tokens separated by formfeeds (\f); a token consisting of a name
     632specifies that the general entity of the name is open; a token of the
     633form prefix=uri specifies the namespace for a particular prefix; a
     634token of the form =uri specifies the default namespace.  This can be
     635called at any point after the first call to an
     636ExternalEntityRefHandler so longer as the parser has not yet been
     637freed.  The new parser is completely independent and may safely be
     638used in a separate thread.  The handlers and userData are initialized
     639from the parser argument.  Returns 0 if out of memory.  Otherwise
     640returns a new XML_Parser object. */
     641XMLPARSEAPI(XML_Parser)
     642XML_ExternalEntityParserCreate(XML_Parser parser,
    614643                   const XML_Char *context,
    615644                   const XML_Char *encoding);
    … …  
    621650};
    622651
    623 int XMLPARSEAPI XML_SetParamEntityParsing(XML_Parser parser,
    624                                           enum XML_ParamEntityParsing parsing);
     652/* Controls parsing of parameter entities (including the external DTD
     653subset). If parsing of parameter entities is enabled, then references
     654to external parameter entities (including the external DTD subset)
     655will be passed to the handler set with
     656XML_SetExternalEntityRefHandler.  The context passed will be 0.
     657Unlike external general entities, external parameter entities can only
     658be parsed synchronously.  If the external parameter entity is to be
     659parsed, it must be parsed during the call to the external entity ref
     660handler: the complete sequence of XML_ExternalEntityParserCreate,
     661XML_Parse/XML_ParseBuffer and XML_ParserFree calls must be made during
     662this call.  After XML_ExternalEntityParserCreate has been called to
     663create the parser for the external parameter entity (context must be 0
     664for this call), it is illegal to make any calls on the old parser
     665until XML_ParserFree has been called on the newly created parser.  If
     666the library has been compiled without support for parameter entity
     667parsing (ie without XML_DTD being defined), then
     668XML_SetParamEntityParsing will return 0 if parsing of parameter
     669entities is requested; otherwise it will return non-zero. */
     670
     671XMLPARSEAPI(int)
     672XML_SetParamEntityParsing(XML_Parser parser,
     673              enum XML_ParamEntityParsing parsing);
     674
     675/* XMLERROR {
     676    ERROR_EXPAT_NONE,
     677    ERROR_EXPAT_NO_MEMORY,
     678    ERROR_EXPAT_SYNTAX,
     679    ERROR_EXPAT_NO_ELEMENTS,
     680    ERROR_EXPAT_INVALID_TOKEN,
     681    ERROR_EXPAT_UNCLOSED_TOKEN,
     682    ERROR_EXPAT_PARTIAL_CHAR,
     683    ERROR_EXPAT_TAG_MISMATCH,
     684    ERROR_EXPAT_DUPLICATE_ATTRIBUTE,
     685    ERROR_EXPAT_JUNK_AFTER_DOC_ELEMENT,
     686    ERROR_EXPAT_PARAM_ENTITY_REF,
     687    ERROR_EXPAT_UNDEFINED_ENTITY,
     688    ERROR_EXPAT_RECURSIVE_ENTITY_REF,
     689    ERROR_EXPAT_ASYNC_ENTITY,
     690    ERROR_EXPAT_BAD_CHAR_REF,
     691    ERROR_EXPAT_BINARY_ENTITY_REF,
     692    ERROR_EXPAT_ATTRIBUTE_EXTERNAL_ENTITY_REF,
     693    ERROR_EXPAT_MISPLACED_XML_PI,
     694    ERROR_EXPAT_UNKNOWN_ENCODING,
     695    ERROR_EXPAT_INCORRECT_ENCODING,
     696    ERROR_EXPAT_UNCLOSED_CDATA_SECTION,
     697    ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING,
     698    ERROR_EXPAT_NOT_STANDALONE,
     699    ERROR_EXPAT_UNEXPECTED_STATE
     700}; */
    625701
    626702#define ERROR_XML_FIRST         40000   // first error code used
    … …  
    656732returns information about the error. */
    657733
    658 XMLERROR  XMLPARSEAPI XML_GetErrorCode(XML_Parser parser);
     734XMLPARSEAPI(XMLERROR)
     735XML_GetErrorCode(XML_Parser parser);
    659736
    660737/* These functions return information about the current parse location.
    … …  
    666743of the sequence of characters that generated the event. */
    667744
    668 int XMLPARSEAPI XML_GetCurrentLineNumber(XML_Parser parser);
    669 int XMLPARSEAPI XML_GetCurrentColumnNumber(XML_Parser parser);
    670 long XMLPARSEAPI XML_GetCurrentByteIndex(XML_Parser parser);
     745XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser);
     746XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser);
     747XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser);
    671748
    672749/* Return the number of bytes in the current event.
    673750Returns 0 if the event is in an internal entity. */
    674751
    675 int XMLPARSEAPI XML_GetCurrentByteCount(XML_Parser parser);
     752XMLPARSEAPI(int)
     753XML_GetCurrentByteCount(XML_Parser parser);
    676754
    677755/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
    … …  
    679757   of the current parse position, and sets the integer pointed to by size
    680758   to the size of this buffer (the number of input bytes). Otherwise
    681    returns a null pointer. Also returns a null pointer if a parse isn't active.
     759   returns a null pointer. Also returns a null pointer if a parse isn't
     760   active.
    682761
    683762   NOTE: The character pointer returned should not be used outside
    684763   the handler that makes the call. */
    685764
    686 const char XMLPARSEAPI * XML_GetInputContext(XML_Parser parser,
     765XMLPARSEAPI(const char *)
     766XML_GetInputContext(XML_Parser parser,
    687767            int *offset,
    688768            int *size);
    … …  
    694774
    695775/* Frees memory used by the parser. */
    696 void XMLPARSEAPI XML_ParserFree(XML_Parser parser);
     776XMLPARSEAPI(void)
     777XML_ParserFree(XML_Parser parser);
    697778
    698779/* Returns a string describing the error. */
    699 // const XML_LChar XMLPARSEAPI * XML_ErrorString(int code);
    700         // moved this to xml.c V0.9.9 (2001-02-16) [umoeller]
     780XMLPARSEAPI(const XML_LChar *)
     781XML_ErrorString(int code);
    701782
    702783/* Return a string containing the version number of this expat */
    703 const XML_LChar XMLPARSEAPI *XML_ExpatVersion(void);
     784XMLPARSEAPI(const XML_LChar *)
     785XML_ExpatVersion(void);
     786
     787typedef struct {
     788  int major;
     789  int minor;
     790  int micro;
     791} XML_Expat_Version;
     792
     793/* Return an XML_Expat_Version structure containing numeric version
     794   number information for this version of expat */
     795
     796XMLPARSEAPI(XML_Expat_Version)
     797XML_ExpatVersionInfo(void);
     798
     799#define XML_MAJOR_VERSION @EXPAT_MAJOR_VERSION@
     800#define XML_MINOR_VERSION @EXPAT_MINOR_VERSION@
     801#define XML_MICRO_VERSION @EXPAT_EDIT@
    704802
    705803#ifdef __cplusplus

  • trunk/include/expat/expat_setup.h

    r38 r97  
    2020
    2121    #define XML_DTD 1
     22    #define XML_BYTE_ORDER 12
     23    #define XML_CONTEXT_BYTES 1024
    2224
    2325#endif

  • trunk/include/expat/xmlrole.h

    r38 r97  
    66#ifndef XmlRole_INCLUDED
    77#define XmlRole_INCLUDED 1
    8 
    9 #include "expat\expat_setup.h"
    10                         // V0.9.9 (2001-02-10) [umoeller]
    11                         // to save the app from having to include this as well
    128
    139#include "expat\xmltok.h"
    … …  
    7874
    7975typedef struct prolog_state {
    80   int (* EXPATENTRY handler)(struct prolog_state *state,
    81                            int tok,
    82                            const char *ptr,
    83                            const char *end,
    84                            const ENCODING *enc);
     76  int (*handler)(struct prolog_state *state,
     77             int tok,
     78         const char *ptr,
     79         const char *end,
     80         const ENCODING *enc);
    8581  unsigned level;
    8682#ifdef XML_DTD

  • trunk/include/expat/xmltok.h

    r38 r97  
    66#ifndef XmlTok_INCLUDED
    77#define XmlTok_INCLUDED 1
    8 
    9 #include "expat\expat_setup.h"
    10                         // V0.9.9 (2001-02-10) [umoeller]
    11                         // to save the app from having to include this as well
    128
    139#ifdef __cplusplus
    … …  
    2117#define XML_TOK_NONE -4    /* The string to be scanned is empty */
    2218#define XML_TOK_TRAILING_CR -3 /* A CR at the end of the scan;
    23                                   might be part of CRLF sequence */
     19                                  might be part of CRLF sequence */ 
    2420#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
    2521#define XML_TOK_PARTIAL -1 /* only part of a token */
    … …  
    116112} POSITION;
    117113
    118 typedef struct
    119 {
    120      const char *name;
    121      const char *valuePtr;
    122      const char *valueEnd;
    123      char normalized;
    124 } ATTRIBUTE, *PATTRIBUTE;
     114typedef struct {
     115  const char *name;
     116  const char *valuePtr;
     117  const char *valueEnd;
     118  char normalized;
     119} ATTRIBUTE;
    125120
    126121struct encoding;
    127 typedef struct encoding ENCODING, *PENCODING;
    128 
    129 typedef int EXPATENTRY SCANNERFUNC(const ENCODING *,
    130                                    const char *,
    131                                    const char *,
    132                                    const char **);
    133 typedef SCANNERFUNC *PSCANNERFUNC;
    134 
    135 struct encoding
    136 {
    137   PSCANNERFUNC      scanners[XML_N_STATES];
    138   PSCANNERFUNC      literalScanners[XML_N_LITERAL_TYPES];
    139   int (* EXPATENTRY sameName)(const ENCODING *,
    140                   const char *,
    141                   const char *);
    142   int (* EXPATENTRY nameMatchesAscii)(const ENCODING *,
    143                           const char *,
    144                           const char *,
    145                           const char *);
    146   int (* EXPATENTRY nameLength)(const ENCODING *,
    147                     const char *);
    148   const char *(*skipS)(const ENCODING *,
    149                        const char *);
    150   int (* EXPATENTRY getAtts)(const ENCODING *enc,
    151                  const char *ptr,
    152                  int attsMax,
    153                  ATTRIBUTE *atts);
    154   int (* EXPATENTRY charRefNumber)(const ENCODING *enc,
    155                        const char *ptr);
    156   int (* EXPATENTRY predefinedEntityName)(const ENCODING *,
    157                               const char *,
    158                               const char *);
    159   void (* EXPATENTRY updatePosition)(const ENCODING *,
    160                                      const char *ptr,
    161                                      const char *end,
    162                                      POSITION *);
    163   int (* EXPATENTRY isPublicId)(const ENCODING *enc,
    164                     const char *ptr,
    165                     const char *end,
    166                     const char **badPtr);
    167   void (* EXPATENTRY utf8Convert)(const ENCODING *enc,
    168                       const char **fromP,
    169                       const char *fromLim,
    170                       char **toP,
    171                       const char *toLim);
    172   void (* EXPATENTRY utf16Convert)(const ENCODING *enc,
    173                        const char **fromP,
    174                        const char *fromLim,
    175                        unsigned short **toP,
    176                        const unsigned short *toLim);
     122typedef struct encoding ENCODING;
     123
     124struct encoding {
     125  int (*scanners[XML_N_STATES])(const ENCODING *,
     126                                const char *,
     127                                const char *,
     128                                const char **);
     129  int (*literalScanners[XML_N_LITERAL_TYPES])(const ENCODING *,
     130                                              const char *,
     131                                              const char *,
     132                                              const char **);
     133  int (*sameName)(const ENCODING *,
     134                  const char *, const char *);
     135  int (*nameMatchesAscii)(const ENCODING *,
     136                          const char *, const char *, const char *);
     137  int (*nameLength)(const ENCODING *, const char *);
     138  const char *(*skipS)(const ENCODING *, const char *);
     139  int (*getAtts)(const ENCODING *enc, const char *ptr,
     140                 int attsMax, ATTRIBUTE *atts);
     141  int (*charRefNumber)(const ENCODING *enc, const char *ptr);
     142  int (*predefinedEntityName)(const ENCODING *, const char *, const char *);
     143  void (*updatePosition)(const ENCODING *,
     144                         const char *ptr,
     145                         const char *end,
     146                         POSITION *);
     147  int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
     148                    const char **badPtr);
     149  void (*utf8Convert)(const ENCODING *enc,
     150                      const char **fromP,
     151                      const char *fromLim,
     152                      char **toP,
     153                      const char *toLim);
     154  void (*utf16Convert)(const ENCODING *enc,
     155                       const char **fromP,
     156                       const char *fromLim,
     157                       unsigned short **toP,
     158                       const unsigned short *toLim);
    177159  int minBytesPerChar;
    178160  char isUtf8;
    … …  
    221203
    222204/* This is used for performing a 2nd-level tokenization on
    223 the content of a literal that has already been returned by XmlTok. */
     205the content of a literal that has already been returned by XmlTok. */ 
    224206
    225207#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
    … …  
    270252
    271253int  XmlParseXmlDecl(int isGeneralTextEntity,
    272                   const ENCODING *enc,
    273                   const char *ptr,
    274                   const char *end,
    275                   const char **badPtr,
    276                   const char **versionPtr,
    277                   const char **versionEndPtr,
    278                   const char **encodingNamePtr,
    279                   const ENCODING **namedEncodingPtr,
    280                   int *standalonePtr);
     254                              const ENCODING *enc,
     255                              const char *ptr,
     256                              const char *end,
     257                              const char **badPtr,
     258                              const char **versionPtr,
     259                              const char **versionEndPtr,
     260                              const char **encodingNamePtr,
     261                              const ENCODING **namedEncodingPtr,
     262                              int *standalonePtr);
    281263
    282264int  XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
    … …  
    289271ENCODING  *
    290272XmlInitUnknownEncoding(void *mem,
    291                int *table,
    292                int (*conv)(void *userData, const char *p),
    293                void *userData);
     273                       int *table,
     274                       int (*conv)(void *userData, const char *p),
     275                       void *userData);
    294276
    295277int  XmlParseXmlDeclNS(int isGeneralTextEntity,
    296                     const ENCODING *enc,
    297                     const char *ptr,
    298                     const char *end,
    299                     const char **badPtr,
    300                     const char **versionPtr,
    301                 const char **versionEndPtr,
    302                     const char **encodingNamePtr,
    303                     const ENCODING **namedEncodingPtr,
    304                     int *standalonePtr);
     278                                const ENCODING *enc,
     279                                const char *ptr,
     280                                const char *end,
     281                                const char **badPtr,
     282                                const char **versionPtr,
     283                                const char **versionEndPtr,
     284                                const char **encodingNamePtr,
     285                                const ENCODING **namedEncodingPtr,
     286                                int *standalonePtr);
    305287int  XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
    306288const ENCODING  *XmlGetUtf8InternalEncodingNS(void);
    … …  
    308290ENCODING  *
    309291XmlInitUnknownEncodingNS(void *mem,
    310                  int *table,
    311                  int (*conv)(void *userData, const char *p),
    312                  void *userData);
     292                         int *table,
     293                         int (*conv)(void *userData, const char *p),
     294                         void *userData);
    313295#ifdef __cplusplus
    314296}

  • trunk/include/helpers/xml.h

    r84 r97  
    8585    #define ERROR_DOM_DUPLICATE_ATTRIBUTE (ERROR_XML_FIRST + 43)
    8686
    87         // @@@todo these
    8887    #define ERROR_DOM_VALIDATE_INVALID_ELEMENT (ERROR_XML_FIRST + 44)
    8988    #define ERROR_DOM_ELEMENT_DECL_OUTSIDE_DOCTYPE (ERROR_XML_FIRST + 45)
    9089    #define ERROR_DOM_ATTLIST_DECL_OUTSIDE_DOCTYPE (ERROR_XML_FIRST + 46)
     90
     91    #define ERROR_DOM_INCOMPLETE_ENCODING_MAP (ERROR_XML_FIRST + 47)
     92                // callback to UnknownEncodingHandler has provided
     93                // an incomplete encoding map V0.9.14 (2001-08-09) [umoeller]
     94
     95    #define ERROR_DOM_INVALID_EXTERNAL_HANDLER (ERROR_XML_FIRST + 48)
    9196
    9297    const char* xmlDescribeError(int code);
    … …  
    619624     ********************************************************************/
    620625
     626    typedef struct _XMLDOM *PXMLDOM;
     627
     628    typedef int APIENTRY FNGETCPDATA(PXMLDOM pDom, ULONG ulCP, int *piMap);
     629    typedef FNGETCPDATA *PFNGETCPDATA;
     630
     631    typedef APIRET APIENTRY FNEXTERNALHANDLER(PXMLDOM pDom,
     632                                              XML_Parser *pSubParser,
     633                                              const char *pcszSystemID,
     634                                              const char *pcszPublicID);
     635    typedef FNEXTERNALHANDLER *PFNEXTERNALHANDLER;
     636
    621637    /*
    622638     *@@ XMLDOM:
    … …  
    638654                        // != NULL only if the document has a DOCTYPE
    639655
    640         APIRET          arcDOM;         // validation errors etc.
    641         BOOL            fInvalid;       // TRUE after validation failed
    642 
    643         const char      *pcszErrorDescription;
    644         ULONG           ulErrorLine;
    645         ULONG           ulErrorColumn;
    646         PXSTRING        pxstrFailingNode; // element or attribute name
     656        // error handling
     657        APIRET          arcDOM;         // validation errors etc.;
     658                                        // if != 0, this has a detailed
     659                                        // expat or DOM error code
     660        BOOL            fInvalid;       // TRUE if validation failed
     661                                        // (parser error otherwise)
     662
     663        const char      *pcszErrorDescription;  // error description
     664        PXSTRING        pxstrSystemID;      // system ID of external entity
     665                                            // where error occured, or NULL
     666                                            // if in main document
     667        ULONG           ulErrorLine;        // line where error occured
     668        ULONG           ulErrorColumn;      // column where error occured
     669        PXSTRING        pxstrFailingNode;   // element or attribute name
     670                                            // or NULL
    647671
    648672        /*
    … …  
    650674         */
    651675
     676        // params copied from xmlCreateDOM
     677        ULONG           flParserFlags;
     678        PFNGETCPDATA    pfnGetCPData;
     679        PFNEXTERNALHANDLER pfnExternalHandler;
     680        PVOID           pvCallbackUser;
     681
    652682        XML_Parser      pParser;
    653683                            // expat parser instance
    … …  
    662692                            // cache for attribute declarations according
    663693                            // to attdecl element name
    664     } XMLDOM, *PXMLDOM;
     694    } XMLDOM;
    665695
    666696    #define DF_PARSECOMMENTS        0x0001
    667697    #define DF_PARSEDTD             0x0002
    668698    #define DF_FAIL_IF_NO_DTD       0x0004
     699    #define DF_DROP_WHITESPACE      0x0008
    669700
    670701    APIRET xmlCreateDOM(ULONG flParserFlags,
     702                        PFNGETCPDATA pfnGetCPData,
     703                        PFNEXTERNALHANDLER pfnExternalHandler,
     704                        PVOID pvCallbackUser,
    671705                        PXMLDOM *ppDom);
    672706

  • trunk/src/helpers/encodings.c

    r63 r97  
    127127}
    128128
    129 
     129/*
     130 *@@ encDecodeUTF8:
     131 *      decodes one UTF-8 character and returns
     132 *      the Unicode value or -1 if the character
     133 *      is invalid.
     134 *
     135 *      On input, *ppch is assumed to point to
     136 *      the first byte of the UTF-8 char to be
     137 *      read.
     138 *
     139 *      This function will advance *ppch by at
     140 *      least one byte (or more if the UTF-8
     141 *      char initially pointed to introduces
     142 *      a multi-byte sequence).
     143 *
     144 *      This returns -1 if *ppch points to an
     145 *      invalid encoding (in which case the
     146 *      pointer is advanced anyway).
     147 *
     148 *      This returns 0 if **ppch points to a
     149 *      null character.
     150 *
     151 *@@added V0.9.14 (2001-08-09) [umoeller]
     152 */
     153
     154unsigned long encDecodeUTF8(const char **ppch)
     155{
     156    unsigned long   ulChar = **ppch;
     157
     158    if (!ulChar)
     159        return 0;
     160
     161    // if (ulChar < 0x80): simple, one byte only... use that
     162
     163    if (ulChar >= 0x80)
     164    {
     165        unsigned long ulCount = 1;
     166        int fIllegal = 0;
     167
     168        // note: 0xc0 and 0xc1 are reserved and
     169        // cannot appear as the first UTF-8 byte
     170
     171        if (    (ulChar >= 0xc2)
     172             && (ulChar < 0xe0)
     173           )
     174        {
     175            // that's two bytes
     176            ulCount = 2;
     177            ulChar &= 0x1f;
     178        }
     179        else if ((ulChar & 0xf0) == 0xe0)
     180        {
     181            // three bytes
     182            ulCount = 3;
     183            ulChar &= 0x0f;
     184        }
     185        else if ((ulChar & 0xf8) == 0xf0)
     186        {
     187            // four bytes
     188            ulCount = 4;
     189            ulChar &= 0x07;
     190        }
     191        else if ((ulChar & 0xfc) == 0xf8)
     192        {
     193            // five bytes
     194            ulCount = 5;
     195            ulChar &= 0x03;
     196        }
     197        else if ((ulChar & 0xfe) == 0xfc)
     198        {
     199            // six bytes
     200            ulCount = 6;
     201            ulChar &= 0x01;
     202        }
     203        else
     204            ++fIllegal;
     205
     206        if (!fIllegal)
     207        {
     208            // go for the second and more bytes then
     209            int ul2;
     210
     211            for (ul2 = 1;
     212                 ul2 < ulCount;
     213                 ++ul2)
     214            {
     215                unsigned long ulChar2 = *((*ppch) + ul2);
     216
     217                if (!(ulChar2 & 0xc0)) //  != 0x80)
     218                {
     219                    ++fIllegal;
     220                    break;
     221                }
     222
     223                ulChar <<= 6;
     224                ulChar |= ulChar2 & 0x3f;
     225            }
     226        }
     227
     228        if (fIllegal)
     229        {
     230            // skip all the following characters
     231            // until we find something with bit 7 off
     232            do
     233            {
     234                ulChar = *(++(*ppch));
     235                if (!ulChar)
     236                    break;
     237            } while (ulChar & 0x80);
     238        }
     239        else
     240            *ppch += ulCount;
     241    }
     242    else
     243        (*ppch)++;
     244
     245    return (ulChar);
     246}
     247

  • trunk/src/helpers/xml.c

    r91 r97  
    136136
    137137#include "helpers\linklist.h"
     138#include "helpers\standards.h"
    138139#include "helpers\stringh.h"
    139140#include "helpers\tree.h"
    … …  
    171172const char* xmlDescribeError(int code)
    172173{
    173     static const char *message[] =
     174    switch (code)
    174175    {
    175176        // start of expat (parser) errors
    176         "Out of memory",
    177         "Syntax error",
    178         "No element found",
    179         "Not well-formed (invalid token)",
    180         "Unclosed token",
    181         "Unclosed token",
    182         "Mismatched tag",
    183         "Duplicate attribute",
    184         "Junk after root element",
    185         "Illegal parameter entity reference",
    186         "Undefined entity",
    187         "Recursive entity reference",
    188         "Asynchronous entity",
    189         "Reference to invalid character number",
    190         "Reference to binary entity",
    191         "Reference to external entity in attribute",
    192         "XML processing instruction not at start of external entity",
    193         "Unknown encoding",
    194         "Encoding specified in XML declaration is incorrect",
    195         "Unclosed CDATA section",
    196         "Error in processing external entity reference",
    197         "Document is not standalone",
    198         "Unexpected parser state - please send a bug report",
     177        case ERROR_EXPAT_NO_MEMORY:
     178            return ("Out of memory");
     179
     180        case ERROR_EXPAT_SYNTAX:
     181            return ("Syntax error");
     182        case ERROR_EXPAT_NO_ELEMENTS:
     183            return ("No element found");
     184        case ERROR_EXPAT_INVALID_TOKEN:
     185            return ("Not well-formed (invalid token)");
     186        case ERROR_EXPAT_UNCLOSED_TOKEN:
     187            return ("Unclosed token");
     188        case ERROR_EXPAT_PARTIAL_CHAR:
     189            return ("Unclosed token");
     190        case ERROR_EXPAT_TAG_MISMATCH:
     191            return ("Mismatched tag");
     192        case ERROR_EXPAT_DUPLICATE_ATTRIBUTE:
     193            return ("Duplicate attribute");
     194        case ERROR_EXPAT_JUNK_AFTER_DOC_ELEMENT:
     195            return ("Junk after root element");
     196        case ERROR_EXPAT_PARAM_ENTITY_REF:
     197            return ("Illegal parameter entity reference");
     198        case ERROR_EXPAT_UNDEFINED_ENTITY:
     199            return ("Undefined entity");
     200        case ERROR_EXPAT_RECURSIVE_ENTITY_REF:
     201            return ("Recursive entity reference");
     202        case ERROR_EXPAT_ASYNC_ENTITY:
     203            return ("Asynchronous entity");
     204        case ERROR_EXPAT_BAD_CHAR_REF:
     205            return ("Reference to invalid character number");
     206        case ERROR_EXPAT_BINARY_ENTITY_REF:
     207            return ("Reference to binary entity");
     208        case ERROR_EXPAT_ATTRIBUTE_EXTERNAL_ENTITY_REF:
     209            return ("Reference to external entity in attribute");
     210        case ERROR_EXPAT_MISPLACED_XML_PI:
     211            return ("XML processing instruction not at start of external entity");
     212        case ERROR_EXPAT_UNKNOWN_ENCODING:
     213            return ("Unknown encoding");
     214        case ERROR_EXPAT_INCORRECT_ENCODING:
     215            return ("Encoding specified in XML declaration is incorrect");
     216        case ERROR_EXPAT_UNCLOSED_CDATA_SECTION:
     217            return ("Unclosed CDATA section");
     218        case ERROR_EXPAT_EXTERNAL_ENTITY_HANDLING:
     219            return ("Error in processing external entity reference");
     220        case ERROR_EXPAT_NOT_STANDALONE:
     221            return ("Document is not standalone");
     222        case ERROR_EXPAT_UNEXPECTED_STATE:
     223            return ("Unexpected parser state - please send a bug report");
    199224        // end of expat (parser) errors
    200225
    201226        // start of validation errors
    202         "Element has not been declared",
    203         "Root element name does not match DOCTYPE name",
    204         "Invalid or duplicate root element",
    205         "Invalid sub-element in parent element",
    206         "Duplicate element declaration",
    207         "Duplicate attribute declaration",
    208         "Undeclared attribute in element",
    209         "Element cannot have content",
    210         "Invalid attribute value",
    211         "Required attribute is missing",
    212         "Subelement in empty element",
    213 
    214         "Parsing error",
    215         "Validity error",
    216 
    217         "DOM node type not supported",
    218         "No DOM document",
    219         "No DOM element",
    220         "Duplicate doctype",
    221         "Root element doesn't match doctype name",
    222         "DOM integrity error",
    223         "Duplicate attribute",
    224 
    225         "Validation error: Undeclared element name",
    226         "Element declaration outside doctype",
    227         "Attlist declaration outside doctype"
    228     };
    229 
    230     int code2 = code - ERROR_XML_FIRST;
    231 
    232     if (    code2 >= 0
    233          && code2 < sizeof(message) / sizeof(message[0])
    234        )
    235         return message[code2];
    236 
    237     return 0;
     227
     228        case ERROR_DOM_UNDECLARED_ELEMENT:
     229            return ("Element has not been declared");
     230        case ERROR_DOM_ROOT_ELEMENT_MISNAMED:
     231            return ("Root element name does not match DOCTYPE name");
     232        case ERROR_DOM_INVALID_ROOT_ELEMENT:
     233            return ("Invalid or duplicate root element");
     234
     235        case ERROR_DOM_INVALID_SUBELEMENT:
     236            return ("Invalid sub-element in parent element");
     237        case ERROR_DOM_DUPLICATE_ELEMENT_DECL:
     238            return ("Duplicate element declaration");
     239        case ERROR_DOM_DUPLICATE_ATTRIBUTE_DECL:
     240            return ("Duplicate attribute declaration");
     241        case ERROR_DOM_UNDECLARED_ATTRIBUTE:
     242            return ("Undeclared attribute in element");
     243        case ERROR_ELEMENT_CANNOT_HAVE_CONTENT:
     244            return ("Element cannot have content");
     245        case ERROR_DOM_INVALID_ATTRIB_VALUE:
     246            return ("Invalid attribute value");
     247        case ERROR_DOM_REQUIRED_ATTRIBUTE_MISSING:
     248            return ("Required attribute is missing");
     249        case ERROR_DOM_SUBELEMENT_IN_EMPTY_ELEMENT:
     250            return ("Subelement in empty element");
     251
     252        case ERROR_DOM_PARSING:
     253            return ("Parsing error");
     254        case ERROR_DOM_VALIDITY:
     255            return ("Validity error");
     256
     257        case ERROR_DOM_NODETYPE_NOT_SUPPORTED:
     258            return ("DOM node type not supported");
     259        case ERROR_DOM_NO_DOCUMENT:
     260            return ("No DOM document");
     261        case ERROR_DOM_NO_ELEMENT:
     262            return ("No DOM element");
     263        case ERROR_DOM_DUPLICATE_DOCTYPE:
     264            return ("Duplicate doctype");
     265        case ERROR_DOM_DOCTYPE_ROOT_NAMES_MISMATCH:
     266            return ("Root element doesn't match doctype name");
     267        case ERROR_DOM_INTEGRITY:
     268            return ("DOM integrity error");
     269        case ERROR_DOM_DUPLICATE_ATTRIBUTE:
     270            return ("Duplicate attribute");
     271
     272        case ERROR_DOM_VALIDATE_INVALID_ELEMENT:
     273            return ("Validation error: Undeclared element name");
     274        case ERROR_DOM_ELEMENT_DECL_OUTSIDE_DOCTYPE:
     275            return ("Element declaration outside doctype");
     276        case ERROR_DOM_ATTLIST_DECL_OUTSIDE_DOCTYPE:
     277            return ("Attlist declaration outside doctype");
     278    }
     279
     280    return NULL;
    238281}
    239282
    … …  
    291334 *
    292335 *@@added V0.9.9 (2001-02-16) [umoeller]
     336 *@@changed V0.9.14 (2001-08-09) [umoeller]: fixed map bug which caused the whole XML stuff to fail
    293337 */
    294338
    … …  
    297341{
    298342    return (strhcmp(((PXSTRING)ul1)->psz,
    299                     ((PXSTRING)ul1)->psz));
     343                    ((PXSTRING)ul2)->psz));
    300344}
    301345
    … …  
    354398 *
    355399 *@@added V0.9.9 (2001-02-16) [umoeller]
     400 *@@changed V0.9.14 (2001-08-09) [umoeller]: fixed crash on string delete
    356401 */
    357402
    … …  
    501546        lstClear(&llDeleteNodes);
    502547
    503         xstrFree(((PXSTRING*)&pNode->Tree.ulKey));
     548        xstrClear(&pNode->strNodeName);
    504549        free(pNode);
    505550    }
    … …  
    557602    }
    558603
    559     arc = xmlCreateNodeBase(ulNodeType,
    560                             cb,
    561                             pcszNodeName,
    562                             ulNodeNameLength,
    563                             (PNODEBASE*)&pNewNode);
    564     if (arc == NO_ERROR)
     604    if (!(arc = xmlCreateNodeBase(ulNodeType,
     605                                  cb,
     606                                  pcszNodeName,
     607                                  ulNodeNameLength,
     608                                  (PNODEBASE*)&pNewNode)))
    565609    {
    566610        pNewNode->pParentNode = pParentNode;
    … …  
    635679    PDOMNODE pNew = NULL;
    636680    APIRET arc = xmlCreateDomNode(pParent,
    637                                DOMNODE_ELEMENT,
    638                                pcszElement,
    639                                0,
    640                                &pNew);
     681                                  DOMNODE_ELEMENT,
     682                                  pcszElement,
     683                                  0,
     684                                  &pNew);
    641685
    642686    if (arc == NO_ERROR)
    … …  
    753797    PDOMNODE pNew = NULL;
    754798    APIRET arc = xmlCreateDomNode(pParent,
    755                                DOMNODE_COMMENT,
    756                                NULL,
    757                                0,
    758                                &pNew);
     799                                  DOMNODE_COMMENT,
     800                                  NULL,
     801                                  0,
     802                                  &pNew);
    759803    if (arc == NO_ERROR)
    760804    {
    … …  
    13811425
    13821426/*
     1427 *@@ UnknownEncodingHandler:
     1428 *      @expat handler called when the xml
     1429 *      @text_declaration has an @encoding that is not
     1430 *      one of the four encodings built into expat.
     1431 *
     1432 *      See XML_SetUnknownEncodingHandler.
     1433 *
     1434 *@@added V0.9.14 (2001-08-09) [umoeller]
     1435 */
     1436
     1437int EXPATENTRY UnknownEncodingHandler(void *pUserData,   // in: out PXMLDOM really
     1438                                      const XML_Char *pcszName,
     1439                                      XML_Encoding *pEncoding)
     1440{
     1441    PXMLDOM     pDom = (PXMLDOM)pUserData;
     1442
     1443    ULONG ulCP;
     1444    if (    (pDom->pfnGetCPData)            // callback exists?
     1445         && (!strncmp(pcszName, "cp", 2))
     1446         && (strlen(pcszName) > 4)              // at least five chars (e.g. "cp850")
     1447         && (ulCP = atoi(pcszName + 2))
     1448       )
     1449    {
     1450        // this is a PC codepage:
     1451/* typedef struct _XML_Encoding
     1452{
     1453  int           map[256];
     1454  void          *data;
     1455  int           (* EXPATENTRY convert)(void *data, const char *s);
     1456  void          (* EXPATENTRY release)(void *data);
     1457} XML_Encoding; */
     1458
     1459        // ZERO(pEncoding);
     1460
     1461        pEncoding->convert = NULL;
     1462        pEncoding->release = NULL;
     1463
     1464        memset(&pEncoding->map, -1, sizeof(pEncoding->map));
     1465
     1466        if (pDom->pfnGetCPData(pDom,
     1467                               ulCP,
     1468                               pEncoding->map))
     1469        {
     1470            // go check if there's any -1 chars left
     1471            ULONG ul;
     1472            for (ul = 0;
     1473                 ul < 256;
     1474                 ul++)
     1475            {
     1476                if (pEncoding->map[ul] < 0)
     1477                    xmlSetError(pDom,
     1478                                ERROR_DOM_INCOMPLETE_ENCODING_MAP,
     1479                                NULL,
     1480                                FALSE);
     1481            }
     1482            // return success
     1483            return (1);
     1484        }
     1485    }
     1486
     1487    // error
     1488    return (0);
     1489}
     1490
     1491/*
    13831492 *@@ StartElementHandler:
    13841493 *      @expat handler called when a new element is
    … …  
    14491558                                                          &pAttrib);
    14501559
    1451                     // shall we validate?
    1452                     if (pDom->pDocTypeNode)
    1453                         ValidateAttributeType(pDom,
    1454                                               pAttrib,
    1455                                               &pAttribDeclBase);
     1560                    if (pDom->arcDOM)
     1561                        xmlSetError(pDom,
     1562                                    pDom->arcDOM,
     1563                                    papcszAttribs[i],
     1564                                    TRUE);      // validation
     1565                    else
     1566                        // shall we validate?
     1567                        if (pDom->pDocTypeNode)
     1568                            ValidateAttributeType(pDom,
     1569                                                  pAttrib,
     1570                                                  &pAttribDeclBase);
    14561571                }
    14571572
    … …  
    15241639    if (!pDom->arcDOM)
    15251640    {
    1526         // ULONG       i;
    1527 
    15281641        if (len)
    15291642        {
    … …  
    15351648                PDOMNODE    pParent = pSI->pDomNode;
    15361649                            // pNew = NULL;
     1650
     1651                BOOL fIsWhitespace = FALSE;
    15371652
    15381653                // shall we validate?
    … …  
    15681683                                ULONG ul;
    15691684                                const char *p = s;
     1685
     1686                                if (pDom->flParserFlags & DF_DROP_WHITESPACE)
     1687                                    fIsWhitespace = TRUE;
     1688
    15701689                                for (ul = 0;
    15711690                                     ul < len;
    … …  
    15781697                                                    pParent->NodeBase.strNodeName.psz,
    15791698                                                    TRUE);
     1699                                        fIsWhitespace = FALSE;
    15801700                                        break;
    15811701                                    }
    … …  
    15831703                        }
    15841704                    }
    1585                 }
     1705
     1706                } // end if (pDom->pDocTypeNode)
     1707
     1708                if (!fIsWhitespace)
     1709                    // this is false if any of the following
     1710                    // is true:
     1711                    // --  we are not validating at all
     1712                    // --  we are validating, but the the element
     1713                    //     can have mixed content
     1714                    // --  we are validating and the element does
     1715                    //     _not_ have mixed content and DF_DROP_WHITESPACE
     1716                    //     is set, but the string is whitespace only
     1717                    //     --> drop it then
    15861718
    15871719                if (pDom->pLastWasTextNode)
    … …  
    17751907 *      handler should be prepared to be called recursively.
    17761908 *
    1777  *@@added V0.9.9 (2001-02-14) [umoeller]
    1778  */
    1779 
    1780 int EXPATENTRY ExternalEntityRefHandler(XML_Parser parser,
     1909 *@@added V0.9.14 (2001-08-09) [umoeller]
     1910 */
     1911
     1912int EXPATENTRY ExternalEntityRefHandler(void *pUserData,      // in: our PXMLDOM really
     1913                                        XML_Parser parser,
    17811914                                        const XML_Char *pcszContext,
    17821915                                        const XML_Char *pcszBase,
    … …  
    17841917                                        const XML_Char *pcszPublicId)
    17851918{
    1786     int i = 1;
    1787 
    1788     // @@todo: allow caller to load external references some way
    1789 
    1790     /* PXMLDOM     pDom = (PXMLDOM)pUserData;
    1791 
    1792     // continue parsing only if we had no errors so far
    1793     if (!pDom->arcDOM)
    1794     {
    1795     } */
     1919    PXMLDOM     pDom = (PXMLDOM)pUserData;
     1920
     1921    int i = 0;          // return error per default
     1922
     1923    APIRET  arc = NO_ERROR;
     1924
     1925    // store the previous parser because
     1926    // all the callbacks use the parser pointer
     1927    XML_Parser pOldParser = pDom->pParser;
     1928    pDom->pParser = NULL;
     1929
     1930    if (    (pDom->pfnExternalHandler)
     1931            // create sub-parser and replace the one
     1932            // in the DOM with it
     1933         && (pDom->pParser = XML_ExternalEntityParserCreate(parser,
     1934                                                            pcszContext,
     1935                                                            "US-ASCII"))
     1936       )
     1937    {
     1938        if ((arc = pDom->pfnExternalHandler(pDom,
     1939                                            pDom->pParser,
     1940                                            pcszSystemId,
     1941                                            pcszPublicId)))
     1942        {
     1943            // error:
     1944            // now this needs special handling, since we're
     1945            // dealing with a sub-handler here...
     1946
     1947            if (arc == -1)
     1948                // parser error: well, then xmlSetError has been
     1949                // called from somewhere in the callbacks already,
     1950                // and we can safely ignore this
     1951                ;
     1952            else
     1953            {
     1954                pDom->arcDOM = arc;
     1955                if (pcszSystemId)
     1956                {
     1957                    if (!pDom->pxstrFailingNode)
     1958                        pDom->pxstrFailingNode = xstrCreate(0);
     1959                    xstrcpy(pDom->pxstrFailingNode, pcszSystemId, 0);
     1960                }
     1961                pDom->pcszErrorDescription = xmlDescribeError(arc);
     1962                pDom->ulErrorLine = XML_GetCurrentLineNumber(pDom->pParser);
     1963                pDom->ulErrorColumn = XML_GetCurrentColumnNumber(pDom->pParser);
     1964            }
     1965        }
     1966
     1967        i = 1;      // success
     1968    }
     1969    else
     1970        xmlSetError(pDom,
     1971                    (!arc) ? ERROR_DOM_INVALID_EXTERNAL_HANDLER : arc,
     1972                    NULL,
     1973                    FALSE);
     1974
     1975    if (pDom->pParser)
     1976        XML_ParserFree(pDom->pParser);
     1977
     1978    pDom->pParser = pOldParser;
    17961979
    17971980    return (i);
    … …  
    21252308 *      Pass the XMLDOM returned here to xmlParse afterwards.
    21262309 *
    2127  *      ulFlags is any combination of the following:
    2128  *
    2129  *      --  DF_PARSECOMMENTS: XML @comments are to be returned in
    2130  *          the DOM tree. Otherwise they are silently ignored.
    2131  *
    2132  *      --  DF_PARSEDTD: add the @DTD of the document into the DOM tree
    2133  *          as well and validate the document, if a DTD was found.
    2134  *          Otherwise just parse and do not validate.
    2135  *
    2136  *      --  DF_FAIL_IF_NO_DTD: fail if no @DTD was found. Useful
    2137  *          if you want to enforce validation. @@todo
    2138  *
    2139  *      Usage:
     2310 *      Simplest possible usage:
    21402311 *
    21412312 *      1) Create a DOM instance.
    21422313 *
    21432314 +          PXMLDOM pDom = NULL;
    2144  +          APIRET arc = xmlCreateDOM(flags, &pDom);
     2315 +          APIRET arc = xmlCreateDOM(flags, NULL, NULL, NULL, &pDom);
    21452316 +
    21462317 *      2) Give chunks of data (or an entire buffer)
    … …  
    21642335 *      4) When done, call xmlFreeDOM, which will free all memory.
    21652336 *
     2337 *      The above code has limitations: only a few character
     2338 *      @encodings are supported, and @external_entities are
     2339 *      silently ignored.
     2340 *
     2341 *      This function supports a number of callbacks and flags
     2342 *      to allow for maximum flexibility. Note however that
     2343 *      not all @expat features are supported yet.
     2344 *
     2345 *      The following callbacks can be specified (any of these
     2346 *      can be NULL):
     2347 *
     2348 *      --  pfnGetCPData should be specified if you want to
     2349 *          support character @encodings other than the
     2350 *          four that built into expat itself (see
     2351 *          XML_SetUnknownEncodingHandler). This is probably
     2352 *          a good idea to do under OS/2 since most OS/2
     2353 *          documents are in a PC-specific codepage such as
     2354 *          CP 850.
     2355 *
     2356 *          This callback must have the following prototype:
     2357 *
     2358 +              int APIENTRY FNGETCPDATA(PXMLDOM pDom, ULONG ulCP, int *piMap)
     2359 *
     2360 *          The callback will only be called once for each
     2361 *          document if the "encoding" attribute of the
     2362 *          XML @text_declaration starts with "cp" (e.g.
     2363 *          "cp850") and will then receives the following
     2364 *          parameters:
     2365 *
     2366 *          --  "pDom" will be the XMLDOM created by this function.
     2367 *
     2368 *          --  ulCP has the IBM code page number, such as "850".
     2369 *
     2370 *          --  piMap is an array of 256 integer values which must
     2371 *              be filled with the callback. Each array item index
     2372 *              is the codepage value, and the value of each field
     2373 *              is the corresponding Unicode value, or -1 if the
     2374 *              character is invalid (shouldn't happen with codepages).
     2375 *
     2376 *              For example, the German o-umlaut character is
     2377 *              0x94 in CP850 and 0x00f6 in Unicode. So set
     2378 *              the int at index 0x94 to 0x00f6.
     2379 *
     2380 *      pvCallbackUser is a user parameter which is simply stored
     2381 *      in the XMLDOM struct which is returned. Since the XMLDOM
     2382 *      is passed to all the callbacks, you can access that pointer
     2383 *      from them.
     2384 *
     2385 *      flParserFlags is any combination of the following:
     2386 *
     2387 *      --  DF_PARSECOMMENTS: XML @comments are to be returned in
     2388 *          the DOM tree. Otherwise they are discarded.
     2389 *
     2390 *      --  DF_PARSEDTD: add the @DTD of the document into the DOM tree
     2391 *          as well and validate the document, if a DTD was found.
     2392 *          Otherwise just parse and do not validate.
     2393 *
     2394 *          DF_PARSEDTD is required for external entities to work
     2395 *          also.
     2396 *
     2397 *      --  DF_FAIL_IF_NO_DTD: fail if no @DTD was found. Useful
     2398 *          if you want to enforce validation. @@todo
     2399 *
     2400 *      --  DF_DROP_WHITESPACE: discard all @whitespace for those
     2401 *          elements that can only have element content. Whitespace
     2402 *          will be preserved only for elements that can have
     2403 *          mixed content. -- If this flag is not set, all whitespace
     2404 *          is preserved.
     2405 *
    21662406 *@@added V0.9.9 (2001-02-14) [umoeller]
    2167  */
    2168 
    2169 APIRET xmlCreateDOM(ULONG flParserFlags,
    2170                     PXMLDOM *ppDom)
     2407 *@@changed V0.9.14 (2001-08-09) [umoeller]: added DF_DROP_WHITESPACE support
     2408 */
     2409
     2410APIRET xmlCreateDOM(ULONG flParserFlags,            // in: DF_* parser flags
     2411                    PFNGETCPDATA pfnGetCPData,      // in: codepage callback or NULL
     2412                    PFNEXTERNALHANDLER pfnExternalHandler, // in: external entity callback or NULL
     2413                    PVOID pvCallbackUser,           // in: user param for callbacks
     2414                    PXMLDOM *ppDom)                 // out: XMLDOM struct created
    21712415{
    21722416    APIRET  arc = NO_ERROR;
    … …  
    21802424
    21812425        memset(pDom, 0, sizeof(XMLDOM));
     2426
     2427        pDom->flParserFlags = flParserFlags;
     2428        pDom->pfnGetCPData = pfnGetCPData;
     2429        pDom->pfnExternalHandler = pfnExternalHandler;
     2430        pDom->pvCallbackUser = pvCallbackUser;
    21822431
    21832432        lstInit(&pDom->llElementStack,
    … …  
    22072456            else
    22082457            {
     2458                if (pfnGetCPData)
     2459                    XML_SetUnknownEncodingHandler(pDom->pParser,
     2460                                                  UnknownEncodingHandler,
     2461                                                  pDom);        // user data
     2462
     2463                XML_SetParamEntityParsing(pDom->pParser,
     2464                                          XML_PARAM_ENTITY_PARSING_ALWAYS);
     2465
    22092466                XML_SetElementHandler(pDom->pParser,
    22102467                                      StartElementHandler,
    … …  
    22212478                    XML_SetCommentHandler(pDom->pParser,
    22222479                                          CommentHandler);
     2480
     2481                if (pfnExternalHandler)
     2482                    XML_SetExternalEntityRefHandler(pDom->pParser,
     2483                                                    ExternalEntityRefHandler);
    22232484
    22242485                if (flParserFlags & DF_PARSEDTD)
    … …  
    22312492                                               NotationDeclHandler);
    22322493
    2233                     XML_SetExternalEntityRefHandler(pDom->pParser,
    2234                                                     ExternalEntityRefHandler);
    2235 
    22362494                    XML_SetElementDeclHandler(pDom->pParser,
    22372495                                              ElementDeclHandler);
    … …  
    23062564    else
    23072565    {
    2308         BOOL fSuccess = XML_Parse(pDom->pParser,
    2309                                   pcszBuf,
    2310                                   cb,
    2311                                   fIsLast);
    2312 
    2313         if (!fSuccess)
     2566        // go parse then
     2567        if (!XML_Parse(pDom->pParser,
     2568                       pcszBuf,
     2569                       cb,
     2570                       fIsLast))
    23142571        {
    23152572            // expat parsing error:
    … …  
    23802637
    23812638        xmlDeleteNode((PNODEBASE)pDom->pDocumentNode);
     2639
     2640        if (pDom->pxstrSystemID)
     2641            xstrFree(&pDom->pxstrSystemID);
     2642        if (pDom->pxstrFailingNode)
     2643            xstrFree(&pDom->pxstrFailingNode);
     2644
     2645        lstClear(&pDom->llElementStack);
    23822646
    23832647        free(pDom);

  • trunk/src/helpers/xmldefs.c

    r63 r97  
    547547 *
    548548 *      All XML processors must be able to read @entities in either
    549  *      UTF-8 or UTF-16. See XML_SetUnknownEncodingHandler for additional
    550  *      encodings directly supported by @expat.
     549 *      UTF-8 or UTF-16. @expat directly supports the following
     550 *      (see XML_SetUnknownEncodingHandler):
     551 *
     552 *      --   UTF-8: 8-bit encoding of Unicode.
     553 *
     554 *      --   UTF-16: 16-bit encoding of Unicode.
     555 *
     556 *      --   ISO-8859-1: that's "latin 1".
     557 *
     558 *      --   US-ASCII.
    551559 *
    552560 *      Entities encoded in UTF-16 must begin with the ZERO WIDTH NO-BREAK

  • trunk/src/helpers/xmlparse.c

    r75 r97  
    22/*
    33 *@@sourcefile xmlparse.c:
    4  *      contains the API of the expat XML parser 1.95.1, as released on
    5  *      SourceForge Oct 22, 2000.
    6  *
    7  *      This was ported to and integrated with the xwphelpers
    8  *      for V0.9.9 (2001-02-10) [umoeller]. See xml.c for a general
    9  *      introduction to @XML support in the xwphelpers.
     4 *      contains the API of the expat XML parser 1.95.2, as released on
     5 *      http://sourceforge.net/projects/expat/ on July 26, 2001.
     6 *
     7 *      V1.95.1 was ported to and integrated with the xwphelpers
     8 *      for V0.9.9 (2001-02-10) [umoeller]. V1.95.2 was re-ported
     9 *      with V0.9.14 (2001-08-09) [umoeller].
     10 *
     11 *      See xml.c for a general introduction to @XML support in the
     12 *      xwphelpers.
    1013 *
    1114 *      Expat is a library, written in C, for parsing XML @documents. It's
    … …  
    7073        // this code generates those options HEAVILY
    7174
    72 // #include <config.h>
     75
     76/* #ifdef COMPILED_FROM_DSP
     77 * #  include "winconfig.h"
     78 * #  define XMLPARSEAPI(type) __declspec(dllexport) type __cdecl
     79 * #  include "expat.h"
     80 * #  undef XMLPARSEAPI
     81 * #else
     82 * #include <config.h> */
    7383
    7484#ifdef __declspec
    75 #define XMLPARSEAPI __declspec(dllexport)
     85#define XMLPARSEAPI(type) __declspec(dllexport) type __cdecl
    7686#endif
    7787
    … …  
    7989
    8090#ifdef __declspec
    81     #undef XMLPARSEAPI
     91#undef XMLPARSEAPI
    8292#endif
     93// #endif /* ndef COMPILED_FROM_DSP */
    8394
    8495#include <stddef.h>
    … …  
    8697
    8798#ifdef XML_UNICODE
    88     #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
    89     #define XmlConvert XmlUtf16Convert
    90     #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
    91     #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
    92     #define XmlEncode XmlUtf16Encode
    93     #define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
    94     typedef unsigned short ICHAR;
     99#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX
     100#define XmlConvert XmlUtf16Convert
     101#define XmlGetInternalEncoding XmlGetUtf16InternalEncoding
     102#define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS
     103#define XmlEncode XmlUtf16Encode
     104#define MUST_CONVERT(enc, s) (!(enc)->isUtf16 || (((unsigned long)s) & 1))
     105typedef unsigned short ICHAR;
     106
    95107#else
    96     #define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
    97     #define XmlConvert XmlUtf8Convert
    98     #define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
    99     #define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
    100     #define XmlEncode XmlUtf8Encode
    101     #define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
    102     typedef char ICHAR;
     108#define XML_ENCODE_MAX XML_UTF8_ENCODE_MAX
     109#define XmlConvert XmlUtf8Convert
     110#define XmlGetInternalEncoding XmlGetUtf8InternalEncoding
     111#define XmlGetInternalEncodingNS XmlGetUtf8InternalEncodingNS
     112#define XmlEncode XmlUtf8Encode
     113#define MUST_CONVERT(enc, s) (!(enc)->isUtf8)
     114typedef char ICHAR;
     115
    103116#endif
    104117
     118
    105119#ifndef XML_NS
    106     #define XmlInitEncodingNS XmlInitEncoding
    107     #define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
    108     #undef XmlGetInternalEncodingNS
    109     #define XmlGetInternalEncodingNS XmlGetInternalEncoding
    110     #define XmlParseXmlDeclNS XmlParseXmlDecl
     120
     121#define XmlInitEncodingNS XmlInitEncoding
     122#define XmlInitUnknownEncodingNS XmlInitUnknownEncoding
     123#undef XmlGetInternalEncodingNS
     124#define XmlGetInternalEncodingNS XmlGetInternalEncoding
     125#define XmlParseXmlDeclNS XmlParseXmlDecl
     126
    111127#endif
    112128
    113129#ifdef XML_UNICODE_WCHAR_T
    114     #define XML_T(x) L ## x
     130#define XML_T(x) L ## x
    115131#else
    116     #define XML_T(x) x
     132#define XML_T(x) x
    117133#endif
    118134
    … …  
    125141typedef const XML_Char *KEY;
    126142
    127 typedef struct _NAMED
     143typedef struct
    128144{
    129145    KEY name;
    130 } NAMED, *PNAMED;
    131 
    132 typedef struct _HASH_TABLE
     146}
     147NAMED;
     148
     149typedef struct
    133150{
    134151    NAMED **v;
    … …  
    137154    size_t usedLim;
    138155    XML_Memory_Handling_Suite *mem;
    139 } HASH_TABLE, *PHASH_TABLE;
    140 
    141 typedef struct _HASH_TABLE_ITER
     156}
     157HASH_TABLE;
     158
     159typedef struct
    142160{
    143161    NAMED **p;
    144162    NAMED **end;
    145 } HASH_TABLE_ITER, *PHASH_TABLE_ITER;
     163}
     164HASH_TABLE_ITER;
    146165
    147166#define INIT_TAG_BUF_SIZE 32    /* must be a multiple of sizeof(XML_Char) */
    … …  
    155174typedef struct binding
    156175{
    157     struct prefix               *prefix;
    158     struct binding              *nextTagBinding;
    159     struct binding              *prevPrefixBinding;
    160     const struct attribute_id   *attId;
    161     XML_Char                    *uri;
    162     int                         uriLen;
    163     int                         uriAlloc;
    164 } BINDING, *PBINDING;
     176    struct prefix *prefix;
     177    struct binding *nextTagBinding;
     178    struct binding *prevPrefixBinding;
     179    const struct attribute_id *attId;
     180    XML_Char *uri;
     181    int uriLen;
     182    int uriAlloc;
     183}
     184BINDING;
    165185
    166186typedef struct prefix
    167187{
    168     const XML_Char              *name;
    169     BINDING                     *binding;
    170 } PREFIX, *PPREFIX;
     188    const XML_Char *name;
     189    BINDING *binding;
     190}
     191PREFIX;
    171192
    172193typedef struct
    173194{
    174     const XML_Char              *str;
    175     const XML_Char              *localPart;
     195    const XML_Char *str;
     196    const XML_Char *localPart;
    176197    int uriLen;
    177 } TAG_NAME, *PTAG_NAME;
     198}
     199TAG_NAME;
    178200
    179201typedef struct tag
    180202{
    181     struct tag                  *parent;
    182     const char                  *rawName;
    183     int                         rawNameLength;
    184     TAG_NAME                    name;
    185     char                        *buf;
    186     char                        *bufEnd;
    187     BINDING                     *bindings;
    188 } TAG, *PTAG;
     203    struct tag *parent;
     204    const char *rawName;
     205    int rawNameLength;
     206    TAG_NAME name;
     207    char *buf;
     208    char *bufEnd;
     209    BINDING *bindings;
     210}
     211TAG;
    189212
    190213typedef struct
    191214{
    192     const XML_Char              *name;
    193     const XML_Char              *textPtr;
    194     int                         textLen;
    195     const XML_Char              *systemId;
    196     const XML_Char              *base;
    197     const XML_Char              *publicId;
    198     const XML_Char              *notation;
     215    const XML_Char *name;
     216    const XML_Char *textPtr;
     217    int textLen;
     218    const XML_Char *systemId;
     219    const XML_Char *base;
     220    const XML_Char *publicId;
     221    const XML_Char *notation;
    199222    char open;
    200223    char is_param;
    201 } ENTITY, *PENTITY;
     224}
     225ENTITY;
    202226
    203227typedef struct
    204228{
    205     enum XML_Content_Type       type;
    206     enum XML_Content_Quant      quant;
    207     const XML_Char              *name;
    208     int                         firstchild;
    209     int                         lastchild;
    210     int                         childcnt;
    211     int                         nextsib;
    212 } CONTENT_SCAFFOLD, *PCONTENT_SCAFFOLD;
     229    enum XML_Content_Type type;
     230    enum XML_Content_Quant quant;
     231    const XML_Char *name;
     232    int firstchild;
     233    int lastchild;
     234    int childcnt;
     235    int nextsib;
     236}
     237CONTENT_SCAFFOLD;
    213238
    214239typedef struct block
    … …  
    217242    int size;
    218243    XML_Char s[1];
    219 } BLOCK, *PBLOCK;
     244}
     245BLOCK;
    220246
    221247typedef struct
    … …  
    227253    XML_Char *start;
    228254    XML_Memory_Handling_Suite *mem;
    229 } STRING_POOL, *PSTRING_POOL;
     255}
     256STRING_POOL;
    230257
    231258/* The XML_Char before the name is used to determine whether
    … …  
    237264    char maybeTokenized;
    238265    char xmlns;
    239 } ATTRIBUTE_ID, *PATTRIBUTE_ID;
     266}
     267ATTRIBUTE_ID;
    240268
    241269typedef struct
    … …  
    244272    char isCdata;
    245273    const XML_Char *value;
    246 } DEFAULT_ATTRIBUTE, *PDEFAULT_ATTRIBUTE;
     274}
     275DEFAULT_ATTRIBUTE;
    247276
    248277typedef struct
    … …  
    254283    int allocDefaultAtts;
    255284    DEFAULT_ATTRIBUTE *defaultAtts;
    256 } ELEMENT_TYPE, *PELEMENT_TYPE;
     285}
     286ELEMENT_TYPE;
    257287
    258288typedef struct
    … …  
    277307    int scaffLevel;
    278308    int *scaffIndex;
    279 } DTD, *PDTD;
     309}
     310DTD;
    280311
    281312typedef struct open_internal_entity
    … …  
    285316    struct open_internal_entity *next;
    286317    ENTITY *entity;
    287 } OPEN_INTERNAL_ENTITY, *POPEN_INTERNAL_ENTITY;
     318}
     319OPEN_INTERNAL_ENTITY;
    288320
    289321typedef XMLERROR Processor(XML_Parser parser,
    290                                  const char *start,
    291                                  const char *end,
    292                                  const char **endPtr);
     322                           const char *start,
     323                           const char *end,
     324                           const char **endPtr);
    293325
    294326static Processor prologProcessor;
    … …  
    299331#ifdef XML_DTD
    300332static Processor ignoreSectionProcessor;
     333
    301334#endif /* XML_DTD */
    302 
    303335static Processor epilogProcessor;
    304336static Processor errorProcessor;
    … …  
    308340static Processor externalEntityContentProcessor;
    309341
    310 static XMLERROR handleUnknownEncoding(XML_Parser parser,
    311                                             const XML_Char * encodingName);
    312 static XMLERROR processXmlDecl(XML_Parser parser,
    313                                      int isGeneralTextEntity,
    314                                      const char *,
    315                                      const char *);
    316 static XMLERROR initializeEncoding(XML_Parser parser);
    317 static XMLERROR doProlog(XML_Parser parser,
    318                                const ENCODING * enc,
    319                                const char *s,
    320                                const char *end,
    321                                int tok,
    322                                const char *next,
    323                                const char **nextPtr);
    324 static XMLERROR processInternalParamEntity(XML_Parser parser,
    325                                                  ENTITY * entity);
    326 static XMLERROR doContent(XML_Parser parser,
    327                                 int startTagLevel,
    328                                 const ENCODING * enc,
    329                                 const char *start,
    330                                 const char *end,
    331                                 const char **endPtr);
    332 static XMLERROR doCdataSection(XML_Parser parser,
    333                                      const ENCODING *,
    334                                      const char **startPtr,
    335                                      const char *end,
    336                                      const char **nextPtr);
     342static XMLERROR
     343 handleUnknownEncoding(XML_Parser parser, const XML_Char * encodingName);
     344static XMLERROR
     345 processXmlDecl(XML_Parser parser, int isGeneralTextEntity, const char *, const char *);
     346static XMLERROR
     347 initializeEncoding(XML_Parser parser);
     348static XMLERROR
     349 doProlog(XML_Parser parser, const ENCODING * enc, const char *s,
     350          const char *end, int tok, const char *next, const char **nextPtr);
     351static XMLERROR
     352 processInternalParamEntity(XML_Parser parser, ENTITY * entity);
     353static XMLERROR
     354 doContent(XML_Parser parser, int startTagLevel, const ENCODING * enc,
     355           const char *start, const char *end, const char **endPtr);
     356static XMLERROR
     357 doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
    337358
    338359#ifdef XML_DTD
    339 static XMLERROR doIgnoreSection(XML_Parser parser,
    340                                       const ENCODING *,
    341                                       const char **startPtr,
    342                                       const char *end,
    343                                       const char **nextPtr);
     360static XMLERROR
     361 doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr, const char *end, const char **nextPtr);
     362
    344363#endif /* XML_DTD */
    345 
    346 static XMLERROR storeAtts(XML_Parser parser,
    347                                 const ENCODING *,
    348                                 const char *s,
    349                                 TAG_NAME * tagNamePtr,
    350                                 BINDING ** bindingsPtr);
    351 static int addBinding(XML_Parser parser,
    352                       PREFIX * prefix,
    353                       const ATTRIBUTE_ID * attId,
    354                       const XML_Char * uri,
    355                       BINDING ** bindingsPtr);
    356 
    357 static int defineAttribute(ELEMENT_TYPE * type,
    358                            ATTRIBUTE_ID *,
    359                            int isCdata,
    360                            int isId,
    361                            const XML_Char * dfltValue,
    362                            XML_Parser parser);
    363 
    364 static XMLERROR storeAttributeValue(XML_Parser parser,
    365                                           const ENCODING *,
    366                                           int isCdata,
    367                                           const char *,
    368                                           const char *,
    369                                           STRING_POOL *);
    370 static XMLERROR appendAttributeValue(XML_Parser parser,
    371                                            const ENCODING *,
    372                                            int isCdata,
    373                                            const char *,
    374                                            const char *,
    375                                            STRING_POOL *);
    376 static ATTRIBUTE_ID * getAttributeId(XML_Parser parser,
    377                                      const ENCODING * enc,
    378                                      const char *start,
    379                                      const char *end);
     364static XMLERROR storeAtts(XML_Parser parser, const ENCODING *, const char *s,
     365                          TAG_NAME * tagNamePtr, BINDING ** bindingsPtr);
     366static
     367int addBinding(XML_Parser parser, PREFIX * prefix, const ATTRIBUTE_ID * attId, const XML_Char * uri, BINDING ** bindingsPtr);
     368
     369static int
     370 defineAttribute(ELEMENT_TYPE * type, ATTRIBUTE_ID *,
     371                 int isCdata, int isId, const XML_Char * dfltValue,
     372                 XML_Parser parser);
     373
     374static XMLERROR
     375 storeAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
     376                     STRING_POOL *);
     377static XMLERROR
     378 appendAttributeValue(XML_Parser parser, const ENCODING *, int isCdata, const char *, const char *,
     379                      STRING_POOL *);
     380static ATTRIBUTE_ID *
     381 getAttributeId(XML_Parser parser, const ENCODING * enc, const char *start, const char *end);
    380382static int setElementTypePrefix(XML_Parser parser, ELEMENT_TYPE *);
    381 static XMLERROR storeEntityValue(XML_Parser parser,
    382                                        const ENCODING * enc,
    383                                        const char *start,
    384                                        const char *end);
    385 static int reportProcessingInstruction(XML_Parser parser,
    386                                        const ENCODING * enc,
    387                                        const char *start,
    388                                        const char *end);
    389 static int reportComment(XML_Parser parser,
    390                          const ENCODING * enc,
    391                          const char *start,
    392                          const char *end);
    393 static void reportDefault(XML_Parser parser,
    394                           const ENCODING * enc,
    395                           const char *start,
    396                           const char *end);
     383static XMLERROR
     384 storeEntityValue(XML_Parser parser, const ENCODING * enc, const char *start, const char *end);
     385static int
     386 reportProcessingInstruction(XML_Parser parser, const ENCODING * enc, const char *start, const char *end);
     387static int
     388 reportComment(XML_Parser parser, const ENCODING * enc, const char *start, const char *end);
     389static void
     390 reportDefault(XML_Parser parser, const ENCODING * enc, const char *start, const char *end);
    397391
    398392static const XML_Char *getContext(XML_Parser parser);
    … …  
    405399static int dtdCopy(DTD * newDtd, const DTD * oldDtd, XML_Parser parser);
    406400
    407 static int copyEntityTable(HASH_TABLE *,
    408                            STRING_POOL *,
    409                            const HASH_TABLE *,
     401static int copyEntityTable(HASH_TABLE *, STRING_POOL *, const HASH_TABLE *,
    410402                           XML_Parser parser);
    411403
    412404#ifdef XML_DTD
    413405static void dtdSwap(DTD *, DTD *);
     406
    414407#endif /* XML_DTD */
    415408
    … …  
    424417static void poolClear(STRING_POOL *);
    425418static void poolDestroy(STRING_POOL *);
    426 static XML_Char *poolAppend(STRING_POOL * pool, const ENCODING * enc,
    427                             const char *ptr, const char *end);
    428 static XML_Char *poolStoreString(STRING_POOL * pool, const ENCODING * enc,
    429                                  const char *ptr, const char *end);
     419static XML_Char *poolAppend(STRING_POOL *pool,
     420                            const ENCODING *enc,
     421                            const char *ptr,
     422                            const char *end,
     423                            unsigned long *pulOfs); // V0.9.14 (2001-08-09) [umoeller]
     424static XML_Char *poolStoreString(STRING_POOL *pool,
     425                                 const ENCODING *enc,
     426                                 const char *ptr,
     427                                 const char *end,
     428                                 unsigned long *pulOfs); // V0.9.14 (2001-08-09) [umoeller]
    430429
    431430static int poolGrow(STRING_POOL * pool);
    … …  
    502501    void *m_unknownEncodingData;
    503502    void *m_unknownEncodingHandlerData;
    504     void (* EXPATENTRY m_unknownEncodingRelease) (void *);
     503    void (*m_unknownEncodingRelease) (void *);
    505504    PROLOG_STATE m_prologState;
    506505    Processor *m_processor;
    … …  
    544543    XML_Parser m_parentParser;
    545544#endif
    546 } Parser, *PParser;
     545}
     546Parser;
    547547
    548548#define MALLOC(s) (((Parser *)parser)->m_mem.malloc_fcn((s)))
    … …  
    569569#define externalEntityRefHandler (((Parser *)parser)->m_externalEntityRefHandler)
    570570#define externalEntityRefHandlerArg (((Parser *)parser)->m_externalEntityRefHandlerArg)
     571#define internalEntityRefHandler (((Parser *)parser)->m_internalEntityRefHandler)
    571572#define unknownEncodingHandler (((Parser *)parser)->m_unknownEncodingHandler)
    572573#define elementDeclHandler (((Parser *)parser)->m_elementDeclHandler)
    … …  
    579580#define unknownEncodingMem (((Parser *)parser)->m_unknownEncodingMem)
    580581#define unknownEncodingData (((Parser *)parser)->m_unknownEncodingData)
    581 #define unknownEncodingHandlerData (((Parser *)parser)->m_unknownEncodingHandlerData)
    582 #define unknownEncodingRelease (((Parser*)parser)->m_unknownEncodingRelease)
     582#define unknownEncodingHandlerData \
     583  (((Parser *)parser)->m_unknownEncodingHandlerData)
     584#define unknownEncodingRelease (((Parser *)parser)->m_unknownEncodingRelease)
    583585#define protocolEncodingName (((Parser *)parser)->m_protocolEncodingName)
    584586#define ns (((Parser *)parser)->m_ns)
    … …  
    594596#define defaultExpandInternalEntities (((Parser *)parser)->m_defaultExpandInternalEntities)
    595597#define tagLevel (((Parser *)parser)->m_tagLevel)
    596 #define buffer (((Parser*)parser)->m_buffer)
     598#define buffer (((Parser *)parser)->m_buffer)
    597599#define bufferPtr (((Parser *)parser)->m_bufferPtr)
    598600#define bufferEnd (((Parser *)parser)->m_bufferEnd)
    … …  
    634636#endif /* XML_DTD */
    635637
     638#ifdef COMPILED_FROM_DSP
     639BOOL WINAPI DllMain(HINSTANCE h, DWORD r, LPVOID p)
     640{
     641    return TRUE;
     642}
     643#endif /* def COMPILED_FROM_DSP */
     644
     645#ifdef _MSC_VER
     646#ifdef _DEBUG
     647Parser *asParser(XML_Parser parser)
     648{
     649    return parser;
     650}
     651#endif
     652#endif
     653
    636654/*
    637655 *@@ XML_ParserCreate:
    … …  
    748766 */
    749767
    750 XML_Parser XML_ParserCreate(const XML_Char* encodingName)
     768XML_Parser XML_ParserCreate(const XML_Char * encodingName)
    751769{
    752770    return XML_ParserCreate_MM(encodingName, NULL, NULL);
    … …  
    830848 */
    831849
    832 XML_Parser XML_ParserCreate_MM(const XML_Char * encodingName,
    833                                const XML_Memory_Handling_Suite * memsuite,
    834                                const XML_Char * nameSep)
     850XML_Parser
     851XML_ParserCreate_MM(const XML_Char * encodingName,
     852                    const XML_Memory_Handling_Suite * memsuite,
     853                    const XML_Char * nameSep)
    835854{
    836855
    … …  
    857876
    858877        parser = memsuite->malloc_fcn(sizeof(Parser));
    859         mtemp = &(((Parser*)parser)->m_mem);
     878        mtemp = &(((Parser *) parser)->m_mem);
    860879        mtemp->malloc_fcn = memsuite->malloc_fcn;
    861880        mtemp->realloc_fcn = memsuite->realloc_fcn;
    … …  
    866885        XML_Memory_Handling_Suite *mtemp;
    867886
    868         parser = (malloc)(sizeof(Parser));
    869         mtemp = &(((Parser*)parser)->m_mem);
    870 
     887        parser = malloc(sizeof(Parser));
     888        mtemp = &(((Parser *) parser)->m_mem);
    871889        mtemp->malloc_fcn = malloc;
    872890        mtemp->realloc_fcn = realloc;
    … …  
    929947    inheritedBindings = 0;
    930948    attsSize = INIT_ATTS_SIZE;
    931     atts = (PATTRIBUTE)MALLOC(attsSize * sizeof(ATTRIBUTE));
     949    atts = MALLOC(attsSize * sizeof(ATTRIBUTE));
    932950    nSpecifiedAtts = 0;
    933     dataBuf = (XML_Char*)MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
     951    dataBuf = MALLOC(INIT_DATA_BUF_SIZE * sizeof(XML_Char));
    934952    groupSize = 0;
    935953    groupConnector = 0;
    … …  
    946964    ns = 0;
    947965    ns_triplets = 0;
    948     poolInit(&tempPool, &(((Parser*)parser)->m_mem));
    949     poolInit(&temp2Pool, &(((Parser*)parser)->m_mem));
     966    poolInit(&tempPool, &(((Parser *) parser)->m_mem));
     967    poolInit(&temp2Pool, &(((Parser *) parser)->m_mem));
    950968    protocolEncodingName = encodingName ? poolCopyString(&tempPool, encodingName) : 0;
    951969    curBase = 0;
    … …  
    10471065
    10481066#ifdef XML_DTD
    1049     enum XML_ParamEntityParsing oldParamEntityParsing = paramEntityParsing;
     1067    int oldParamEntityParsing = paramEntityParsing;
    10501068
    10511069#endif
    … …  
    10571075
    10581076        *tmp = namespaceSeparator;
    1059         parser = XML_ParserCreate_MM(encodingName, &((Parser*)parser)->m_mem,
     1077        parser = XML_ParserCreate_MM(encodingName, &((Parser *) parser)->m_mem,
    10601078                                     tmp);
    10611079    }
    10621080    else
    10631081    {
    1064         parser = XML_ParserCreate_MM(encodingName, &((Parser*)parser)->m_mem,
     1082        parser = XML_ParserCreate_MM(encodingName, &((Parser *) parser)->m_mem,
    10651083                                     NULL);
    10661084    }
    … …  
    11231141}
    11241142
    1125 static void destroyBindings(BINDING * bindings, XML_Parser parser)
     1143static
     1144void destroyBindings(BINDING * bindings, XML_Parser parser)
    11261145{
    11271146    for (;;)
    … …  
    11721191        if (hadExternalDoctype)
    11731192            dtd.complete = 0;
    1174         dtdSwap(&dtd, &((Parser*)parentParser)->m_dtd);
     1193        dtdSwap(&dtd, &((Parser *) parentParser)->m_dtd);
    11751194    }
    11761195#endif /* XML_DTD */
    … …  
    12751294 */
    12761295
    1277 const XML_Char* XML_GetBase(XML_Parser parser)
     1296const XML_Char *XML_GetBase(XML_Parser parser)
    12781297{
    12791298    return curBase;
    … …  
    14331452
    14341453void XML_SetProcessingInstructionHandler(XML_Parser parser,
    1435                                          XML_ProcessingInstructionHandler handler)
     1454                                     XML_ProcessingInstructionHandler handler)
    14361455{
    14371456    processingInstructionHandler = handler;
    … …  
    17411760 *      Handler prototype:
    17421761 +
    1743  +      int EXPATENTRY ExternalEntityRefHandler(XML_Parser parser,
     1762 +      int EXPATENTRY ExternalEntityRefHandler(void *pUser,
     1763 +                                              XML_Parser parser,
    17441764 +                                              const XML_Char *pcszContext,
    17451765 +                                              const XML_Char *pcszBase,
    … …  
    17871807 *      external entities may refer to other external entities, your
    17881808 *      handler should be prepared to be called recursively.
     1809 *
     1810 *@@changed V0.9.14 (2001-08-09) [umoeller]: changed prototype to contain user data
    17891811 */
    17901812
    … …  
    18411863 *
    18421864 *      See _XML_Encoding for more details about that structure and
    1843  *      what to do with it.
    1844  *
    1845  *      Expat places restrictions on character encodings that it can
    1846  *      support by filling in the XML_Encoding structure.
    1847  *
    1848  *      1.  Every ASCII character that can appear in a well-formed XML
    1849  *          document must be represented by a single byte, and that byte
    1850  *          must correspond to its ASCII encoding (except for the
    1851  *          characters $@\^'{}~).
    1852  *
    1853  *      2.  Characters must be encoded in 4 bytes or less.
    1854  *
    1855  *      3.  All characters encoded must have Unicode scalar values less
    1856  *          than or equal to 65535 (0xFFFF). (This does not apply to
    1857  *          the built-in support for UTF-16 and UTF-8.)
    1858  *
    1859  *      4.  No character may be encoded by more than one distinct
    1860  *          sequence of bytes.
     1865 *      what to do with it, and restrictions imposed by expat.
     1866 *
    18611867 */
    18621868
    … …  
    20732079 */
    20742080
    2075 int XML_Parse(XML_Parser parser,
    2076               const char *s,
    2077               int len,
    2078               int isFinal)
     2081int XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
    20792082{
    20802083    if (len == 0)
    … …  
    20832086            return 1;
    20842087        positionPtr = bufferPtr;
    2085         errorCode = processor(parser,
    2086                               bufferPtr,
    2087                               parseEndPtr = bufferEnd,
    2088                               0);
     2088        errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);
    20892089        if (errorCode == ERROR_EXPAT_NONE)
    20902090            return 1;
    … …  
    21032103        if (isFinal)
    21042104        {
    2105             errorCode = processor(parser,
    2106                                   s,
    2107                                   parseEndPtr = s + len,
    2108                                   0);
     2105            errorCode = processor(parser, s, parseEndPtr = s + len, 0);
    21092106            if (errorCode == ERROR_EXPAT_NONE)
    21102107                return 1;
    … …  
    21272124            {
    21282125                /* FIXME avoid integer overflow */
    2129                 buffer = buffer == 0 ? (char*)MALLOC(len * 2) : (char*)REALLOC(buffer, len * 2);
     2126                buffer = buffer == 0 ? MALLOC(len * 2) : REALLOC(buffer, len * 2);
    21302127                /* FIXME storage leak if realloc fails */
    21312128                if (!buffer)
    … …  
    22122209 */
    22132210
    2214 void* XML_GetBuffer(XML_Parser parser, int len)
     2211void *XML_GetBuffer(XML_Parser parser, int len)
    22152212{
    22162213    if (len > bufferLim - bufferEnd)
    … …  
    22552252            }
    22562253            while (bufferSize < neededSize);
    2257             newBuf = (char*)MALLOC(bufferSize);
     2254            newBuf = MALLOC(bufferSize);
    22582255            if (newBuf == 0)
    22592256            {
    … …  
    23622359 */
    23632360
    2364 const char* XML_GetInputContext(XML_Parser parser, int *offset, int *size)
     2361const char *XML_GetInputContext(XML_Parser parser, int *offset, int *size)
    23652362{
    23662363#ifdef XML_CONTEXT_BYTES
    … …  
    24292426}
    24302427
    2431 /*
    2432  *@@ XML_ExpatVersion:
    2433  *      returns the library version string (e.g. "expat_1.95.1").
    2434  */
    2435 
    2436 const XML_LChar* XML_ExpatVersion(void)
    2437 {
    2438     return "expat_1.95.1";
    2439 }
    2440 
    2441 static XMLERROR contentProcessor(XML_Parser parser,
    2442                                        const char *start,
    2443                                        const char *end,
    2444                                        const char **endPtr)
     2428const XML_LChar *XML_ErrorString(int code)
     2429{
     2430    static const XML_LChar *message[] =
     2431    {
     2432        0,
     2433        XML_T("out of memory"),
     2434        XML_T("syntax error"),
     2435        XML_T("no element found"),
     2436        XML_T("not well-formed (invalid token)"),
     2437        XML_T("unclosed token"),
     2438        XML_T("unclosed token"),
     2439        XML_T("mismatched tag"),
     2440        XML_T("duplicate attribute"),
     2441        XML_T("junk after document element"),
     2442        XML_T("illegal parameter entity reference"),
     2443        XML_T("undefined entity"),
     2444        XML_T("recursive entity reference"),
     2445        XML_T("asynchronous entity"),
     2446        XML_T("reference to invalid character number"),
     2447        XML_T("reference to binary entity"),
     2448        XML_T("reference to external entity in attribute"),
     2449        XML_T("xml processing instruction not at start of external entity"),
     2450        XML_T("unknown encoding"),
     2451        XML_T("encoding specified in XML declaration is incorrect"),
     2452        XML_T("unclosed CDATA section"),
     2453        XML_T("error in processing external entity reference"),
     2454        XML_T("document is not standalone"),
     2455        XML_T("unexpected parser state - please send a bug report")
     2456    };
     2457
     2458    if (code > 0 && code < sizeof(message) / sizeof(message[0]))
     2459        return message[code];
     2460    return 0;
     2461}
     2462
     2463/* const XML_LChar *
     2464 * XML_ExpatVersion(void) {
     2465 * return VERSION;
     2466 * }
     2467 *
     2468 * XML_Expat_Version
     2469 * XML_ExpatVersionInfo(void) {
     2470 * XML_Expat_Version version;
     2471 *
     2472 * version.major = XML_MAJOR_VERSION;
     2473 * version.minor = XML_MINOR_VERSION;
     2474 * version.micro = XML_MICRO_VERSION;
     2475 *
     2476 * return version;
     2477 * } */
     2478
     2479static
     2480XMLERROR contentProcessor(XML_Parser parser,
     2481                          const char *start,
     2482                          const char *end,
     2483                          const char **endPtr)
    24452484{
    24462485    return doContent(parser, 0, encoding, start, end, endPtr);
    24472486}
    24482487
    2449 static XMLERROR externalEntityInitProcessor(XML_Parser parser,
    2450                                                   const char *start,
    2451                                                   const char *end,
    2452                                                   const char **endPtr)
     2488static
     2489XMLERROR externalEntityInitProcessor(XML_Parser parser,
     2490                                     const char *start,
     2491                                     const char *end,
     2492                                     const char **endPtr)
    24532493{
    24542494    XMLERROR result = initializeEncoding(parser);
    … …  
    24602500}
    24612501
    2462 static XMLERROR externalEntityInitProcessor2(XML_Parser parser,
    2463                                                    const char *start,
    2464                                                    const char *end,
    2465                                                    const char **endPtr)
     2502static
     2503XMLERROR externalEntityInitProcessor2(XML_Parser parser,
     2504                                      const char *start,
     2505                                      const char *end,
     2506                                      const char **endPtr)
    24662507{
    24672508    const char *next;
    … …  
    24942535}
    24952536
    2496 static XMLERROR externalEntityInitProcessor3(XML_Parser parser,
    2497                                                    const char *start,
    2498                                                    const char *end,
    2499                                                    const char **endPtr)
     2537static
     2538XMLERROR externalEntityInitProcessor3(XML_Parser parser,
     2539                                      const char *start,
     2540                                      const char *end,
     2541                                      const char **endPtr)
    25002542{
    25012543    const char *next;
    … …  
    25352577}
    25362578
    2537 static XMLERROR externalEntityContentProcessor(XML_Parser parser,
    2538                                                      const char *start,
    2539                                                      const char *end,
    2540                                                      const char **endPtr)
     2579static
     2580XMLERROR externalEntityContentProcessor(XML_Parser parser,
     2581                                        const char *start,
     2582                                        const char *end,
     2583                                        const char **endPtr)
    25412584{
    25422585    return doContent(parser, 1, encoding, start, end, endPtr);
    25432586}
    25442587
    2545 static XMLERROR
    2546  doContent(XML_Parser parser,
    2547            int startTagLevel,
    2548            const ENCODING * enc,
    2549            const char *s,
    2550            const char *end,
    2551            const char **nextPtr)
     2588/*
     2589 *@@ doContent:
     2590 *
     2591 *@@changed V0.9.14 (2001-08-09) [umoeller]: fixed ERROR_EXPAT_UNDEFINED_ENTITY with callback-defined encodings
     2592 */
     2593
     2594static XMLERROR doContent(XML_Parser parser,
     2595                          int startTagLevel,
     2596                          const ENCODING * enc,
     2597                          const char *s,
     2598                          const char *end,
     2599                          const char **nextPtr)
    25522600{
    25532601    const char **eventPP;
    … …  
    26272675                    const XML_Char *name;
    26282676                    ENTITY *entity;
     2677                    unsigned long ulOfs; // V0.9.14 (2001-08-09) [umoeller]
    26292678                    XML_Char ch = XmlPredefinedEntityName(enc,
    2630                                                      s + enc->minBytesPerChar,
    2631                                                  next - enc->minBytesPerChar);
     2679                                                          s + enc->minBytesPerChar,
     2680                                                          next - enc->minBytesPerChar);
    26322681
    26332682                    if (ch)
    … …  
    26392688                        break;
    26402689                    }
    2641                     name = poolStoreString(&dtd.pool, enc,
     2690                    name = poolStoreString(&dtd.pool,
     2691                                           enc,
    26422692                                           s + enc->minBytesPerChar,
    2643                                            next - enc->minBytesPerChar);
     2693                                           next - enc->minBytesPerChar,
     2694                                           &ulOfs);
    26442695                    if (!name)
    26452696                        return ERROR_EXPAT_NO_MEMORY;
    2646                     entity = (ENTITY*)lookup(&dtd.generalEntities, name, 0);
     2697                    entity = (ENTITY*)lookup(&dtd.generalEntities,
     2698                                             name + ulOfs,  // V0.9.14 (2001-08-09) [umoeller]
     2699                                             0);
    26472700                    poolDiscard(&dtd.pool);
    26482701                    if (!entity)
    … …  
    26962749                            if (!context)
    26972750                                return ERROR_EXPAT_NO_MEMORY;
    2698                             if (!externalEntityRefHandler(externalEntityRefHandlerArg,
     2751                            if (!externalEntityRefHandler(handlerArg,   // V0.9.14 (2001-08-09) [umoeller]
     2752                                                          externalEntityRefHandlerArg,
    26992753                                                          context,
    27002754                                                          entity->base,
    … …  
    27292783                    else
    27302784                    {
    2731                         tag = (TAG*)MALLOC(sizeof(TAG));
     2785                        tag = MALLOC(sizeof(TAG));
    27322786                        if (!tag)
    27332787                            return ERROR_EXPAT_NO_MEMORY;
    2734                         tag->buf = (char*)MALLOC(INIT_TAG_BUF_SIZE);
     2788                        tag->buf = MALLOC(INIT_TAG_BUF_SIZE);
    27352789                        if (!tag->buf)
    27362790                            return ERROR_EXPAT_NO_MEMORY;
    … …  
    27522806
    27532807                            bufSize = ROUND_UP(bufSize, sizeof(XML_Char));
    2754                             tag->buf = (char*)REALLOC(tag->buf, bufSize);
     2808                            tag->buf = REALLOC(tag->buf, bufSize);
    27552809                            if (!tag->buf)
    27562810                                return ERROR_EXPAT_NO_MEMORY;
    … …  
    27732827
    27742828                            if (nextPtr)
    2775                                 toPtr = (XML_Char*)(tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
     2829                                toPtr = (XML_Char *) (tag->buf + ROUND_UP(tag->rawNameLength, sizeof(XML_Char)));
    27762830                            else
    2777                                 toPtr = (XML_Char*)tag->buf;
     2831                                toPtr = (XML_Char *) tag->buf;
    27782832                            tag->name.str = toPtr;
    27792833                            XmlConvert(enc,
    27802834                                       &fromPtr, rawNameEnd,
    2781                                (ICHAR **) & toPtr, (ICHAR*)tag->bufEnd - 1);
     2835                               (ICHAR **) & toPtr, (ICHAR *) tag->bufEnd - 1);
    27822836                            if (fromPtr == rawNameEnd)
    27832837                                break;
    27842838                            bufSize = (tag->bufEnd - tag->buf) << 1;
    2785                             tag->buf = (char*)REALLOC(tag->buf, bufSize);
     2839                            tag->buf = REALLOC(tag->buf, bufSize);
    27862840                            if (!tag->buf)
    27872841                                return ERROR_EXPAT_NO_MEMORY;
    … …  
    28222876                    TAG_NAME name;
    28232877
    2824                     name.str = poolStoreString(&tempPool, enc, rawName,
    2825                                        rawName + XmlNameLength(enc, rawName));
     2878                    name.str = poolStoreString(&tempPool,
     2879                                               enc,
     2880                                               rawName,
     2881                                               rawName + XmlNameLength(enc, rawName),
     2882                                               NULL);
    28262883                    if (!name.str)
    28272884                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    28822939                        if (tag->name.localPart)
    28832940                        {
    2884                             XML_Char *to = (XML_Char*)tag->name.str + tag->name.uriLen;
     2941                            XML_Char *to = (XML_Char *) tag->name.str + tag->name.uriLen;
    28852942                            const XML_Char *from = tag->name.localPart;
    28862943
    … …  
    29172974                        XML_Char buf[XML_ENCODE_MAX];
    29182975
    2919                         characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR*)buf));
     2976                        characterDataHandler(handlerArg, buf, XmlEncode(n, (ICHAR *) buf));
    29202977                    }
    29212978                    else if (defaultHandler)
    … …  
    29763033                    if (MUST_CONVERT(enc, s))
    29773034                    {
    2978                         ICHAR *dataPtr = (ICHAR*)dataBuf;
    2979 
    2980                         XmlConvert(enc, &s, end, &dataPtr, (ICHAR*)dataBufEnd);
    2981                         characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR*)dataBuf);
     3035                        ICHAR *dataPtr = (ICHAR *) dataBuf;
     3036
     3037                        XmlConvert(enc, &s, end, &dataPtr, (ICHAR *) dataBufEnd);
     3038                        characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *) dataBuf);
    29823039                    }
    29833040                    else
    29843041                        characterDataHandler(handlerArg,
    2985                                              (XML_Char*)s,
    2986                                            (XML_Char*)end - (XML_Char*)s);
     3042                                             (XML_Char *) s,
     3043                                           (XML_Char *) end - (XML_Char *) s);
    29873044                }
    29883045                else if (defaultHandler)
    … …  
    30063063                        for (;;)
    30073064                        {
    3008                             ICHAR *dataPtr = (ICHAR*)dataBuf;
    3009 
    3010                             XmlConvert(enc, &s, next, &dataPtr, (ICHAR*)dataBufEnd);
     3065                            ICHAR *dataPtr = (ICHAR *) dataBuf;
     3066
     3067                            XmlConvert(enc, &s, next, &dataPtr, (ICHAR *) dataBufEnd);
    30113068                            *eventEndPP = s;
    3012                             characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR*)dataBuf);
     3069                            characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *) dataBuf);
    30133070                            if (s == next)
    30143071                                break;
    … …  
    30183075                    else
    30193076                        characterDataHandler(handlerArg,
    3020                                              (XML_Char*)s,
    3021                                           (XML_Char*)next - (XML_Char*)s);
     3077                                             (XML_Char *) s,
     3078                                          (XML_Char *) next - (XML_Char *) s);
    30223079                }
    30233080                else if (defaultHandler)
    … …  
    30453102 * otherwise just check the attributes for well-formedness. */
    30463103
    3047 static XMLERROR storeAtts(XML_Parser parser,
    3048                                 const ENCODING * enc,
    3049                                 const char *attStr,
    3050                                 TAG_NAME * tagNamePtr,
    3051                                 BINDING ** bindingsPtr)
     3104static XMLERROR storeAtts(XML_Parser parser, const ENCODING * enc,
     3105                          const char *attStr, TAG_NAME * tagNamePtr,
     3106                          BINDING ** bindingsPtr)
    30523107{
    30533108    ELEMENT_TYPE *elementType = 0;
    … …  
    30643119    if (tagNamePtr)
    30653120    {
    3066         elementType = (ELEMENT_TYPE*)lookup(&dtd.elementTypes, tagNamePtr->str, 0);
     3121        elementType = (ELEMENT_TYPE *) lookup(&dtd.elementTypes, tagNamePtr->str, 0);
    30673122        if (!elementType)
    30683123        {
    … …  
    30703125            if (!tagNamePtr->str)
    30713126                return ERROR_EXPAT_NO_MEMORY;
    3072             elementType = (ELEMENT_TYPE*)lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
     3127            elementType = (ELEMENT_TYPE *) lookup(&dtd.elementTypes, tagNamePtr->str, sizeof(ELEMENT_TYPE));
    30733128            if (!elementType)
    30743129                return ERROR_EXPAT_NO_MEMORY;
    … …  
    30853140
    30863141        attsSize = n + nDefaultAtts + INIT_ATTS_SIZE;
    3087         atts = (PATTRIBUTE)REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
     3142        atts = REALLOC((void *)atts, attsSize * sizeof(ATTRIBUTE));
    30883143        if (!atts)
    30893144            return ERROR_EXPAT_NO_MEMORY;
    … …  
    31473202        {
    31483203            /* the value did not need normalizing */
    3149             appAtts[attIndex] = poolStoreString(&tempPool, enc, atts[i].valuePtr, atts[i].valueEnd);
     3204            appAtts[attIndex] = poolStoreString(&tempPool,
     3205                                                enc,
     3206                                                atts[i].valuePtr,
     3207                                                atts[i].valueEnd,
     3208                                                NULL);
    31503209            if (appAtts[attIndex] == 0)
    31513210                return ERROR_EXPAT_NO_MEMORY;
    … …  
    32313290                ATTRIBUTE_ID *id;
    32323291
    3233                 ((XML_Char*)(appAtts[i]))[-1] = 0;
    3234                 id = (ATTRIBUTE_ID*)lookup(&dtd.attributeIds, appAtts[i], 0);
     3292                ((XML_Char *) (appAtts[i]))[-1] = 0;
     3293                id = (ATTRIBUTE_ID *) lookup(&dtd.attributeIds, appAtts[i], 0);
    32353294                if (id->prefix->binding)
    32363295                {
    … …  
    32713330            }
    32723331            else
    3273                 ((XML_Char*)(appAtts[i]))[-1] = 0;
     3332                ((XML_Char *) (appAtts[i]))[-1] = 0;
    32743333        }
    32753334    }
    32763335    /* clear the flags that say whether attributes were specified */
    32773336    for (; i < attIndex; i += 2)
    3278         ((XML_Char*)(appAtts[i]))[-1] = 0;
     3337        ((XML_Char *) (appAtts[i]))[-1] = 0;
    32793338    if (!tagNamePtr)
    32803339        return ERROR_EXPAT_NONE;
    … …  
    33063365    {
    33073366        TAG *p;
    3308         XML_Char *uri = (XML_Char*)MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
     3367        XML_Char *uri = MALLOC((n + EXPAND_SPARE) * sizeof(XML_Char));
    33093368
    33103369        if (!uri)
    … …  
    33233382}
    33243383
    3325 static int addBinding(XML_Parser parser, PREFIX * prefix, const ATTRIBUTE_ID * attId, const XML_Char * uri, BINDING ** bindingsPtr)
     3384static
     3385int addBinding(XML_Parser parser, PREFIX * prefix, const ATTRIBUTE_ID * attId, const XML_Char * uri, BINDING ** bindingsPtr)
    33263386{
    33273387    BINDING *b;
    … …  
    33373397        if (len > b->uriAlloc)
    33383398        {
    3339             b->uri = (XML_Char*)REALLOC(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
     3399            b->uri = REALLOC(b->uri, sizeof(XML_Char) * (len + EXPAND_SPARE));
    33403400            if (!b->uri)
    33413401                return 0;
    … …  
    33463406    else
    33473407    {
    3348         b = (PBINDING)MALLOC(sizeof(BINDING));
     3408        b = MALLOC(sizeof(BINDING));
    33493409        if (!b)
    33503410            return 0;
    3351         b->uri = (XML_Char*)MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
     3411        b->uri = MALLOC(sizeof(XML_Char) * (len + EXPAND_SPARE));
    33523412        if (!b->uri)
    33533413        {
    … …  
    33793439 * the whole file is parsed with one call. */
    33803440
    3381 static XMLERROR cdataSectionProcessor(XML_Parser parser,
    3382                                      const char *start,
    3383                                      const char *end,
    3384                                      const char **endPtr)
     3441static
     3442XMLERROR cdataSectionProcessor(XML_Parser parser,
     3443                               const char *start,
     3444                               const char *end,
     3445                               const char **endPtr)
    33853446{
    33863447    XMLERROR result = doCdataSection(parser, encoding, &start, end, endPtr);
    … …  
    33973458 * the section is not yet closed. */
    33983459
    3399 static XMLERROR doCdataSection(XML_Parser parser,
    3400                               const ENCODING * enc,
    3401                               const char **startPtr,
    3402                               const char *end,
    3403                               const char **nextPtr)
     3460static
     3461XMLERROR doCdataSection(XML_Parser parser,
     3462                        const ENCODING * enc,
     3463                        const char **startPtr,
     3464                        const char *end,
     3465                        const char **nextPtr)
    34043466{
    34053467    const char *s = *startPtr;
    … …  
    34573519                        for (;;)
    34583520                        {
    3459                             ICHAR *dataPtr = (ICHAR*)dataBuf;
    3460 
    3461                             XmlConvert(enc, &s, next, &dataPtr, (ICHAR*)dataBufEnd);
     3521                            ICHAR *dataPtr = (ICHAR *) dataBuf;
     3522
     3523                            XmlConvert(enc, &s, next, &dataPtr, (ICHAR *) dataBufEnd);
    34623524                            *eventEndPP = next;
    3463                             characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR*)dataBuf);
     3525                            characterDataHandler(handlerArg, dataBuf, dataPtr - (ICHAR *) dataBuf);
    34643526                            if (s == next)
    34653527                                break;
    … …  
    34693531                    else
    34703532                        characterDataHandler(handlerArg,
    3471                                              (XML_Char*)s,
    3472                                           (XML_Char*)next - (XML_Char*)s);
     3533                                             (XML_Char *) s,
     3534                                          (XML_Char *) next - (XML_Char *) s);
    34733535                }
    34743536                else if (defaultHandler)
    … …  
    35073569 * the whole file is parsed with one call. */
    35083570
    3509 static XMLERROR ignoreSectionProcessor(XML_Parser parser,
    3510                                       const char *start,
    3511                                       const char *end,
    3512                                       const char **endPtr)
     3571static
     3572XMLERROR ignoreSectionProcessor(XML_Parser parser,
     3573                                const char *start,
     3574                                const char *end,
     3575                                const char **endPtr)
    35133576{
    35143577    XMLERROR result = doIgnoreSection(parser, encoding, &start, end, endPtr);
    … …  
    35253588 * the section is not yet closed. */
    35263589
    3527 static XMLERROR doIgnoreSection(XML_Parser parser,
    3528                                const ENCODING * enc,
    3529                                const char **startPtr,
    3530                                const char *end,
    3531                                const char **nextPtr)
     3590static
     3591XMLERROR doIgnoreSection(XML_Parser parser,
     3592                         const ENCODING * enc,
     3593                         const char **startPtr,
     3594                         const char *end,
     3595                         const char **nextPtr)
    35323596{
    35333597    const char *next;
    … …  
    35763640                return ERROR_EXPAT_NONE;
    35773641            }
    3578             return ERROR_EXPAT_SYNTAX;    /* ERROR_EXPAT_UNCLOSED_IGNORE_SECTION */
     3642            return ERROR_EXPAT_SYNTAX;  /* ERROR_EXPAT_UNCLOSED_IGNORE_SECTION */
    35793643        default:
    35803644            *eventPP = next;
    … …  
    35863650#endif /* XML_DTD */
    35873651
    3588 static XMLERROR  initializeEncoding(XML_Parser parser)
     3652static XMLERROR
     3653 initializeEncoding(XML_Parser parser)
    35893654{
    35903655    const char *s;
    … …  
    36203685}
    36213686
    3622 static XMLERROR  processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
     3687static XMLERROR
     3688 processXmlDecl(XML_Parser parser, int isGeneralTextEntity,
    36233689                const char *s, const char *next)
    36243690{
    … …  
    36603726                                            encodingName,
    36613727                                            encodingName
    3662                                      + XmlNameLength(encoding, encodingName));
     3728                                            + XmlNameLength(encoding, encodingName),
     3729                                            NULL);
    36633730            if (!storedEncName)
    36643731                return ERROR_EXPAT_NO_MEMORY;
    … …  
    36703737                                            encoding,
    36713738                                            version,
    3672                                       versionend - encoding->minBytesPerChar);
     3739                                            versionend - encoding->minBytesPerChar,
     3740                                            NULL);
    36733741            if (!storedversion)
    36743742                return ERROR_EXPAT_NO_MEMORY;
    … …  
    36993767                                                encodingName,
    37003768                                                encodingName
    3701                                      + XmlNameLength(encoding, encodingName));
     3769                                                + XmlNameLength(encoding, encodingName),
     3770                                                NULL);
    37023771                if (!storedEncName)
    37033772                    return ERROR_EXPAT_NO_MEMORY;
    … …  
    37173786}
    37183787
    3719 static XMLERROR handleUnknownEncoding(XML_Parser parser,
    3720                                             const XML_Char* encodingName)
     3788static XMLERROR
     3789 handleUnknownEncoding(XML_Parser parser, const XML_Char * encodingName)
    37213790{
    37223791    if (unknownEncodingHandler)
    … …  
    37303799        info.data = 0;
    37313800        info.release = 0;
    3732         if (unknownEncodingHandler(unknownEncodingHandlerData,
    3733                                    encodingName,
    3734                                    &info))
     3801        if (unknownEncodingHandler(unknownEncodingHandlerData, encodingName, &info))
    37353802        {
    37363803            ENCODING *enc;
    … …  
    37633830}
    37643831
    3765 static XMLERROR prologInitProcessor(XML_Parser parser,
     3832static XMLERROR
     3833 prologInitProcessor(XML_Parser parser,
    37663834                     const char *s,
    37673835                     const char *end,
    … …  
    37763844}
    37773845
    3778 static XMLERROR prologProcessor(XML_Parser parser,
     3846static XMLERROR
     3847 prologProcessor(XML_Parser parser,
    37793848                 const char *s,
    37803849                 const char *end,
    … …  
    37873856}
    37883857
    3789 static XMLERROR doProlog(XML_Parser parser,
     3858static XMLERROR
     3859 doProlog(XML_Parser parser,
    37903860          const ENCODING * enc,
    37913861          const char *s,
    … …  
    38723942                if (startDoctypeDeclHandler)
    38733943                {
    3874                     doctypeName = poolStoreString(&tempPool, enc, s, next);
     3944                    doctypeName = poolStoreString(&tempPool, enc, s, next, NULL);
    38753945                    if (!doctypeName)
    38763946                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    39033973                if (startDoctypeDeclHandler)
    39043974                {
    3905                     doctypePubid = poolStoreString(&tempPool, enc, s + 1, next - 1);
     3975                    doctypePubid = poolStoreString(&tempPool, enc, s + 1, next - 1, NULL);
    39063976                    if (!doctypePubid)
    39073977                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    39093979                }
    39103980#ifdef XML_DTD
    3911                 declEntity = (ENTITY*)lookup(&dtd.paramEntities,
     3981                declEntity = (ENTITY *) lookup(&dtd.paramEntities,
    39123982                                               externalSubsetName,
    39133983                                               sizeof(ENTITY));
    … …  
    39243994                                                    enc,
    39253995                                                    s + enc->minBytesPerChar,
    3926                                                  next - enc->minBytesPerChar);
     3996                                                    next - enc->minBytesPerChar,
     3997                                                    NULL);
    39273998
    39283999                    if (!tem)
    … …  
    39464017                    if (paramEntityParsing && externalEntityRefHandler)
    39474018                    {
    3948                         ENTITY *entity = (ENTITY*)lookup(&dtd.paramEntities,
     4019                        ENTITY *entity = (ENTITY *) lookup(&dtd.paramEntities,
    39494020                                                           externalSubsetName,
    39504021                                                           0);
    39514022
    3952                         if (!externalEntityRefHandler(externalEntityRefHandlerArg,
     4023                        if (!externalEntityRefHandler(handlerArg,   // V0.9.14 (2001-08-09) [umoeller]
     4024                                                      externalEntityRefHandlerArg,
    39534025                                                      0,
    39544026                                                      entity->base,
    … …  
    40284100                    if (!poolAppendString(&tempPool, prefix))
    40294101                        return ERROR_EXPAT_NO_MEMORY;
    4030                     if (!poolAppend(&tempPool, enc, s, next))
     4102                    if (!poolAppend(&tempPool, enc, s, next, NULL))
    40314103                        return ERROR_EXPAT_NO_MEMORY;
    40324104                    declAttributeType = tempPool.start;
    … …  
    40434115                {
    40444116                    if (*declAttributeType == '('
    4045                         || *declAttributeType == 'N' && declAttributeType[1] == 'O')
     4117                        || (*declAttributeType == 'N' && declAttributeType[1] == 'O'))
    40464118                    {
    40474119                        /* Enumerated or Notation type */
    … …  
    40804152                    {
    40814153                        if (*declAttributeType == '('
    4082                             || *declAttributeType == 'N' && declAttributeType[1] == 'O')
     4154                            || (*declAttributeType == 'N' && declAttributeType[1] == 'O'))
    40834155                        {
    40844156                            /* Enumerated or Notation type */
    … …  
    41294201                if (startDoctypeDeclHandler)
    41304202                {
    4131                     doctypeSysid = poolStoreString(&tempPool, enc, s + 1, next - 1);
     4203                    doctypeSysid = poolStoreString(&tempPool,
     4204                                                   enc,
     4205                                                   s + 1,
     4206                                                   next - 1,
     4207                                                   NULL);
    41324208                    if (!doctypeSysid)
    41334209                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    41474223                if (!declEntity)
    41484224                {
    4149                     declEntity = (ENTITY*)lookup(&dtd.paramEntities,
     4225                    declEntity = (ENTITY *) lookup(&dtd.paramEntities,
    41504226                                                   externalSubsetName,
    41514227                                                   sizeof(ENTITY));
    … …  
    41594235                if (declEntity)
    41604236                {
    4161                     declEntity->systemId = poolStoreString(&dtd.pool, enc,
    4162                                                      s + enc->minBytesPerChar,
    4163                                                  next - enc->minBytesPerChar);
     4237                    declEntity->systemId = poolStoreString(&dtd.pool,
     4238                                                           enc,
     4239                                                           s + enc->minBytesPerChar,
     4240                                                           next - enc->minBytesPerChar,
     4241                                                           NULL);
    41644242                    if (!declEntity->systemId)
    41654243                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    41844262                if (declEntity)
    41854263                {
    4186                     declEntity->notation = poolStoreString(&dtd.pool, enc, s, next);
     4264                    declEntity->notation = poolStoreString(&dtd.pool,
     4265                                                           enc,
     4266                                                           s,
     4267                                                           next,
     4268                                                           NULL);
    41874269                    if (!declEntity->notation)
    41884270                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    42204302                        break;
    42214303                    }
    4222                     name = poolStoreString(&dtd.pool, enc, s, next);
     4304                    name = poolStoreString(&dtd.pool,
     4305                                           enc,
     4306                                           s,
     4307                                           next,
     4308                                           NULL);
    42234309                    if (!name)
    42244310                        return ERROR_EXPAT_NO_MEMORY;
    42254311                    if (dtd.complete)
    42264312                    {
    4227                         declEntity = (ENTITY*)lookup(&dtd.generalEntities, name, sizeof(ENTITY));
     4313                        declEntity = (ENTITY *) lookup(&dtd.generalEntities, name, sizeof(ENTITY));
    42284314                        if (!declEntity)
    42294315                            return ERROR_EXPAT_NO_MEMORY;
    … …  
    42514337                if (dtd.complete)
    42524338                {
    4253                     const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next);
     4339                    const XML_Char *name = poolStoreString(&dtd.pool, enc, s, next, NULL);
    42544340
    42554341                    if (!name)
    42564342                        return ERROR_EXPAT_NO_MEMORY;
    4257                     declEntity = (ENTITY*)lookup(&dtd.paramEntities,
     4343                    declEntity = (ENTITY *) lookup(&dtd.paramEntities,
    42584344                                                   name, sizeof(ENTITY));
    42594345                    if (!declEntity)
    … …  
    42804366                if (notationDeclHandler)
    42814367                {
    4282                     declNotationName = poolStoreString(&tempPool, enc, s, next);
     4368                    declNotationName = poolStoreString(&tempPool, enc, s, next, NULL);
    42834369                    if (!declNotationName)
    42844370                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    42944380                                                    enc,
    42954381                                                    s + enc->minBytesPerChar,
    4296                                                  next - enc->minBytesPerChar);
     4382                                                    next - enc->minBytesPerChar,
     4383                                                    NULL);
    42974384
    42984385                    if (!tem)
    … …  
    43094396                    = poolStoreString(&tempPool, enc,
    43104397                                      s + enc->minBytesPerChar,
    4311                                       next - enc->minBytesPerChar);
     4398                                      next - enc->minBytesPerChar,
     4399                                      NULL);
    43124400
    43134401                    if (!systemId)
    … …  
    43654453                    if (groupSize)
    43664454                    {
    4367                         groupConnector = (char*)REALLOC(groupConnector, groupSize *= 2);
     4455                        groupConnector = REALLOC(groupConnector, groupSize *= 2);
    43684456                        if (dtd.scaffIndex)
    4369                             dtd.scaffIndex = (int*)REALLOC(dtd.scaffIndex, groupSize * sizeof(int));
     4457                            dtd.scaffIndex = REALLOC(dtd.scaffIndex, groupSize * sizeof(int));
    43704458                    }
    43714459                    else
    4372                         groupConnector = (char*)MALLOC(groupSize = 32);
     4460                        groupConnector = MALLOC(groupSize = 32);
    43734461                    if (!groupConnector)
    43744462                        return ERROR_EXPAT_NO_MEMORY;
    … …  
    44144502                    name = poolStoreString(&dtd.pool, enc,
    44154503                                           s + enc->minBytesPerChar,
    4416                                            next - enc->minBytesPerChar);
     4504                                           next - enc->minBytesPerChar,
     4505                                           NULL);
    44174506                    if (!name)
    44184507                        return ERROR_EXPAT_NO_MEMORY;
    4419                     entity = (ENTITY*)lookup(&dtd.paramEntities, name, 0);
     4508                    entity = (ENTITY *) lookup(&dtd.paramEntities, name, 0);
    44204509                    poolDiscard(&dtd.pool);
    44214510                    if (!entity)
    … …  
    44414530                        dtd.complete = 0;
    44424531                        entity->open = 1;
    4443                         if (!externalEntityRefHandler(externalEntityRefHandlerArg,
     4532                        if (!externalEntityRefHandler(handlerArg,       // V0.9.14 (2001-08-09) [umoeller]
     4533                                                      externalEntityRefHandlerArg,
    44444534                                                      0,
    44454535                                                      entity->base,
    … …  
    44854575                    if (elementDeclHandler)
    44864576                    {
    4487                         XMLCONTENT *content = (XMLCONTENT*)MALLOC(sizeof(XMLCONTENT));
     4577                        XMLCONTENT *content = (XMLCONTENT *) MALLOC(sizeof(XMLCONTENT));
    44884578
    44894579                        if (!content)
    … …  
    46144704}
    46154705
    4616 static XMLERROR epilogProcessor(XML_Parser parser,
    4617                                const char *s,
    4618                                const char *end,
    4619                                const char **nextPtr)
     4706static
     4707XMLERROR epilogProcessor(XML_Parser parser,
     4708                         const char *s,
     4709                         const char *end,
     4710                         const char **nextPtr)
    46204711{
    46214712    processor = epilogProcessor;
    … …  
    46784769#ifdef XML_DTD
    46794770
    4680 static XMLERROR processInternalParamEntity(XML_Parser parser, ENTITY * entity)
     4771static XMLERROR
     4772 processInternalParamEntity(XML_Parser parser, ENTITY * entity)
    46814773{
    46824774    const char *s, *end, *next;
    … …  
    47024794#endif /* XML_DTD */
    47034795
    4704 static XMLERROR errorProcessor(XML_Parser parser,
    4705                               const char *s,
    4706                               const char *end,
    4707                               const char **nextPtr)
     4796static
     4797XMLERROR errorProcessor(XML_Parser parser,
     4798                        const char *s,
     4799                        const char *end,
     4800                        const char **nextPtr)
    47084801{
    47094802    return errorCode;
    47104803}
    47114804
    4712 static XMLERROR storeAttributeValue(XML_Parser parser,
    4713                                           const ENCODING * enc,
    4714                                           int isCdata,
    4715                                           const char *ptr,
    4716                                           const char *end,
    4717                                           STRING_POOL * pool)
     4805static XMLERROR
     4806 storeAttributeValue(XML_Parser parser, const ENCODING * enc, int isCdata,
     4807                     const char *ptr, const char *end,
     4808                     STRING_POOL * pool)
    47184809{
    47194810    XMLERROR result = appendAttributeValue(parser, enc, isCdata, ptr, end, pool);
    … …  
    47284819}
    47294820
    4730 static XMLERROR appendAttributeValue(XML_Parser parser, const ENCODING * enc, int isCdata,
    4731                       const char *ptr, const char *end,
    4732                       STRING_POOL * pool)
     4821
     4822/*
     4823 *@@ appendAttributeValue:
     4824 *
     4825 *@@changed V0.9.14 (2001-08-09) [umoeller]: fixed ERROR_EXPAT_UNDEFINED_ENTITY with callback-defined encodings
     4826 */
     4827
     4828static XMLERROR appendAttributeValue(XML_Parser parser,
     4829                                     const ENCODING * enc,
     4830                                     int isCdata,
     4831                                     const char *ptr,
     4832                                     const char *end,
     4833                                     STRING_POOL * pool)
    47334834{
    47344835    for (;;)
    … …  
    47654866                     && (poolLength(pool) == 0 || poolLastChar(pool) == 0x20))
    47664867                        break;
    4767                     n = XmlEncode(n, (ICHAR*)buf);
     4868                    n = XmlEncode(n, (ICHAR *) buf);
    47684869                    if (!n)
    47694870                    {
    … …  
    47804881                break;
    47814882            case XML_TOK_DATA_CHARS:
    4782                 if (!poolAppend(pool, enc, ptr, next))
     4883                if (!poolAppend(pool, enc, ptr, next, NULL))
    47834884                    return ERROR_EXPAT_NO_MEMORY;
     4885                break;
    47844886                break;
    47854887            case XML_TOK_TRAILING_CR:
    … …  
    47974899                    const XML_Char *name;
    47984900                    ENTITY *entity;
     4901                    unsigned long ulOfs; // V0.9.14 (2001-08-09) [umoeller]
    47994902                    XML_Char ch = XmlPredefinedEntityName(enc,
    48004903                                                   ptr + enc->minBytesPerChar,
    … …  
    48094912                    name = poolStoreString(&temp2Pool, enc,
    48104913                                           ptr + enc->minBytesPerChar,
    4811                                            next - enc->minBytesPerChar);
     4914                                           next - enc->minBytesPerChar,
     4915                                           &ulOfs); // V0.9.14 (2001-08-09) [umoeller]
    48124916                    if (!name)
    48134917                        return ERROR_EXPAT_NO_MEMORY;
    4814                     entity = (ENTITY*)lookup(&dtd.generalEntities, name, 0);
     4918                    entity = (ENTITY *) lookup(&dtd.generalEntities,
     4919                                               name + ulOfs, // V0.9.14 (2001-08-09) [umoeller]
     4920                                               0);
    48154921                    poolDiscard(&temp2Pool);
    48164922                    if (!entity)
    … …  
    48644970}
    48654971
    4866 static XMLERROR storeEntityValue(XML_Parser parser,
    4867                                 const ENCODING * enc,
    4868                                 const char *entityTextPtr,
    4869                                 const char *entityTextEnd)
     4972static
     4973XMLERROR storeEntityValue(XML_Parser parser,
     4974                          const ENCODING * enc,
     4975                          const char *entityTextPtr,
     4976                          const char *entityTextEnd)
    48704977{
    48714978    STRING_POOL *pool = &(dtd.pool);
    … …  
    48874994
    48884995                    name = poolStoreString(&tempPool, enc,
    4889                                          entityTextPtr + enc->minBytesPerChar,
    4890                                            next - enc->minBytesPerChar);
     4996                                           entityTextPtr + enc->minBytesPerChar,
     4997                                           next - enc->minBytesPerChar,
     4998                                           NULL);
    48914999                    if (!name)
    48925000                        return ERROR_EXPAT_NO_MEMORY;
    4893                     entity = (ENTITY*)lookup(&dtd.paramEntities, name, 0);
     5001                    entity = (ENTITY *) lookup(&dtd.paramEntities, name, 0);
    48945002                    poolDiscard(&tempPool);
    48955003                    if (!entity)
    … …  
    49285036            case XML_TOK_ENTITY_REF:
    49295037            case XML_TOK_DATA_CHARS:
    4930                 if (!poolAppend(pool, enc, entityTextPtr, next))
     5038                if (!poolAppend(pool, enc, entityTextPtr, next, NULL))
    49315039                    return ERROR_EXPAT_NO_MEMORY;
    49325040                break;
    … …  
    49515059                        return ERROR_EXPAT_BAD_CHAR_REF;
    49525060                    }
    4953                     n = XmlEncode(n, (ICHAR*)buf);
     5061                    n = XmlEncode(n, (ICHAR *) buf);
    49545062                    if (!n)
    49555063                    {
    … …  
    49845092}
    49855093
    4986 static void normalizeLines(XML_Char * s)
     5094static void
     5095 normalizeLines(XML_Char * s)
    49875096{
    49885097    XML_Char *p;
    … …  
    50115120}
    50125121
    5013 static int reportProcessingInstruction(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
     5122static int
     5123 reportProcessingInstruction(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
    50145124{
    50155125    const XML_Char *target;
    … …  
    50255135    start += enc->minBytesPerChar * 2;
    50265136    tem = start + XmlNameLength(enc, start);
    5027     target = poolStoreString(&tempPool, enc, start, tem);
     5137    target = poolStoreString(&tempPool, enc, start, tem, NULL);
    50285138    if (!target)
    50295139        return 0;
    … …  
    50315141    data = poolStoreString(&tempPool, enc,
    50325142                           XmlSkipS(enc, tem),
    5033                            end - enc->minBytesPerChar * 2);
     5143                           end - enc->minBytesPerChar * 2,
     5144                           NULL);
    50345145    if (!data)
    50355146        return 0;
    … …  
    50405151}
    50415152
    5042 static int reportComment(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
     5153static int
     5154 reportComment(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
    50435155{
    50445156    XML_Char *data;
    … …  
    50535165                           enc,
    50545166                           start + enc->minBytesPerChar * 4,
    5055                            end - enc->minBytesPerChar * 3);
     5167                           end - enc->minBytesPerChar * 3,
     5168                           NULL);
    50565169    if (!data)
    50575170        return 0;
    … …  
    50625175}
    50635176
    5064 static void reportDefault(XML_Parser parser, const ENCODING * enc, const char *s, const char *end)
     5177static void
     5178 reportDefault(XML_Parser parser, const ENCODING * enc, const char *s, const char *end)
    50655179{
    50665180    if (MUST_CONVERT(enc, s))
    … …  
    50815195        do
    50825196        {
    5083             ICHAR *dataPtr = (ICHAR*)dataBuf;
    5084 
    5085             XmlConvert(enc, &s, end, &dataPtr, (ICHAR*)dataBufEnd);
     5197            ICHAR *dataPtr = (ICHAR *) dataBuf;
     5198
     5199            XmlConvert(enc, &s, end, &dataPtr, (ICHAR *) dataBufEnd);
    50865200            *eventEndPP = s;
    5087             defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR*)dataBuf);
     5201            defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *) dataBuf);
    50885202            *eventPP = s;
    50895203        }
    … …  
    50915205    }
    50925206    else
    5093         defaultHandler(handlerArg, (XML_Char*)s, (XML_Char*)end - (XML_Char*)s);
    5094 }
    5095 
    5096 
    5097 static int defineAttribute(ELEMENT_TYPE * type, ATTRIBUTE_ID * attId, int isCdata,
     5207        defaultHandler(handlerArg, (XML_Char *) s, (XML_Char *) end - (XML_Char *) s);
     5208}
     5209
     5210
     5211static int
     5212 defineAttribute(ELEMENT_TYPE * type, ATTRIBUTE_ID * attId, int isCdata,
    50985213                 int isId, const XML_Char * value, XML_Parser parser)
    50995214{
    … …  
    51175232        {
    51185233            type->allocDefaultAtts = 8;
    5119             type->defaultAtts = (PDEFAULT_ATTRIBUTE)MALLOC(type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
     5234            type->defaultAtts = MALLOC(type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
    51205235        }
    51215236        else
    51225237        {
    51235238            type->allocDefaultAtts *= 2;
    5124             type->defaultAtts = (PDEFAULT_ATTRIBUTE)REALLOC(type->defaultAtts,
     5239            type->defaultAtts = REALLOC(type->defaultAtts,
    51255240                          type->allocDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
    51265241        }
    … …  
    51565271            if (!poolAppendChar(&dtd.pool, XML_T('\0')))
    51575272                return 0;
    5158             prefix = (PREFIX*)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
     5273            prefix = (PREFIX *) lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
    51595274            if (!prefix)
    51605275                return 0;
    … …  
    51705285}
    51715286
    5172 static ATTRIBUTE_ID* getAttributeId(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
     5287static ATTRIBUTE_ID *
     5288 getAttributeId(XML_Parser parser, const ENCODING * enc, const char *start, const char *end)
    51735289{
    51745290    ATTRIBUTE_ID *id;
    … …  
    51775293    if (!poolAppendChar(&dtd.pool, XML_T('\0')))
    51785294        return 0;
    5179     name = poolStoreString(&dtd.pool, enc, start, end);
     5295    name = poolStoreString(&dtd.pool, enc, start, end, NULL);
    51805296    if (!name)
    51815297        return 0;
    51825298    ++name;
    5183     id = (ATTRIBUTE_ID*)lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID));
     5299    id = (ATTRIBUTE_ID *) lookup(&dtd.attributeIds, name, sizeof(ATTRIBUTE_ID));
    51845300    if (!id)
    51855301        return 0;
    … …  
    52015317                id->prefix = &dtd.defaultPrefix;
    52025318            else
    5203                 id->prefix = (PREFIX*)lookup(&dtd.prefixes, name + 6, sizeof(PREFIX));
     5319                id->prefix = (PREFIX *) lookup(&dtd.prefixes, name + 6, sizeof(PREFIX));
    52045320            id->xmlns = 1;
    52055321        }
    … …  
    52215337                    if (!poolAppendChar(&dtd.pool, XML_T('\0')))
    52225338                        return 0;
    5223                     id->prefix = (PREFIX*)lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
     5339                    id->prefix = (PREFIX *) lookup(&dtd.prefixes, poolStart(&dtd.pool), sizeof(PREFIX));
    52245340                    if (id->prefix->name == poolStart(&dtd.pool))
    52255341                        poolFinish(&dtd.pool);
    … …  
    52365352#define CONTEXT_SEP XML_T('\f')
    52375353
    5238 static const XML_Char *getContext(XML_Parser parser)
     5354static
     5355const XML_Char *getContext(XML_Parser parser)
    52395356{
    52405357    HASH_TABLE_ITER iter;
    … …  
    52635380        int len;
    52645381        const XML_Char *s;
    5265         PREFIX *prefix = (PREFIX*)hashTableIterNext(&iter);
     5382        PREFIX *prefix = (PREFIX *) hashTableIterNext(&iter);
    52665383
    52675384        if (!prefix)
    … …  
    52905407    {
    52915408        const XML_Char *s;
    5292         ENTITY *e = (ENTITY*)hashTableIterNext(&iter);
     5409        ENTITY *e = (ENTITY *) hashTableIterNext(&iter);
    52935410
    52945411        if (!e)
    … …  
    53095426}
    53105427
    5311 static int setContext(XML_Parser parser, const XML_Char * context)
     5428static
     5429int setContext(XML_Parser parser, const XML_Char * context)
    53125430{
    53135431    const XML_Char *s = context;
    … …  
    53215439            if (!poolAppendChar(&tempPool, XML_T('\0')))
    53225440                return 0;
    5323             e = (ENTITY*)lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
     5441            e = (ENTITY *) lookup(&dtd.generalEntities, poolStart(&tempPool), 0);
    53245442            if (e)
    53255443                e->open = 1;
    … …  
    53395457                if (!poolAppendChar(&tempPool, XML_T('\0')))
    53405458                    return 0;
    5341                 prefix = (PREFIX*)lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX));
     5459                prefix = (PREFIX *) lookup(&dtd.prefixes, poolStart(&tempPool), sizeof(PREFIX));
    53425460                if (!prefix)
    53435461                    return 0;
    … …  
    53735491
    53745492
    5375 static void normalizePublicId(XML_Char * publicId)
     5493static
     5494void normalizePublicId(XML_Char * publicId)
    53765495{
    53775496    XML_Char *p = publicId;
    … …  
    53995518static int dtdInit(DTD * p, XML_Parser parser)
    54005519{
    5401     XML_Memory_Handling_Suite *ms = &((Parser*)parser)->m_mem;
     5520    XML_Memory_Handling_Suite *ms = &((Parser *) parser)->m_mem;
    54025521
    54035522    poolInit(&(p->pool), ms);
    … …  
    54455564    for (;;)
    54465565    {
    5447         ELEMENT_TYPE *e = (ELEMENT_TYPE*)hashTableIterNext(&iter);
     5566        ELEMENT_TYPE *e = (ELEMENT_TYPE *) hashTableIterNext(&iter);
    54485567
    54495568        if (!e)
    … …  
    54665585}
    54675586
    5468 /*
    5469  * Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
    5470  * The new DTD has already been initialized.
    5471  *
    5472  */
     5587/* Do a deep copy of the DTD.  Return 0 for out of memory; non-zero otherwise.
     5588 * The new DTD has already been initialized. */
    54735589
    54745590static int dtdCopy(DTD * newDtd, const DTD * oldDtd, XML_Parser parser)
    … …  
    54825598    {
    54835599        const XML_Char *name;
    5484         const PREFIX *oldP = (PREFIX*)hashTableIterNext(&iter);
     5600        const PREFIX *oldP = (PREFIX *) hashTableIterNext(&iter);
    54855601
    54865602        if (!oldP)
    … …  
    55015617        ATTRIBUTE_ID *newA;
    55025618        const XML_Char *name;
    5503         const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID*)hashTableIterNext(&iter);
     5619        const ATTRIBUTE_ID *oldA = (ATTRIBUTE_ID *) hashTableIterNext(&iter);
    55045620
    55055621        if (!oldA)
    … …  
    55125628            return 0;
    55135629        ++name;
    5514         newA = (ATTRIBUTE_ID*)lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
     5630        newA = (ATTRIBUTE_ID *) lookup(&(newDtd->attributeIds), name, sizeof(ATTRIBUTE_ID));
    55155631        if (!newA)
    55165632            return 0;
    … …  
    55225638                newA->prefix = &newDtd->defaultPrefix;
    55235639            else
    5524                 newA->prefix = (PREFIX*)lookup(&(newDtd->prefixes), oldA->prefix->name, 0);
     5640                newA->prefix = (PREFIX *) lookup(&(newDtd->prefixes), oldA->prefix->name, 0);
    55255641        }
    55265642    }
    … …  
    55355651        ELEMENT_TYPE *newE;
    55365652        const XML_Char *name;
    5537         const ELEMENT_TYPE *oldE = (ELEMENT_TYPE*)hashTableIterNext(&iter);
     5653        const ELEMENT_TYPE *oldE = (ELEMENT_TYPE *) hashTableIterNext(&iter);
    55385654
    55395655        if (!oldE)
    … …  
    55425658        if (!name)
    55435659            return 0;
    5544         newE = (ELEMENT_TYPE*)lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
     5660        newE = (ELEMENT_TYPE *) lookup(&(newDtd->elementTypes), name, sizeof(ELEMENT_TYPE));
    55455661        if (!newE)
    55465662            return 0;
    55475663        if (oldE->nDefaultAtts)
    55485664        {
    5549             newE->defaultAtts = (DEFAULT_ATTRIBUTE*)MALLOC(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
     5665            newE->defaultAtts = (DEFAULT_ATTRIBUTE *) MALLOC(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE));
    55505666            if (!newE->defaultAtts)
    55515667                return 0;
    55525668        }
    55535669        if (oldE->idAtt)
    5554             newE->idAtt = (ATTRIBUTE_ID*)lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
     5670            newE->idAtt = (ATTRIBUTE_ID *) lookup(&(newDtd->attributeIds), oldE->idAtt->name, 0);
    55555671        newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts;
    55565672        if (oldE->prefix)
    5557             newE->prefix = (PREFIX*)lookup(&(newDtd->prefixes), oldE->prefix->name, 0);
     5673            newE->prefix = (PREFIX *) lookup(&(newDtd->prefixes), oldE->prefix->name, 0);
    55585674        for (i = 0; i < newE->nDefaultAtts; i++)
    55595675        {
    5560             newE->defaultAtts[i].id = (ATTRIBUTE_ID*)lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
     5676            newE->defaultAtts[i].id = (ATTRIBUTE_ID *) lookup(&(newDtd->attributeIds), oldE->defaultAtts[i].id->name, 0);
    55615677            newE->defaultAtts[i].isCdata = oldE->defaultAtts[i].isCdata;
    55625678            if (oldE->defaultAtts[i].value)
    … …  
    56135729        ENTITY *newE;
    56145730        const XML_Char *name;
    5615         const ENTITY *oldE = (ENTITY*)hashTableIterNext(&iter);
     5731        const ENTITY *oldE = (ENTITY *) hashTableIterNext(&iter);
    56165732
    56175733        if (!oldE)
    … …  
    56205736        if (!name)
    56215737            return 0;
    5622         newE = (ENTITY*)lookup(newTable, name, sizeof(ENTITY));
     5738        newE = (ENTITY *) lookup(newTable, name, sizeof(ENTITY));
    56235739        if (!newE)
    56245740            return 0;
    … …  
    56675783#define INIT_SIZE 64
    56685784
    5669 static int keyeq(KEY s1, KEY s2)
     5785static
     5786int keyeq(KEY s1, KEY s2)
    56705787{
    56715788    for (; *s1 == *s2; s1++, s2++)
    … …  
    56755792}
    56765793
    5677 static unsigned long hash(KEY s)
     5794static
     5795unsigned long hash(KEY s)
    56785796{
    56795797    unsigned long h = 0;
    … …  
    56845802}
    56855803
    5686 static NAMED *lookup(HASH_TABLE * table, KEY name, size_t createSize)
     5804static
     5805NAMED *lookup(HASH_TABLE * table, KEY name, size_t createSize)
    56875806{
    56885807    size_t i;
    … …  
    56955814            return 0;
    56965815        tsize = INIT_SIZE * sizeof(NAMED *);
    5697         table->v = (NAMED**)table->mem->malloc_fcn(tsize);
     5816        table->v = table->mem->malloc_fcn(tsize);
    56985817        if (!table->v)
    56995818            return 0;
    … …  
    57215840            size_t newSize = table->size * 2;
    57225841            size_t tsize = newSize * sizeof(NAMED *);
    5723             NAMED **newV = (NAMED**)table->mem->malloc_fcn(tsize);
     5842            NAMED **newV = table->mem->malloc_fcn(tsize);
    57245843
    57255844            if (!newV)
    … …  
    57475866        }
    57485867    }
    5749     table->v[i] = (NAMED*)table->mem->malloc_fcn(createSize);
     5868    table->v[i] = table->mem->malloc_fcn(createSize);
    57505869    if (!table->v[i])
    57515870        return 0;
    … …  
    57565875}
    57575876
    5758 static void hashTableDestroy(HASH_TABLE * table)
     5877static
     5878void hashTableDestroy(HASH_TABLE * table)
    57595879{
    57605880    size_t i;
    … …  
    57715891}
    57725892
    5773 static void hashTableInit(HASH_TABLE * p, XML_Memory_Handling_Suite * ms)
     5893static
     5894void hashTableInit(HASH_TABLE * p, XML_Memory_Handling_Suite * ms)
    57745895{
    57755896    p->size = 0;
    … …  
    57805901}
    57815902
    5782 static void hashTableIterInit(HASH_TABLE_ITER * iter, const HASH_TABLE * table)
     5903static
     5904void hashTableIterInit(HASH_TABLE_ITER * iter, const HASH_TABLE * table)
    57835905{
    57845906    iter->p = table->v;
    … …  
    57865908}
    57875909
    5788 static NAMED* hashTableIterNext(HASH_TABLE_ITER * iter)
     5910static
     5911NAMED *hashTableIterNext(HASH_TABLE_ITER * iter)
    57895912{
    57905913    while (iter->p != iter->end)
    … …  
    57995922
    58005923
    5801 static void poolInit(STRING_POOL * pool, XML_Memory_Handling_Suite * ms)
     5924static
     5925void poolInit(STRING_POOL * pool, XML_Memory_Handling_Suite * ms)
    58025926{
    58035927    pool->blocks = 0;
    … …  
    58095933}
    58105934
    5811 static void poolClear(STRING_POOL * pool)
     5935static
     5936void poolClear(STRING_POOL * pool)
    58125937{
    58135938    if (!pool->freeBlocks)
    … …  
    58325957}
    58335958
    5834 static void poolDestroy(STRING_POOL * pool)
     5959static
     5960void poolDestroy(STRING_POOL * pool)
    58355961{
    58365962    BLOCK *p = pool->blocks;
    … …  
    58585984}
    58595985
    5860 static XML_Char *poolAppend(STRING_POOL * pool, const ENCODING * enc,
    5861                      const char *ptr, const char *end)
     5986/*
     5987 *@@ poolAppend:
     5988 *      appends a new string to a pool.
     5989 *      Returns pool->start if the pool is valid,
     5990 *      or NULL if storing failed.
     5991 *
     5992 *      V0.9.14: I added the pulOfs parameter which, after
     5993 *      the string was stored, receives the offset from
     5994 *      pool->start at which the string was stored in the
     5995 *      pool. I am not quite sure how all this works, but
     5996 *      if a user-defined encoding is in place (via
     5997 *      XML_SetUnknownEncodingHandler), the first entry
     5998 *      in the pool is always the encoding name from the
     5999 *      xml header, and all entity references failed here
     6000 *      because the lookup would always be done for
     6001 *      the encoding name instead of the entity name
     6002 *      (which then is the second entry in the pool).
     6003 *      Whatever.
     6004 *
     6005 *@@changed V0.9.14 (2001-08-09) [umoeller]: added pulOfs param
     6006 */
     6007
     6008static XML_Char* poolAppend(STRING_POOL * pool,
     6009                            const ENCODING * enc,
     6010                            const char *ptr,
     6011                            const char *end,
     6012                            unsigned long *pulOfs)  // out: offset of beginning of stored
     6013                                                    // string from pool->start
     6014                                                    // V0.9.14 (2001-08-09) [umoeller]
    58626015{
    58636016    if (!pool->ptr && !poolGrow(pool))
    … …  
    58656018    for (;;)
    58666019    {
    5867         XmlConvert(enc, &ptr, end, (ICHAR **) & (pool->ptr), (ICHAR*)pool->end);
     6020        char *pOldStart = pool->ptr;
     6021        XmlConvert(enc,
     6022                   &ptr,                    // fromP
     6023                   end,
     6024                   (ICHAR**)&(pool->ptr),   // toP
     6025                   (ICHAR *)pool->end);
     6026                // expands to:
     6027                // (((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
     6028                // -- for cp850, we end up in
     6029                // -- for Latin1, we end up in
     6030        if (pulOfs)
     6031            *pulOfs = pOldStart - pool->start; // V0.9.14 (2001-08-09) [umoeller]
     6032
    58686033        if (ptr == end)
    58696034            break;
    … …  
    58746039}
    58756040
    5876 static const XML_Char *poolCopyString(STRING_POOL * pool, const XML_Char * s)
     6041static const XML_Char* poolCopyString(STRING_POOL *pool,
     6042                                      const XML_Char *s)
    58776043{
    58786044    do
    … …  
    59026068}
    59036069
    5904 static const XML_Char* poolAppendString(STRING_POOL * pool, const XML_Char * s)
     6070static const XML_Char* poolAppendString(STRING_POOL *pool,
     6071                                        const XML_Char *s)
    59056072{
    59066073    while (*s)
    … …  
    59136080}                               /* End poolAppendString */
    59146081
    5915 static XML_Char* poolStoreString(STRING_POOL * pool, const ENCODING * enc,
    5916                           const char *ptr, const char *end)
    5917 {
    5918     if (!poolAppend(pool, enc, ptr, end))
     6082/*
     6083 *@@ poolStoreString:
     6084 *
     6085 *@@changed V0.9.14 (2001-08-09) [umoeller]: added pulOfs param
     6086 */
     6087
     6088static XML_Char* poolStoreString(STRING_POOL *pool,
     6089                                 const ENCODING *enc,
     6090                                 const char *ptr,
     6091                                 const char *end,
     6092                                 unsigned long *pulOfs) // V0.9.14 (2001-08-09) [umoeller]
     6093{
     6094    if (!poolAppend(pool,
     6095                    enc,
     6096                    ptr,
     6097                    end,
     6098                    pulOfs))    // V0.9.14 (2001-08-09) [umoeller]
    59196099        return 0;
    5920     if (pool->ptr == pool->end && !poolGrow(pool))
     6100    if (    (pool->ptr == pool->end)
     6101         && (!poolGrow(pool))
     6102       )
    59216103        return 0;
    59226104    *(pool->ptr)++ = 0;
    … …  
    59246106}
    59256107
    5926 static int poolGrow(STRING_POOL * pool)
     6108static int poolGrow(STRING_POOL *pool)
    59276109{
    59286110    if (pool->freeBlocks)
    … …  
    59456127            pool->blocks = pool->freeBlocks;
    59466128            pool->freeBlocks = tem;
    5947             memcpy(pool->blocks->s, pool->start, (pool->end - pool->start) * sizeof(XML_Char));
     6129            memcpy(pool->blocks->s,
     6130                   pool->start,
     6131                   (pool->end - pool->start) * sizeof(XML_Char));
    59486132            pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
    59496133            pool->start = pool->blocks->s;
    … …  
    59566140        int blockSize = (pool->end - pool->start) * 2;
    59576141
    5958         pool->blocks = (BLOCK*)pool->mem->realloc_fcn(pool->blocks,
    5959                                                          offsetof(BLOCK, s)
    5960                                                       + blockSize * sizeof(XML_Char));
     6142        pool->blocks = pool->mem->realloc_fcn(pool->blocks, offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
    59616143        if (!pool->blocks)
    59626144            return 0;
    … …  
    59756157        else
    59766158            blockSize *= 2;
    5977         tem = (BLOCK*)pool->mem->malloc_fcn(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
     6159        tem = pool->mem->malloc_fcn(offsetof(BLOCK, s) + blockSize * sizeof(XML_Char));
    59786160        if (!tem)
    59796161            return 0;
    … …  
    59906172}
    59916173
    5992 static int  nextScaffoldPart(XML_Parser parser)
     6174static int
     6175 nextScaffoldPart(XML_Parser parser)
    59936176{
    59946177    CONTENT_SCAFFOLD *me;
    … …  
    59976180    if (!dtd.scaffIndex)
    59986181    {
    5999         dtd.scaffIndex = (int*)MALLOC(groupSize * sizeof(int));
     6182        dtd.scaffIndex = MALLOC(groupSize * sizeof(int));
    60006183
    60016184        if (!dtd.scaffIndex)
    … …  
    60096192        {
    60106193            dtd.scaffSize *= 2;
    6011             dtd.scaffold = (CONTENT_SCAFFOLD*)REALLOC(dtd.scaffold,
     6194            dtd.scaffold = (CONTENT_SCAFFOLD *) REALLOC(dtd.scaffold,
    60126195                                    dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
    60136196        }
    … …  
    60156198        {
    60166199            dtd.scaffSize = 32;
    6017             dtd.scaffold = (CONTENT_SCAFFOLD*)MALLOC(dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
     6200            dtd.scaffold = (CONTENT_SCAFFOLD *) MALLOC(dtd.scaffSize * sizeof(CONTENT_SCAFFOLD));
    60186201        }
    60196202        if (!dtd.scaffold)
    … …  
    60396222}                               /* End nextScaffoldPart */
    60406223
    6041 static void build_node(XML_Parser parser,
     6224static void
     6225 build_node(XML_Parser parser,
    60426226            int src_node,
    60436227            XMLCONTENT * dest,
    … …  
    60816265}                               /* End build_node */
    60826266
    6083 static XMLCONTENT * build_model(XML_Parser parser)
     6267static XMLCONTENT *
     6268 build_model(XML_Parser parser)
    60846269{
    60856270    XMLCONTENT *ret;
    … …  
    60886273    int allocsize = dtd.scaffCount * sizeof(XMLCONTENT) + dtd.contentStringLen;
    60896274
    6090     ret = (XMLCONTENT*)MALLOC(allocsize);
     6275    ret = MALLOC(allocsize);
    60916276    if (!ret)
    60926277        return 0;
    … …  
    60996284}                               /* End build_model */
    61006285
    6101 static ELEMENT_TYPE * getElementType(XML_Parser parser,
     6286static ELEMENT_TYPE *
     6287 getElementType(XML_Parser parser,
    61026288                const ENCODING * enc,
    61036289                const char *ptr,
    61046290                const char *end)
    61056291{
    6106     const XML_Char *name = poolStoreString(&dtd.pool, enc, ptr, end);
     6292    const XML_Char *name = poolStoreString(&dtd.pool, enc, ptr, end, NULL);
    61076293    ELEMENT_TYPE *ret;
    61086294
    61096295    if (!name)
    61106296        return 0;
    6111     ret = (ELEMENT_TYPE*)lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
     6297    ret = (ELEMENT_TYPE *) lookup(&dtd.elementTypes, name, sizeof(ELEMENT_TYPE));
    61126298    if (!ret)
    61136299        return 0;
    … …  
    61226308    return ret;
    61236309}                               /* End getElementType */
    6124 

  • trunk/src/helpers/xmlrole.c

    r75 r97  
    1 
    21/*
    3  *sourcefile xmlrole.c
    4  *      part of the expat implementation. See xmlparse.c.
    5  *
    6  */
    7 
    8 /*
    9  *      Copyright (C) 2001 Ulrich M”ller.
    10  *      Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd.
    11  *                                     and Clark Cooper.
    12  *
    13  *      Permission is hereby granted, free of charge, to any person obtaining
    14  *      a copy of this software and associated documentation files (the
    15  *      "Software"), to deal in the Software without restriction, including
    16  *      without limitation the rights to use, copy, modify, merge, publish,
    17  *      distribute, sublicense, and/or sell copies of the Software, and to
    18  *      permit persons to whom the Software is furnished to do so, subject to
    19  *      the following conditions:
    20  *
    21  *      The above copyright notice and this permission notice shall be included
    22  *      in all copies or substantial portions of the Software.
    23  *
    24  *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    25  *      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    26  *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    27  *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    28  *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    29  *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    30  *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    31  */
    32 
    33 #include "setup.h"
     2Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
     3See the file COPYING for copying permission.
     4*/
     5
     6/* #ifdef COMPILED_FROM_DSP
     7#  include "winconfig.h"
     8#else
     9#  include <config.h>
     10#endif
     11   */
    3412
    3513#include "expat\expat_setup.h"          // V0.9.9 (2001-02-10) [umoeller]
    … …  
    4321
    4422/* Doesn't check:
    45  *
    46  * that ,| are not mixed in a model group
    47  * content of literals
    48  *
    49  */
    50 
    51 static const char KW_ANY[] =
    52 {ASCII_A, ASCII_N, ASCII_Y, '\0'};
    53 static const char KW_ATTLIST[] =
    54 {ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0'};
    55 static const char KW_CDATA[] =
    56 {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
    57 static const char KW_DOCTYPE[] =
    58 {ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0'};
    59 static const char KW_ELEMENT[] =
    60 {ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0'};
    61 static const char KW_EMPTY[] =
    62 {ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0'};
    63 static const char KW_ENTITIES[] =
    64 {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0'};
    65 static const char KW_ENTITY[] =
    66 {ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0'};
    67 static const char KW_FIXED[] =
    68 {ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0'};
    69 static const char KW_ID[] =
    70 {ASCII_I, ASCII_D, '\0'};
    71 static const char KW_IDREF[] =
    72 {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0'};
    73 static const char KW_IDREFS[] =
    74 {ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0'};
    75 static const char KW_IGNORE[] =
    76 {ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0'};
    77 static const char KW_IMPLIED[] =
    78 {ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0'};
    79 static const char KW_INCLUDE[] =
    80 {ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0'};
    81 static const char KW_NDATA[] =
    82 {ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
    83 static const char KW_NMTOKEN[] =
    84 {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0'};
    85 static const char KW_NMTOKENS[] =
    86 {ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0'};
    87 static const char KW_NOTATION[] =
    88 {ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0'};
    89 static const char KW_PCDATA[] =
    90 {ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0'};
    91 static const char KW_PUBLIC[] =
    92 {ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0'};
    93 static const char KW_REQUIRED[] =
    94 {ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0'};
    95 static const char KW_SYSTEM[] =
    96 {ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0'};
     23
     24 that ,| are not mixed in a model group
     25 content of literals
     26
     27*/
     28
     29static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
     30static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
     31static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
     32static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
     33static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
     34static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
     35static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
     36static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
     37static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
     38static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
     39static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
     40static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
     41static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
     42static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
     43static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
     44static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
     45static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
     46static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
     47static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
     48static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
     49static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
     50static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
     51static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
    9752
    9853#ifndef MIN_BYTES_PER_CHAR
    … …  
    10964#endif /* not XML_DTD */
    11065
    111 typedef int EXPATENTRY PROLOG_HANDLER(PROLOG_STATE * state,
    112                                     int tok,
    113                                     const char *ptr,
    114                                     const char *end,
    115                                     const ENCODING * enc);
    116 
    117 static PROLOG_HANDLER prolog0,
    118                       prolog1,
    119                       prolog2,
    120                       doctype0,
    121                       doctype1,
    122                       doctype2,
    123                       doctype3,
    124                       doctype4,
    125                       doctype5,
    126                       internalSubset,
    127                       entity0,
    128                       entity1,
    129                       entity2,
    130                       entity3,
    131                       entity4,
    132                       entity5,
    133                       entity6,
    134                       entity7,
    135                       entity8,
    136                       entity9,
    137                       notation0,
    138                       notation1,
    139                       notation2,
    140                       notation3,
    141                       notation4,
    142                       attlist0,
    143                       attlist1,
    144                       attlist2,
    145                       attlist3,
    146                       attlist4,
    147                       attlist5,
    148                       attlist6,
    149                       attlist7,
    150                       attlist8,
    151                       attlist9,
    152                       element0,
    153                       element1,
    154                       element2,
    155                       element3,
    156                       element4,
    157                       element5,
    158                       element6,
    159                       element7,
     66typedef int PROLOG_HANDLER(PROLOG_STATE *state,
     67               int tok,
     68               const char *ptr,
     69               const char *end,
     70               const ENCODING *enc);
     71
     72static PROLOG_HANDLER
     73  prolog0, prolog1, prolog2,
     74  doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
     75  internalSubset,
     76  entity0, entity1, entity2, entity3, entity4, entity5, entity6,
     77  entity7, entity8, entity9,
     78  notation0, notation1, notation2, notation3, notation4,
     79  attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
     80  attlist7, attlist8, attlist9,
     81  element0, element1, element2, element3, element4, element5, element6,
     82  element7,
    16083#ifdef XML_DTD
    161                       externalSubset0,
    162                       externalSubset1,
    163                       condSect0,
    164                       condSect1,
    165                       condSect2,
    166 #endif
    167                       declClose,
    168                       error;
    169 
    170 static int common(PROLOG_STATE * state, int tok);
    171 
    172 static int EXPATENTRY prolog0(PROLOG_STATE * state,
    173                             int tok,
    174                             const char *ptr,
    175                             const char *end,
    176                             const ENCODING * enc)
    177 {
    178     switch (tok)
    179     {
    180         case XML_TOK_PROLOG_S:
    181             state->handler = prolog1;
    182             return XML_ROLE_NONE;
    183         case XML_TOK_XML_DECL:
    184             state->handler = prolog1;
    185             return XML_ROLE_XML_DECL;
    186         case XML_TOK_PI:
    187             state->handler = prolog1;
    188             return XML_ROLE_NONE;
    189         case XML_TOK_COMMENT:
    190             state->handler = prolog1;
    191         case XML_TOK_BOM:
    192             return XML_ROLE_NONE;
    193         case XML_TOK_DECL_OPEN:
    194             if (!XmlNameMatchesAscii(enc,
    195                                      ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    196                                      end,
    197                                      KW_DOCTYPE))
    198                 break;
    199             state->handler = doctype0;
    200             return XML_ROLE_NONE;
    201         case XML_TOK_INSTANCE_START:
    202             state->handler = error;
    203             return XML_ROLE_INSTANCE_START;
    204     }
    205     return common(state, tok);
    206 }
    207 
    208 static int EXPATENTRY prolog1(PROLOG_STATE * state,
    209                             int tok,
    210                             const char *ptr,
    211                             const char *end,
    212                             const ENCODING * enc)
    213 {
    214     switch (tok)
    215     {
    216         case XML_TOK_PROLOG_S:
    217             return XML_ROLE_NONE;
    218         case XML_TOK_PI:
    219         case XML_TOK_COMMENT:
    220         case XML_TOK_BOM:
    221             return XML_ROLE_NONE;
    222         case XML_TOK_DECL_OPEN:
    223             if (!XmlNameMatchesAscii(enc,
    224                                      ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    225                                      end,
    226                                      KW_DOCTYPE))
    227                 break;
    228             state->handler = doctype0;
    229             return XML_ROLE_NONE;
    230         case XML_TOK_INSTANCE_START:
    231             state->handler = error;
    232             return XML_ROLE_INSTANCE_START;
    233     }
    234     return common(state, tok);
    235 }
    236 
    237 static int EXPATENTRY prolog2(PROLOG_STATE * state,
    238                             int tok,
    239                             const char *ptr,
    240                             const char *end,
    241                             const ENCODING * enc)
    242 {
    243     switch (tok)
    244     {
    245         case XML_TOK_PROLOG_S:
    246             return XML_ROLE_NONE;
    247         case XML_TOK_PI:
    248         case XML_TOK_COMMENT:
    249             return XML_ROLE_NONE;
    250         case XML_TOK_INSTANCE_START:
    251             state->handler = error;
    252             return XML_ROLE_INSTANCE_START;
    253     }
    254     return common(state, tok);
    255 }
    256 
    257 static int EXPATENTRY doctype0(PROLOG_STATE * state,
    258                              int tok,
    259                              const char *ptr,
    260                              const char *end,
    261                              const ENCODING * enc)
    262 {
    263     switch (tok)
    264     {
    265         case XML_TOK_PROLOG_S:
    266             return XML_ROLE_NONE;
    267         case XML_TOK_NAME:
    268         case XML_TOK_PREFIXED_NAME:
    269             state->handler = doctype1;
    270             return XML_ROLE_DOCTYPE_NAME;
    271     }
    272     return common(state, tok);
    273 }
    274 
    275 static int EXPATENTRY doctype1(PROLOG_STATE * state,
    276                              int tok,
    277                              const char *ptr,
    278                              const char *end,
    279                              const ENCODING * enc)
    280 {
    281     switch (tok)
    282     {
    283         case XML_TOK_PROLOG_S:
    284             return XML_ROLE_NONE;
    285         case XML_TOK_OPEN_BRACKET:
    286             state->handler = internalSubset;
    287             return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
    288         case XML_TOK_DECL_CLOSE:
    289             state->handler = prolog2;
    290             return XML_ROLE_DOCTYPE_CLOSE;
    291         case XML_TOK_NAME:
    292             if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM))
    293             {
    294                 state->handler = doctype3;
    295                 return XML_ROLE_NONE;
    296             }
    297             if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC))
    298             {
    299                 state->handler = doctype2;
    300                 return XML_ROLE_NONE;
    301             }
    302             break;
    303     }
    304     return common(state, tok);
    305 }
    306 
    307 static int EXPATENTRY doctype2(PROLOG_STATE * state,
    308                              int tok,
    309                              const char *ptr,
    310                              const char *end,
    311                              const ENCODING * enc)
    312 {
    313     switch (tok)
    314     {
    315         case XML_TOK_PROLOG_S:
    316             return XML_ROLE_NONE;
    317         case XML_TOK_LITERAL:
    318             state->handler = doctype3;
    319             return XML_ROLE_DOCTYPE_PUBLIC_ID;
    320     }
    321     return common(state, tok);
    322 }
    323 
    324 static int EXPATENTRY doctype3(PROLOG_STATE * state,
    325                              int tok,
    326                              const char *ptr,
    327                              const char *end,
    328                              const ENCODING * enc)
    329 {
    330     switch (tok)
    331     {
    332         case XML_TOK_PROLOG_S:
    333             return XML_ROLE_NONE;
    334         case XML_TOK_LITERAL:
    335             state->handler = doctype4;
    336             return XML_ROLE_DOCTYPE_SYSTEM_ID;
    337     }
    338     return common(state, tok);
    339 }
    340 
    341 static int EXPATENTRY doctype4(PROLOG_STATE * state,
    342                              int tok,
    343                              const char *ptr,
    344                              const char *end,
    345                              const ENCODING * enc)
    346 {
    347     switch (tok)
    348     {
    349         case XML_TOK_PROLOG_S:
    350             return XML_ROLE_NONE;
    351         case XML_TOK_OPEN_BRACKET:
    352             state->handler = internalSubset;
    353             return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
    354         case XML_TOK_DECL_CLOSE:
    355             state->handler = prolog2;
    356             return XML_ROLE_DOCTYPE_CLOSE;
    357     }
    358     return common(state, tok);
    359 }
    360 
    361 static int EXPATENTRY doctype5(PROLOG_STATE * state,
    362                              int tok,
    363                              const char *ptr,
    364                              const char *end,
    365                              const ENCODING * enc)
    366 {
    367     switch (tok)
    368     {
    369         case XML_TOK_PROLOG_S:
    370             return XML_ROLE_NONE;
    371         case XML_TOK_DECL_CLOSE:
    372             state->handler = prolog2;
    373             return XML_ROLE_DOCTYPE_CLOSE;
    374     }
    375     return common(state, tok);
    376 }
    377 
    378 static int EXPATENTRY internalSubset(PROLOG_STATE * state,
    379                                    int tok,
    380                                    const char *ptr,
    381                                    const char *end,
    382                                    const ENCODING * enc)
    383 {
    384     switch (tok)
    385     {
    386         case XML_TOK_PROLOG_S:
    387             return XML_ROLE_NONE;
    388         case XML_TOK_DECL_OPEN:
    389             if (XmlNameMatchesAscii(enc,
    390                                     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    391                                     end,
    392                                     KW_ENTITY))
    393             {
    394                 state->handler = entity0;
    395                 return XML_ROLE_NONE;
    396             }
    397             if (XmlNameMatchesAscii(enc,
    398                                     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    399                                     end,
    400                                     KW_ATTLIST))
    401             {
    402                 state->handler = attlist0;
    403                 return XML_ROLE_NONE;
    404             }
    405             if (XmlNameMatchesAscii(enc,
    406                                     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    407                                     end,
    408                                     KW_ELEMENT))
    409             {
    410                 state->handler = element0;
    411                 return XML_ROLE_NONE;
    412             }
    413             if (XmlNameMatchesAscii(enc,
    414                                     ptr + 2 * MIN_BYTES_PER_CHAR(enc),
    415                                     end,
    416                                     KW_NOTATION))
    417             {
    418                 state->handler = notation0;
    419                 return XML_ROLE_NONE;
    420             }
    421             break;
    422         case XML_TOK_PI:
    423         case XML_TOK_COMMENT:
    424             return XML_ROLE_NONE;
    425         case XML_TOK_PARAM_ENTITY_REF:
    426             return XML_ROLE_PARAM_ENTITY_REF;
    427         case XML_TOK_CLOSE_BRACKET:
    428             state->handler = doctype5;
    429             return XML_ROLE_NONE;
    430     }
    431     return common(state, tok);
     84  externalSubset0, externalSubset1,
     85  condSect0, condSect1, condSect2,
     86#endif /* XML_DTD */
     87  declClose,
     88  error;
     89
     90static
     91int common(PROLOG_STATE *state, int tok);
     92
     93static
     94int prolog0(PROLOG_STATE *state,
     95        int tok,
     96        const char *ptr,
     97        const char *end,
     98        const ENCODING *enc)
     99{
     100  switch (tok) {
     101  case XML_TOK_PROLOG_S:
     102    state->handler = prolog1;
     103    return XML_ROLE_NONE;
     104  case XML_TOK_XML_DECL:
     105    state->handler = prolog1;
     106    return XML_ROLE_XML_DECL;
     107  case XML_TOK_PI:
     108    state->handler = prolog1;
     109    return XML_ROLE_NONE;
     110  case XML_TOK_COMMENT:
     111    state->handler = prolog1;
     112  case XML_TOK_BOM:
     113    return XML_ROLE_NONE;
     114  case XML_TOK_DECL_OPEN:
     115    if (!XmlNameMatchesAscii(enc,
     116                 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     117                 end,
     118                 KW_DOCTYPE))
     119      break;
     120    state->handler = doctype0;
     121    return XML_ROLE_NONE;
     122  case XML_TOK_INSTANCE_START:
     123    state->handler = error;
     124    return XML_ROLE_INSTANCE_START;
     125  }
     126  return common(state, tok);
     127}
     128
     129static
     130int prolog1(PROLOG_STATE *state,
     131        int tok,
     132        const char *ptr,
     133        const char *end,
     134        const ENCODING *enc)
     135{
     136  switch (tok) {
     137  case XML_TOK_PROLOG_S:
     138    return XML_ROLE_NONE;
     139  case XML_TOK_PI:
     140  case XML_TOK_COMMENT:
     141  case XML_TOK_BOM:
     142    return XML_ROLE_NONE;
     143  case XML_TOK_DECL_OPEN:
     144    if (!XmlNameMatchesAscii(enc,
     145                 ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     146                 end,
     147                 KW_DOCTYPE))
     148      break;
     149    state->handler = doctype0;
     150    return XML_ROLE_NONE;
     151  case XML_TOK_INSTANCE_START:
     152    state->handler = error;
     153    return XML_ROLE_INSTANCE_START;
     154  }
     155  return common(state, tok);
     156}
     157
     158static
     159int prolog2(PROLOG_STATE *state,
     160        int tok,
     161        const char *ptr,
     162        const char *end,
     163        const ENCODING *enc)
     164{
     165  switch (tok) {
     166  case XML_TOK_PROLOG_S:
     167    return XML_ROLE_NONE;
     168  case XML_TOK_PI:
     169  case XML_TOK_COMMENT:
     170    return XML_ROLE_NONE;
     171  case XML_TOK_INSTANCE_START:
     172    state->handler = error;
     173    return XML_ROLE_INSTANCE_START;
     174  }
     175  return common(state, tok);
     176}
     177
     178static
     179int doctype0(PROLOG_STATE *state,
     180         int tok,
     181         const char *ptr,
     182         const char *end,
     183         const ENCODING *enc)
     184{
     185  switch (tok) {
     186  case XML_TOK_PROLOG_S:
     187    return XML_ROLE_NONE;
     188  case XML_TOK_NAME:
     189  case XML_TOK_PREFIXED_NAME:
     190    state->handler = doctype1;
     191    return XML_ROLE_DOCTYPE_NAME;
     192  }
     193  return common(state, tok);
     194}
     195
     196static
     197int doctype1(PROLOG_STATE *state,
     198         int tok,
     199         const char *ptr,
     200         const char *end,
     201         const ENCODING *enc)
     202{
     203  switch (tok) {
     204  case XML_TOK_PROLOG_S:
     205    return XML_ROLE_NONE;
     206  case XML_TOK_OPEN_BRACKET:
     207    state->handler = internalSubset;
     208    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
     209  case XML_TOK_DECL_CLOSE:
     210    state->handler = prolog2;
     211    return XML_ROLE_DOCTYPE_CLOSE;
     212  case XML_TOK_NAME:
     213    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
     214      state->handler = doctype3;
     215      return XML_ROLE_NONE;
     216    }
     217    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
     218      state->handler = doctype2;
     219      return XML_ROLE_NONE;
     220    }
     221    break;
     222  }
     223  return common(state, tok);
     224}
     225
     226static
     227int doctype2(PROLOG_STATE *state,
     228         int tok,
     229         const char *ptr,
     230         const char *end,
     231         const ENCODING *enc)
     232{
     233  switch (tok) {
     234  case XML_TOK_PROLOG_S:
     235    return XML_ROLE_NONE;
     236  case XML_TOK_LITERAL:
     237    state->handler = doctype3;
     238    return XML_ROLE_DOCTYPE_PUBLIC_ID;
     239  }
     240  return common(state, tok);
     241}
     242
     243static
     244int doctype3(PROLOG_STATE *state,
     245         int tok,
     246         const char *ptr,
     247         const char *end,
     248         const ENCODING *enc)
     249{
     250  switch (tok) {
     251  case XML_TOK_PROLOG_S:
     252    return XML_ROLE_NONE;
     253  case XML_TOK_LITERAL:
     254    state->handler = doctype4;
     255    return XML_ROLE_DOCTYPE_SYSTEM_ID;
     256  }
     257  return common(state, tok);
     258}
     259
     260static
     261int doctype4(PROLOG_STATE *state,
     262         int tok,
     263         const char *ptr,
     264         const char *end,
     265         const ENCODING *enc)
     266{
     267  switch (tok) {
     268  case XML_TOK_PROLOG_S:
     269    return XML_ROLE_NONE;
     270  case XML_TOK_OPEN_BRACKET:
     271    state->handler = internalSubset;
     272    return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
     273  case XML_TOK_DECL_CLOSE:
     274    state->handler = prolog2;
     275    return XML_ROLE_DOCTYPE_CLOSE;
     276  }
     277  return common(state, tok);
     278}
     279
     280static
     281int doctype5(PROLOG_STATE *state,
     282         int tok,
     283         const char *ptr,
     284         const char *end,
     285         const ENCODING *enc)
     286{
     287  switch (tok) {
     288  case XML_TOK_PROLOG_S:
     289    return XML_ROLE_NONE;
     290  case XML_TOK_DECL_CLOSE:
     291    state->handler = prolog2;
     292    return XML_ROLE_DOCTYPE_CLOSE;
     293  }
     294  return common(state, tok);
     295}
     296
     297static
     298int internalSubset(PROLOG_STATE *state,
     299           int tok,
     300           const char *ptr,
     301           const char *end,
     302           const ENCODING *enc)
     303{
     304  switch (tok) {
     305  case XML_TOK_PROLOG_S:
     306    return XML_ROLE_NONE;
     307  case XML_TOK_DECL_OPEN:
     308    if (XmlNameMatchesAscii(enc,
     309                ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     310                end,
     311                KW_ENTITY)) {
     312      state->handler = entity0;
     313      return XML_ROLE_NONE;
     314    }
     315    if (XmlNameMatchesAscii(enc,
     316                ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     317                end,
     318                KW_ATTLIST)) {
     319      state->handler = attlist0;
     320      return XML_ROLE_NONE;
     321    }
     322    if (XmlNameMatchesAscii(enc,
     323                ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     324                end,
     325                KW_ELEMENT)) {
     326      state->handler = element0;
     327      return XML_ROLE_NONE;
     328    }
     329    if (XmlNameMatchesAscii(enc,
     330                ptr + 2 * MIN_BYTES_PER_CHAR(enc),
     331                end,
     332                KW_NOTATION)) {
     333      state->handler = notation0;
     334      return XML_ROLE_NONE;
     335    }
     336    break;
     337  case XML_TOK_PI:
     338  case XML_TOK_COMMENT:
     339    return XML_ROLE_NONE;
     340  case XML_TOK_PARAM_ENTITY_REF:
     341    return XML_ROLE_PARAM_ENTITY_REF;
     342  case XML_TOK_CLOSE_BRACKET:
     343    state->handler = doctype5;
     344    return XML_ROLE_NONE;
     345  }
     346  return common(state, tok);
    432347}
    433348
    434349#ifdef XML_DTD
    435350
    436 static int EXPATENTRY externalSubset0(PROLOG_STATE * state,
    437                                     int tok,
    438                                     const char *ptr,
    439                                     const char *end,
    440                                     const ENCODING * enc)
    441 {
    442     state->handler = externalSubset1;
    443     if (tok == XML_TOK_XML_DECL)
    444         return XML_ROLE_TEXT_DECL;
    445     return externalSubset1(state, tok, ptr, end, enc);
    446 }
    447 
    448 static
    449 int externalSubset1(PROLOG_STATE * state,
    450                     int tok,
    451                     const char *ptr,
    452                     const char *end,
    453                     const ENCODING * enc)
    454 {
    455     switch (tok)
    456     {
    457         case XML_TOK_COND_SECT_OPEN:
    458             state->handler = condSect0;
    459             return XML_ROLE_NONE;
    460         case XML_TOK_COND_SECT_CLOSE:
    461             if (state->includeLevel == 0)
    462                 break;
    463             state->includeLevel -= 1;
    464             return XML_ROLE_NONE;
    465         case XML_TOK_PROLOG_S:
    466             return XML_ROLE_NONE;
    467         case XML_TOK_CLOSE_BRACKET:
    468             break;
    469         case XML_TOK_NONE:
    470             if (state->includeLevel)
    471                 break;
    472             return XML_ROLE_NONE;
    473         default:
    474             return internalSubset(state, tok, ptr, end, enc);
    475     }
    476     return common(state, tok);
    477 }
    478 
    479 #endif /* XML_DTD */
    480 
    481 static
    482 int entity0(PROLOG_STATE * state,
     351static
     352int externalSubset0(PROLOG_STATE *state,
    483353            int tok,
    484354            const char *ptr,
    485355            const char *end,
    486             const ENCODING * enc)
    487 {
    488     switch (tok)
    489     {
    490         case XML_TOK_PROLOG_S:
    491             return XML_ROLE_NONE;
    492         case XML_TOK_PERCENT:
    493             state->handler = entity1;
    494             return XML_ROLE_NONE;
    495         case XML_TOK_NAME:
    496             state->handler = entity2;
    497             return XML_ROLE_GENERAL_ENTITY_NAME;
    498     }
    499     return common(state, tok);
    500 }
    501 
    502 static
    503 int entity1(PROLOG_STATE * state,
     356            const ENCODING *enc)
     357{
     358  state->handler = externalSubset1;
     359  if (tok == XML_TOK_XML_DECL)
     360    return XML_ROLE_TEXT_DECL;
     361  return externalSubset1(state, tok, ptr, end, enc);
     362}
     363
     364static
     365int externalSubset1(PROLOG_STATE *state,
    504366            int tok,
    505367            const char *ptr,
    506368            const char *end,
    507             const ENCODING * enc)
    508 {
    509     switch (tok)
    510     {
    511         case XML_TOK_PROLOG_S:
    512             return XML_ROLE_NONE;
    513         case XML_TOK_NAME:
    514             state->handler = entity7;
    515             return XML_ROLE_PARAM_ENTITY_NAME;
    516     }
    517     return common(state, tok);
    518 }
    519 
    520 static
    521 int entity2(PROLOG_STATE * state,
    522             int tok,
    523             const char *ptr,
    524             const char *end,
    525             const ENCODING * enc)
    526 {
    527     switch (tok)
    528     {
    529         case XML_TOK_PROLOG_S:
    530             return XML_ROLE_NONE;
    531         case XML_TOK_NAME:
    532             if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM))
    533             {
    534                 state->handler = entity4;
    535                 return XML_ROLE_NONE;
    536             }
    537             if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC))
    538             {
    539                 state->handler = entity3;
    540                 return XML_ROLE_NONE;
    541             }
    542             break;
    543         case XML_TOK_LITERAL:
    544             state->handler = declClose;
    545             return XML_ROLE_ENTITY_VALUE;
    546     }
    547     return common(state, tok);
    548 }
    549 
    550 static
    551 int entity3(PROLOG_STATE * state,
    552             int tok,
    553             const char *ptr,
    554             const char *end,
    555             const ENCODING * enc)
    556 {
    557     switch (tok)
    558     {
    559         case XML_TOK_PROLOG_S:
    560             return XML_ROLE_NONE;
    561         case XML_TOK_LITERAL:
    562             state->handler = entity4;
    563             return XML_ROLE_ENTITY_PUBLIC_ID;
    564     }
    565     return common(state, tok);
    566 }
    567 
    568 
    569 static
    570 int entity4(PROLOG_STATE * state,
    571             int tok,
    572             const char *ptr,
    573             const char *end,
    574             const ENCODING * enc)
    575 {
    576     switch (tok)
    577     {
    578         case XML_TOK_PROLOG_S:
    579             return XML_ROLE_NONE;
    580         case XML_TOK_LITERAL:
    581             state->handler = entity5;
    582             return XML_ROLE_ENTITY_SYSTEM_ID;
    583     }
    584     return common(state, tok);
    585 }
    586 
    587 static
    588 int entity5(PROLOG_STATE * state,
    589             int tok,
    590             const char *ptr,
    591             const char *end,
    592             const ENCODING * enc)
    593 {
    594     switch (tok)
    595     {
    596         case XML_TOK_PROLOG_S:
    597             return XML_ROLE_NONE;
    598         case XML_TOK_DECL_CLOSE:
    599             setTopLevel(state);
    600             return XML_ROLE_ENTITY_COMPLETE;
    601         case XML_TOK_NAME:
    602             if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA))
    603             {
    604                 state->handler = entity6;
    605                 return XML_ROLE_NONE;
    606             }
    607             break;
    608     }
    609     return common(state, tok);
    610 }
    611 
    612 static
    613 int entity6(PROLOG_STATE * state,
    614             int tok,
    615             const char *ptr,
    616             const char *end,
    617             const ENCODING * enc)
    618 {
    619     switch (tok)
    620     {
    621         case XML_TOK_PROLOG_S:
    622             return XML_ROLE_NONE;
    623         case XML_TOK_NAME:
    624             state->handler = declClose;
    625             return XML_ROLE_ENTITY_NOTATION_NAME;
    626     }
    627     return common(state, tok);
    628 }
    629 
    630 static
    631 int entity7(PROLOG_STATE * state,
    632             int tok,
    633             const char *ptr,
    634             const char *end,
    635             const ENCODING * enc)
    636 {
    637     switch (tok)
    638     {
    639         case XML_TOK_PROLOG_S:
    640             return XML_ROLE_NONE;
    641         case XML_TOK_NAME:
    642             if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM))
    643             {
    644                 state->handler = entity9;
    645                 return XML_ROLE_NONE;
    646             }
    647             if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC))
    648             {
    649                 state->handler = entity8;
    650                 return XML_ROLE_NONE;
    651             }
    652             break;
    653         case XML_TOK_LITERAL:
    654             state->handler = declClose;
    655             return XML_ROLE_ENTITY_VALUE;
    656     }
    657     return common(state, tok);
    658 }
    659 
    660 static
    661 int entity8(PROLOG_STATE * state,
    662             int tok,
    663             const char *ptr,
    664             const char *end,
    665             const ENCODING * enc)
    666 {
    667     switch (tok)
    668     {
    669         case XML_TOK_PROLOG_S:
    670             return XML_ROLE_NONE;
    671         case XML_TOK_LITERAL:
    672             state->handler = entity9;
    673             return XML_ROLE_ENTITY_PUBLIC_ID;
    674     }
    675     return common(state, tok);
    676 }
    677 
    678 static
    679 int entity9(PROLOG_STATE * state,
    680             int tok,
    681             const char *ptr,
    682             const char *end,
    683             const ENCODING * enc)
    684 {
    685     switch (tok)
    686     {
    687         case XML_TOK_PROLOG_S:
    688             return XML_ROLE_NONE;
    689         case XML_TOK_LITERAL:
    690             state->handler = declClose;
    691             return XML_ROLE_ENTITY_SYSTEM_ID;
    692     }
    693     return common(state, tok);
    694 }
    695 
    696 static
    697 int notation0(PROLOG_STATE * state,
    698               int tok,
    699               const char *ptr,
    700               const char *end,
    701               const ENCODING * enc)
    702 {
    703     switch (tok)
    704     {
    705         case XML_TOK_PROLOG_S:
    706             return XML_ROLE_NONE;
    707         case XML_TOK_NAME:
    708             state->handler = notation1;
    709             return XML_ROLE_NOTATION_NAME;
    710     }
    711     return common(state, tok);
    712 }
    713 
    714 static
    715 int notation1(PROLOG_STATE * state,
    716               int tok,
    717               const char *ptr,
    718               const char *end,
    719               const ENCODING * enc)
    720 {
    721     switch (tok)
    722     {
    723         case XML_TOK_PROLOG_S:
    724             return XML_ROLE_NONE;
    725         case XML_TOK_NAME:
    726             if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM))
    727             {
    728                 state->handler = notation3;
    729                 return XML_ROLE_NONE;
    730             }
    731             if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC))
    732             {
    733                 state->handler = notation2;
    734                 return XML_ROLE_NONE;
    735             }
    736             break;
    737     }
    738     return common(state, tok);
    739 }
    740 
    741 static
    742 int notation2(PROLOG_STATE * state,
    743               int tok,
    744               const char *ptr,
    745               const char *end,
    746               const ENCODING * enc)
    747 {
    748     switch (tok)
    749     {
    750         case XML_TOK_PROLOG_S:
    751             return XML_ROLE_NONE;
    752         case XML_TOK_LITERAL:
    753             state->handler = notation4;
    754             return XML_ROLE_NOTATION_PUBLIC_ID;
    755     }
    756     return common(state, tok);
    757 }
    758 
    759 static
    760 int notation3(PROLOG_STATE * state,
    761               int tok,
    762               const char *ptr,
    763               const char *end,
    764               const ENCODING * enc)
    765 {
    766     switch (tok)
    767     {
    768         case XML_TOK_PROLOG_S:
    769             return XML_ROLE_NONE;
    770         case XML_TOK_LITERAL:
    771             state->handler = declClose;
    772             return XML_ROLE_NOTATION_SYSTEM_ID;
    773     }
    774     return common(state, tok);
    775 }
    776 
    777 static
    778 int notation4(PROLOG_STATE * state,
    779               int tok,
    780               const char *ptr,
    781               const char *end,
    782               const ENCODING * enc)
    783 {
    784     switch (tok)
    785     {
    786         case XML_TOK_PROLOG_S:
    787             return XML_ROLE_NONE;
    788         case XML_TOK_LITERAL:
    789             state->handler = declClose;
    790             return XML_ROLE_NOTATION_SYSTEM_ID;
    791         case XML_TOK_DECL_CLOSE:
    792             setTopLevel(state);
    793             return XML_ROLE_NOTATION_NO_SYSTEM_ID;
    794     }
    795     return common(state, tok);
    796 }
    797 
    798 static
    799 int attlist0(PROLOG_STATE * state,
    800              int tok,
    801              const char *ptr,
    802              const char *end,
    803              const ENCODING * enc)
    804 {
    805     switch (tok)
    806     {
    807         case XML_TOK_PROLOG_S:
    808             return XML_ROLE_NONE;
    809         case XML_TOK_NAME:
    810         case XML_TOK_PREFIXED_NAME:
    811             state->handler = attlist1;
    812             return XML_ROLE_ATTLIST_ELEMENT_NAME;
    813     }
    814     return common(state, tok);
    815 }
    816 
    817 static
    818 int attlist1(PROLOG_STATE * state,
    819              int tok,
    820              const char *ptr,
    821              const char *end,
    822              const ENCODING * enc)
    823 {
    824     switch (tok)
    825     {
    826         case XML_TOK_PROLOG_S:
    827             return XML_ROLE_NONE;
    828         case XML_TOK_DECL_CLOSE:
    829             setTopLevel(state);
    830             return XML_ROLE_NONE;
    831         case XML_TOK_NAME:
    832         case XML_TOK_PREFIXED_NAME:
    833             state->handler = attlist2;
    834             return XML_ROLE_ATTRIBUTE_NAME;
    835     }
    836     return common(state, tok);
    837 }
    838 
    839 static
    840 int attlist2(PROLOG_STATE * state,
    841              int tok,
    842              const char *ptr,
    843              const char *end,
    844              const ENCODING * enc)
    845 {
    846     switch (tok)
    847     {
    848         case XML_TOK_PROLOG_S:
    849             return XML_ROLE_NONE;
    850         case XML_TOK_NAME:
    851             {
    852                 static const char *types[] =
    853                 {
    854                     KW_CDATA,
    855                     KW_ID,
    856                     KW_IDREF,
    857                     KW_IDREFS,
    858                     KW_ENTITY,
    859                     KW_ENTITIES,
    860                     KW_NMTOKEN,
    861                     KW_NMTOKENS,
    862                 };
    863                 int i;
    864 
    865                 for (i = 0; i < (int)(sizeof(types) / sizeof(types[0])); i++)
    866                     if (XmlNameMatchesAscii(enc, ptr, end, types[i]))
    867                     {
    868                         state->handler = attlist8;
    869                         return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
    870                     }
    871             }
    872             if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION))
    873             {
    874                 state->handler = attlist5;
    875                 return XML_ROLE_NONE;
    876             }
    877             break;
    878         case XML_TOK_OPEN_PAREN:
    879             state->handler = attlist3;
    880             return XML_ROLE_NONE;
    881     }
    882     return common(state, tok);
    883 }
    884 
    885 static
    886 int attlist3(PROLOG_STATE * state,
    887              int tok,
    888              const char *ptr,
    889              const char *end,
    890              const ENCODING * enc)
    891 {
    892     switch (tok)
    893     {
    894         case XML_TOK_PROLOG_S:
    895             return XML_ROLE_NONE;
    896         case XML_TOK_NMTOKEN:
    897         case XML_TOK_NAME:
    898         case XML_TOK_PREFIXED_NAME:
    899             state->handler = attlist4;
    900             return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
    901     }
    902     return common(state, tok);
    903 }
    904 
    905 static
    906 int attlist4(PROLOG_STATE * state,
    907              int tok,
    908              const char *ptr,
    909              const char *end,
    910              const ENCODING * enc)
    911 {
    912     switch (tok)
    913     {
    914         case XML_TOK_PROLOG_S:
    915             return XML_ROLE_NONE;
    916         case XML_TOK_CLOSE_PAREN:
    917             state->handler = attlist8;
    918             return XML_ROLE_NONE;
    919         case XML_TOK_OR:
    920             state->handler = attlist3;
    921             return XML_ROLE_NONE;
    922     }
    923     return common(state, tok);
    924 }
    925 
    926 static
    927 int attlist5(PROLOG_STATE * state,
    928              int tok,
    929              const char *ptr,
    930              const char *end,
    931              const ENCODING * enc)
    932 {
    933     switch (tok)
    934     {
    935         case XML_TOK_PROLOG_S:
    936             return XML_ROLE_NONE;
    937         case XML_TOK_OPEN_PAREN:
    938             state->handler = attlist6;
    939             return XML_ROLE_NONE;
    940     }
    941     return common(state, tok);
    942 }
    943 
    944 
    945 static
    946 int attlist6(PROLOG_STATE * state,
    947              int tok,
    948              const char *ptr,
    949              const char *end,
    950              const ENCODING * enc)
    951 {
    952     switch (tok)
    953     {
    954         case XML_TOK_PROLOG_S:
    955             return XML_ROLE_NONE;
    956         case XML_TOK_NAME:
    957             state->handler = attlist7;
    958             return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
    959     }
    960     return common(state, tok);
    961 }
    962 
    963 static
    964 int attlist7(PROLOG_STATE * state,
    965              int tok,
    966              const char *ptr,
    967              const char *end,
    968              const ENCODING * enc)
    969 {
    970     switch (tok)
    971     {
    972         case XML_TOK_PROLOG_S:
    973             return XML_ROLE_NONE;
    974         case XML_TOK_CLOSE_PAREN:
    975             state->handler = attlist8;
    976             return XML_ROLE_NONE;
    977         case XML_TOK_OR:
    978             state->handler = attlist6;
    979             return XML_ROLE_NONE;
    980     }
    981     return common(state, tok);
    982 }
    983 
    984 /* default value */
    985 static
    986 int attlist8(PROLOG_STATE * state,
    987              int tok,
    988              const char *ptr,
    989              const char *end,
    990              const ENCODING * enc)
    991 {
    992     switch (tok)
    993     {
    994         case XML_TOK_PROLOG_S:
    995             return XML_ROLE_NONE;
    996         case XML_TOK_POUND_NAME:
    997             if (XmlNameMatchesAscii(enc,
    998                                     ptr + MIN_BYTES_PER_CHAR(enc),
    999                                     end,
    1000                                     KW_IMPLIED))
    1001             {
    1002                 state->handler = attlist1;
    1003                 return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
    1004             }
    1005             if (XmlNameMatchesAscii(enc,
    1006                                     ptr + MIN_BYTES_PER_CHAR(enc),
    1007                                     end,
    1008                                     KW_REQUIRED))
    1009             {
    1010                 state->handler = attlist1;
    1011                 return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
    1012             }
    1013             if (XmlNameMatchesAscii(enc,
    1014                                     ptr + MIN_BYTES_PER_CHAR(enc),
    1015                                     end,
    1016                                     KW_FIXED))
    1017             {
    1018                 state->handler = attlist9;
    1019                 return XML_ROLE_NONE;
    1020             }
    1021             break;
    1022         case XML_TOK_LITERAL:
    1023             state->handler = attlist1;
    1024             return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
    1025     }
    1026     return common(state, tok);
    1027 }
    1028 
    1029 static
    1030 int attlist9(PROLOG_STATE * state,
    1031              int tok,
    1032              const char *ptr,
    1033              const char *end,
    1034              const ENCODING * enc)
    1035 {
    1036     switch (tok)
    1037     {
    1038         case XML_TOK_PROLOG_S:
    1039             return XML_ROLE_NONE;
    1040         case XML_TOK_LITERAL:
    1041             state->handler = attlist1;
    1042             return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
    1043     }
    1044     return common(state, tok);
    1045 }
    1046 
    1047 static
    1048 int element0(PROLOG_STATE * state,
    1049              int tok,
    1050              const char *ptr,
    1051              const char *end,
    1052              const ENCODING * enc)
    1053 {
    1054     switch (tok)
    1055     {
    1056         case XML_TOK_PROLOG_S:
    1057             return XML_ROLE_NONE;
    1058         case XML_TOK_NAME:
    1059         case XML_TOK_PREFIXED_NAME:
    1060             state->handler = element1;
    1061             return XML_ROLE_ELEMENT_NAME;
    1062     }
    1063     return common(state, tok);
    1064 }
    1065 
    1066 static
    1067 int element1(PROLOG_STATE * state,
    1068              int tok,
    1069              const char *ptr,
    1070              const char *end,
    1071              const ENCODING * enc)
    1072 {
    1073     switch (tok)
    1074     {
    1075         case XML_TOK_PROLOG_S:
    1076             return XML_ROLE_NONE;
    1077         case XML_TOK_NAME:
    1078             if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY))
    1079             {
    1080                 state->handler = declClose;
    1081                 return XML_ROLE_CONTENT_EMPTY;
    1082             }
    1083             if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY))
    1084             {
    1085                 state->handler = declClose;
    1086                 return XML_ROLE_CONTENT_ANY;
    1087             }
    1088             break;
    1089         case XML_TOK_OPEN_PAREN:
    1090             state->handler = element2;
    1091             state->level = 1;
    1092             return XML_ROLE_GROUP_OPEN;
    1093     }
    1094     return common(state, tok);
    1095 }
    1096 
    1097 static
    1098 int element2(PROLOG_STATE * state,
    1099              int tok,
    1100              const char *ptr,
    1101              const char *end,
    1102              const ENCODING * enc)
    1103 {
    1104     switch (tok)
    1105     {
    1106         case XML_TOK_PROLOG_S:
    1107             return XML_ROLE_NONE;
    1108         case XML_TOK_POUND_NAME:
    1109             if (XmlNameMatchesAscii(enc,
    1110                                     ptr + MIN_BYTES_PER_CHAR(enc),
    1111                                     end,
    1112                                     KW_PCDATA))
    1113             {
    1114                 state->handler = element3;
    1115                 return XML_ROLE_CONTENT_PCDATA;
    1116             }
    1117             break;
    1118         case XML_TOK_OPEN_PAREN:
    1119             state->level = 2;
    1120             state->handler = element6;
    1121             return XML_ROLE_GROUP_OPEN;
    1122         case XML_TOK_NAME:
    1123         case XML_TOK_PREFIXED_NAME:
    1124             state->handler = element7;
    1125             return XML_ROLE_CONTENT_ELEMENT;
    1126         case XML_TOK_NAME_QUESTION:
    1127             state->handler = element7;
    1128             return XML_ROLE_CONTENT_ELEMENT_OPT;
    1129         case XML_TOK_NAME_ASTERISK:
    1130             state->handler = element7;
    1131             return XML_ROLE_CONTENT_ELEMENT_REP;
    1132         case XML_TOK_NAME_PLUS:
    1133             state->handler = element7;
    1134             return XML_ROLE_CONTENT_ELEMENT_PLUS;
    1135     }
    1136     return common(state, tok);
    1137 }
    1138 
    1139 static
    1140 int element3(PROLOG_STATE * state,
    1141              int tok,
    1142              const char *ptr,
    1143              const char *end,
    1144              const ENCODING * enc)
    1145 {
    1146     switch (tok)
    1147     {
    1148         case XML_TOK_PROLOG_S:
    1149             return XML_ROLE_NONE;
    1150         case XML_TOK_CLOSE_PAREN:
    1151             state->handler = declClose;
    1152             return XML_ROLE_GROUP_CLOSE;
    1153         case XML_TOK_CLOSE_PAREN_ASTERISK:
    1154             state->handler = declClose;
    1155             return XML_ROLE_GROUP_CLOSE_REP;
    1156         case XML_TOK_OR:
    1157             state->handler = element4;
    1158             return XML_ROLE_NONE;
    1159     }
    1160     return common(state, tok);
    1161 }
    1162 
    1163 static
    1164 int element4(PROLOG_STATE * state,
    1165              int tok,
    1166              const char *ptr,
    1167              const char *end,
    1168              const ENCODING * enc)
    1169 {
    1170     switch (tok)
    1171     {
    1172         case XML_TOK_PROLOG_S:
    1173             return XML_ROLE_NONE;
    1174         case XML_TOK_NAME:
    1175         case XML_TOK_PREFIXED_NAME:
    1176             state->handler = element5;
    1177             return XML_ROLE_CONTENT_ELEMENT;
    1178     }
    1179     return common(state, tok);
    1180 }
    1181 
    1182 static
    1183 int element5(PROLOG_STATE * state,
    1184              int tok,
    1185              const char *ptr,
    1186              const char *end,
    1187              const ENCODING * enc)
    1188 {
    1189     switch (tok)
    1190     {
    1191         case XML_TOK_PROLOG_S:
    1192             return XML_ROLE_NONE;
    1193         case XML_TOK_CLOSE_PAREN_ASTERISK:
    1194             state->handler = declClose;
    1195             return XML_ROLE_GROUP_CLOSE_REP;
    1196         case XML_TOK_OR:
    1197             state->handler = element4;
    1198             return XML_ROLE_NONE;
    1199     }
    1200     return common(state, tok);
    1201 }
    1202 
    1203 static
    1204 int element6(PROLOG_STATE * state,
    1205              int tok,
    1206              const char *ptr,
    1207              const char *end,
    1208              const ENCODING * enc)
    1209 {
    1210     switch (tok)
    1211     {
    1212         case XML_TOK_PROLOG_S:
    1213             return XML_ROLE_NONE;
    1214         case XML_TOK_OPEN_PAREN:
    1215             state->level += 1;
    1216             return XML_ROLE_GROUP_OPEN;
    1217         case XML_TOK_NAME:
    1218         case XML_TOK_PREFIXED_NAME:
    1219             state->handler = element7;
    1220             return XML_ROLE_CONTENT_ELEMENT;
    1221         case XML_TOK_NAME_QUESTION:
    1222             state->handler = element7;
    1223             return XML_ROLE_CONTENT_ELEMENT_OPT;
    1224         case XML_TOK_NAME_ASTERISK:
    1225             state->handler = element7;
    1226             return XML_ROLE_CONTENT_ELEMENT_REP;
    1227         case XML_TOK_NAME_PLUS:
    1228             state->handler = element7;
    1229             return XML_ROLE_CONTENT_ELEMENT_PLUS;
    1230     }
    1231     return common(state, tok);
    1232 }
    1233 
    1234 static
    1235 int element7(PROLOG_STATE * state,
    1236              int tok,
    1237              const char *ptr,
    1238              const char *end,
    1239              const ENCODING * enc)
    1240 {
    1241     switch (tok)
    1242     {
    1243         case XML_TOK_PROLOG_S:
    1244             return XML_ROLE_NONE;
    1245         case XML_TOK_CLOSE_PAREN:
    1246             state->level -= 1;
    1247             if (state->level == 0)
    1248                 state->handler = declClose;
    1249             return XML_ROLE_GROUP_CLOSE;
    1250         case XML_TOK_CLOSE_PAREN_ASTERISK:
    1251             state->level -= 1;
    1252             if (state->level == 0)
    1253                 state->handler = declClose;
    1254             return XML_ROLE_GROUP_CLOSE_REP;
    1255         case XML_TOK_CLOSE_PAREN_QUESTION:
    1256             state->level -= 1;
    1257             if (state->level == 0)
    1258                 state->handler = declClose;
    1259             return XML_ROLE_GROUP_CLOSE_OPT;
    1260         case XML_TOK_CLOSE_PAREN_PLUS:
    1261             state->level -= 1;
    1262             if (state->level == 0)
    1263                 state->handler = declClose;
    1264             return XML_ROLE_GROUP_CLOSE_PLUS;
    1265         case XML_TOK_COMMA:
    1266             state->handler = element6;
    1267             return XML_ROLE_GROUP_SEQUENCE;
    1268         case XML_TOK_OR:
    1269             state->handler = element6;
    1270             return XML_ROLE_GROUP_CHOICE;
    1271     }
    1272     return common(state, tok);
    1273 }
    1274 
    1275 #ifdef XML_DTD
    1276 
    1277 static
    1278 int condSect0(PROLOG_STATE * state,
    1279               int tok,
    1280               const char *ptr,
    1281               const char *end,
    1282               const ENCODING * enc)
    1283 {
    1284     switch (tok)
    1285     {
    1286         case XML_TOK_PROLOG_S:
    1287             return XML_ROLE_NONE;
    1288         case XML_TOK_NAME:
    1289             if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE))
    1290             {
    1291                 state->handler = condSect1;
    1292                 return XML_ROLE_NONE;
    1293             }
    1294             if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE))
    1295             {
    1296                 state->handler = condSect2;
    1297                 return XML_ROLE_NONE;
    1298             }
    1299             break;
    1300     }
    1301     return common(state, tok);
    1302 }
    1303 
    1304 static
    1305 int condSect1(PROLOG_STATE * state,
    1306               int tok,
    1307               const char *ptr,
    1308               const char *end,
    1309               const ENCODING * enc)
    1310 {
    1311     switch (tok)
    1312     {
    1313         case XML_TOK_PROLOG_S:
    1314             return XML_ROLE_NONE;
    1315         case XML_TOK_OPEN_BRACKET:
    1316             state->handler = externalSubset1;
    1317             state->includeLevel += 1;
    1318             return XML_ROLE_NONE;
    1319     }
    1320     return common(state, tok);
    1321 }
    1322 
    1323 static
    1324 int condSect2(PROLOG_STATE * state,
    1325               int tok,
    1326               const char *ptr,
    1327               const char *end,
    1328               const ENCODING * enc)
    1329 {
    1330     switch (tok)
    1331     {
    1332         case XML_TOK_PROLOG_S:
    1333             return XML_ROLE_NONE;
    1334         case XML_TOK_OPEN_BRACKET:
    1335             state->handler = externalSubset1;
    1336             return XML_ROLE_IGNORE_SECT;
    1337     }
    1338     return common(state, tok);
     369            const ENCODING *enc)
     370{
     371  switch (tok) {
     372  case XML_TOK_COND_SECT_OPEN:
     373    state->handler = condSect0;
     374    return XML_ROLE_NONE;
     375  case XML_TOK_COND_SECT_CLOSE:
     376    if (state->includeLevel == 0)
     377      break;
     378    state->includeLevel -= 1;
     379    return XML_ROLE_NONE;
     380  case XML_TOK_PROLOG_S:
     381    return XML_ROLE_NONE;
     382  case XML_TOK_CLOSE_BRACKET:
     383    break;
     384  case XML_TOK_NONE:
     385    if (state->includeLevel)
     386      break;
     387    return XML_ROLE_NONE;
     388  default:
     389    return internalSubset(state, tok, ptr, end, enc);
     390  }
     391  return common(state, tok);
    1339392}
    1340393
    … …  
    1342395
    1343396static
    1344 int declClose(PROLOG_STATE * state,
    1345               int tok,
    1346               const char *ptr,
    1347               const char *end,
    1348               const ENCODING * enc)
    1349 {
    1350     switch (tok)
    1351     {
    1352         case XML_TOK_PROLOG_S:
    1353             return XML_ROLE_NONE;
    1354         case XML_TOK_DECL_CLOSE:
    1355             setTopLevel(state);
    1356             return XML_ROLE_NONE;
    1357     }
    1358     return common(state, tok);
    1359 }
    1360 
    1361 #if 0
    1362 
    1363 static
    1364 int ignore(PROLOG_STATE * state,
    1365            int tok,
    1366            const char *ptr,
    1367            const char *end,
    1368            const ENCODING * enc)
    1369 {
    1370     switch (tok)
    1371     {
    1372         case XML_TOK_DECL_CLOSE:
    1373             state->handler = internalSubset;
    1374             return 0;
    1375         default:
    1376             return XML_ROLE_NONE;
    1377     }
    1378     return common(state, tok);
    1379 }
    1380 #endif
    1381 
    1382 static
    1383 int error(PROLOG_STATE * state,
     397int entity0(PROLOG_STATE *state,
     398        int tok,
     399        const char *ptr,
     400        const char *end,
     401        const ENCODING *enc)
     402{
     403  switch (tok) {
     404  case XML_TOK_PROLOG_S:
     405    return XML_ROLE_NONE;
     406  case XML_TOK_PERCENT:
     407    state->handler = entity1;
     408    return XML_ROLE_NONE;
     409  case XML_TOK_NAME:
     410    state->handler = entity2;
     411    return XML_ROLE_GENERAL_ENTITY_NAME;
     412  }
     413  return common(state, tok);
     414}
     415
     416static
     417int entity1(PROLOG_STATE *state,
     418        int tok,
     419        const char *ptr,
     420        const char *end,
     421        const ENCODING *enc)
     422{
     423  switch (tok) {
     424  case XML_TOK_PROLOG_S:
     425    return XML_ROLE_NONE;
     426  case XML_TOK_NAME:
     427    state->handler = entity7;
     428    return XML_ROLE_PARAM_ENTITY_NAME;
     429  }
     430  return common(state, tok);
     431}
     432
     433static
     434int entity2(PROLOG_STATE *state,
     435        int tok,
     436        const char *ptr,
     437        const char *end,
     438        const ENCODING *enc)
     439{
     440  switch (tok) {
     441  case XML_TOK_PROLOG_S:
     442    return XML_ROLE_NONE;
     443  case XML_TOK_NAME:
     444    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
     445      state->handler = entity4;
     446      return XML_ROLE_NONE;
     447    }
     448    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
     449      state->handler = entity3;
     450      return XML_ROLE_NONE;
     451    }
     452    break;
     453  case XML_TOK_LITERAL:
     454    state->handler = declClose;
     455    return XML_ROLE_ENTITY_VALUE;
     456  }
     457  return common(state, tok);
     458}
     459
     460static
     461int entity3(PROLOG_STATE *state,
     462        int tok,
     463        const char *ptr,
     464        const char *end,
     465        const ENCODING *enc)
     466{
     467  switch (tok) {
     468  case XML_TOK_PROLOG_S:
     469    return XML_ROLE_NONE;
     470  case XML_TOK_LITERAL:
     471    state->handler = entity4;
     472    return XML_ROLE_ENTITY_PUBLIC_ID;
     473  }
     474  return common(state, tok);
     475}
     476
     477
     478static
     479int entity4(PROLOG_STATE *state,
     480        int tok,
     481        const char *ptr,
     482        const char *end,
     483        const ENCODING *enc)
     484{
     485  switch (tok) {
     486  case XML_TOK_PROLOG_S:
     487    return XML_ROLE_NONE;
     488  case XML_TOK_LITERAL:
     489    state->handler = entity5;
     490    return XML_ROLE_ENTITY_SYSTEM_ID;
     491  }
     492  return common(state, tok);
     493}
     494
     495static
     496int entity5(PROLOG_STATE *state,
     497        int tok,
     498        const char *ptr,
     499        const char *end,
     500        const ENCODING *enc)
     501{
     502  switch (tok) {
     503  case XML_TOK_PROLOG_S:
     504    return XML_ROLE_NONE;
     505  case XML_TOK_DECL_CLOSE:
     506    setTopLevel(state);
     507    return XML_ROLE_ENTITY_COMPLETE;
     508  case XML_TOK_NAME:
     509    if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
     510      state->handler = entity6;
     511      return XML_ROLE_NONE;
     512    }
     513    break;
     514  }
     515  return common(state, tok);
     516}
     517
     518static
     519int entity6(PROLOG_STATE *state,
     520        int tok,
     521        const char *ptr,
     522        const char *end,
     523        const ENCODING *enc)
     524{
     525  switch (tok) {
     526  case XML_TOK_PROLOG_S:
     527    return XML_ROLE_NONE;
     528  case XML_TOK_NAME:
     529    state->handler = declClose;
     530    return XML_ROLE_ENTITY_NOTATION_NAME;
     531  }
     532  return common(state, tok);
     533}
     534
     535static
     536int entity7(PROLOG_STATE *state,
     537        int tok,
     538        const char *ptr,
     539        const char *end,
     540        const ENCODING *enc)
     541{
     542  switch (tok) {
     543  case XML_TOK_PROLOG_S:
     544    return XML_ROLE_NONE;
     545  case XML_TOK_NAME:
     546    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
     547      state->handler = entity9;
     548      return XML_ROLE_NONE;
     549    }
     550    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
     551      state->handler = entity8;
     552      return XML_ROLE_NONE;
     553    }
     554    break;
     555  case XML_TOK_LITERAL:
     556    state->handler = declClose;
     557    return XML_ROLE_ENTITY_VALUE;
     558  }
     559  return common(state, tok);
     560}
     561
     562static
     563int entity8(PROLOG_STATE *state,
     564        int tok,
     565        const char *ptr,
     566        const char *end,
     567        const ENCODING *enc)
     568{
     569  switch (tok) {
     570  case XML_TOK_PROLOG_S:
     571    return XML_ROLE_NONE;
     572  case XML_TOK_LITERAL:
     573    state->handler = entity9;
     574    return XML_ROLE_ENTITY_PUBLIC_ID;
     575  }
     576  return common(state, tok);
     577}
     578
     579static
     580int entity9(PROLOG_STATE *state,
     581        int tok,
     582        const char *ptr,
     583        const char *end,
     584        const ENCODING *enc)
     585{
     586  switch (tok) {
     587  case XML_TOK_PROLOG_S:
     588    return XML_ROLE_NONE;
     589  case XML_TOK_LITERAL:
     590    state->handler = declClose;
     591    return XML_ROLE_ENTITY_SYSTEM_ID;
     592  }
     593  return common(state, tok);
     594}
     595
     596static
     597int notation0(PROLOG_STATE *state,
    1384598          int tok,
    1385599          const char *ptr,
    1386600          const char *end,
    1387           const ENCODING * enc)
    1388 {
    1389     return XML_ROLE_NONE;
    1390 }
    1391 
    1392 static
    1393 int common(PROLOG_STATE * state, int tok)
    1394 {
     601          const ENCODING *enc)
     602{
     603  switch (tok) {
     604  case XML_TOK_PROLOG_S:
     605    return XML_ROLE_NONE;
     606  case XML_TOK_NAME:
     607    state->handler = notation1;
     608    return XML_ROLE_NOTATION_NAME;
     609  }
     610  return common(state, tok);
     611}
     612
     613static
     614int notation1(PROLOG_STATE *state,
     615          int tok,
     616          const char *ptr,
     617          const char *end,
     618          const ENCODING *enc)
     619{
     620  switch (tok) {
     621  case XML_TOK_PROLOG_S:
     622    return XML_ROLE_NONE;
     623  case XML_TOK_NAME:
     624    if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
     625      state->handler = notation3;
     626      return XML_ROLE_NONE;
     627    }
     628    if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
     629      state->handler = notation2;
     630      return XML_ROLE_NONE;
     631    }
     632    break;
     633  }
     634  return common(state, tok);
     635}
     636
     637static
     638int notation2(PROLOG_STATE *state,
     639          int tok,
     640          const char *ptr,
     641          const char *end,
     642          const ENCODING *enc)
     643{
     644  switch (tok) {
     645  case XML_TOK_PROLOG_S:
     646    return XML_ROLE_NONE;
     647  case XML_TOK_LITERAL:
     648    state->handler = notation4;
     649    return XML_ROLE_NOTATION_PUBLIC_ID;
     650  }
     651  return common(state, tok);
     652}
     653
     654static
     655int notation3(PROLOG_STATE *state,
     656          int tok,
     657          const char *ptr,
     658          const char *end,
     659          const ENCODING *enc)
     660{
     661  switch (tok) {
     662  case XML_TOK_PROLOG_S:
     663    return XML_ROLE_NONE;
     664  case XML_TOK_LITERAL:
     665    state->handler = declClose;
     666    return XML_ROLE_NOTATION_SYSTEM_ID;
     667  }
     668  return common(state, tok);
     669}
     670
     671static
     672int notation4(PROLOG_STATE *state,
     673          int tok,
     674          const char *ptr,
     675          const char *end,
     676          const ENCODING *enc)
     677{
     678  switch (tok) {
     679  case XML_TOK_PROLOG_S:
     680    return XML_ROLE_NONE;
     681  case XML_TOK_LITERAL:
     682    state->handler = declClose;
     683    return XML_ROLE_NOTATION_SYSTEM_ID;
     684  case XML_TOK_DECL_CLOSE:
     685    setTopLevel(state);
     686    return XML_ROLE_NOTATION_NO_SYSTEM_ID;
     687  }
     688  return common(state, tok);
     689}
     690
     691static
     692int attlist0(PROLOG_STATE *state,
     693         int tok,
     694         const char *ptr,
     695         const char *end,
     696         const ENCODING *enc)
     697{
     698  switch (tok) {
     699  case XML_TOK_PROLOG_S:
     700    return XML_ROLE_NONE;
     701  case XML_TOK_NAME:
     702  case XML_TOK_PREFIXED_NAME:
     703    state->handler = attlist1;
     704    return XML_ROLE_ATTLIST_ELEMENT_NAME;
     705  }
     706  return common(state, tok);
     707}
     708
     709static
     710int attlist1(PROLOG_STATE *state,
     711         int tok,
     712         const char *ptr,
     713         const char *end,
     714         const ENCODING *enc)
     715{
     716  switch (tok) {
     717  case XML_TOK_PROLOG_S:
     718    return XML_ROLE_NONE;
     719  case XML_TOK_DECL_CLOSE:
     720    setTopLevel(state);
     721    return XML_ROLE_NONE;
     722  case XML_TOK_NAME:
     723  case XML_TOK_PREFIXED_NAME:
     724    state->handler = attlist2;
     725    return XML_ROLE_ATTRIBUTE_NAME;
     726  }
     727  return common(state, tok);
     728}
     729
     730static
     731int attlist2(PROLOG_STATE *state,
     732         int tok,
     733         const char *ptr,
     734         const char *end,
     735         const ENCODING *enc)
     736{
     737  switch (tok) {
     738  case XML_TOK_PROLOG_S:
     739    return XML_ROLE_NONE;
     740  case XML_TOK_NAME:
     741    {
     742      static const char *types[] = {
     743    KW_CDATA,
     744        KW_ID,
     745        KW_IDREF,
     746        KW_IDREFS,
     747        KW_ENTITY,
     748        KW_ENTITIES,
     749        KW_NMTOKEN,
     750        KW_NMTOKENS,
     751      };
     752      int i;
     753      for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
     754    if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
     755      state->handler = attlist8;
     756      return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
     757    }
     758    }
     759    if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
     760      state->handler = attlist5;
     761      return XML_ROLE_NONE;
     762    }
     763    break;
     764  case XML_TOK_OPEN_PAREN:
     765    state->handler = attlist3;
     766    return XML_ROLE_NONE;
     767  }
     768  return common(state, tok);
     769}
     770
     771static
     772int attlist3(PROLOG_STATE *state,
     773         int tok,
     774         const char *ptr,
     775         const char *end,
     776         const ENCODING *enc)
     777{
     778  switch (tok) {
     779  case XML_TOK_PROLOG_S:
     780    return XML_ROLE_NONE;
     781  case XML_TOK_NMTOKEN:
     782  case XML_TOK_NAME:
     783  case XML_TOK_PREFIXED_NAME:
     784    state->handler = attlist4;
     785    return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
     786  }
     787  return common(state, tok);
     788}
     789
     790static
     791int attlist4(PROLOG_STATE *state,
     792         int tok,
     793         const char *ptr,
     794         const char *end,
     795         const ENCODING *enc)
     796{
     797  switch (tok) {
     798  case XML_TOK_PROLOG_S:
     799    return XML_ROLE_NONE;
     800  case XML_TOK_CLOSE_PAREN:
     801    state->handler = attlist8;
     802    return XML_ROLE_NONE;
     803  case XML_TOK_OR:
     804    state->handler = attlist3;
     805    return XML_ROLE_NONE;
     806  }
     807  return common(state, tok);
     808}
     809
     810static
     811int attlist5(PROLOG_STATE *state,
     812         int tok,
     813         const char *ptr,
     814         const char *end,
     815         const ENCODING *enc)
     816{
     817  switch (tok) {
     818  case XML_TOK_PROLOG_S:
     819    return XML_ROLE_NONE;
     820  case XML_TOK_OPEN_PAREN:
     821    state->handler = attlist6;
     822    return XML_ROLE_NONE;
     823  }
     824  return common(state, tok);
     825}
     826
     827
     828static
     829int attlist6(PROLOG_STATE *state,
     830         int tok,
     831         const char *ptr,
     832         const char *end,
     833         const ENCODING *enc)
     834{
     835  switch (tok) {
     836  case XML_TOK_PROLOG_S:
     837    return XML_ROLE_NONE;
     838  case XML_TOK_NAME:
     839    state->handler = attlist7;
     840    return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
     841  }
     842  return common(state, tok);
     843}
     844
     845static
     846int attlist7(PROLOG_STATE *state,
     847         int tok,
     848         const char *ptr,
     849         const char *end,
     850         const ENCODING *enc)
     851{
     852  switch (tok) {
     853  case XML_TOK_PROLOG_S:
     854    return XML_ROLE_NONE;
     855  case XML_TOK_CLOSE_PAREN:
     856    state->handler = attlist8;
     857    return XML_ROLE_NONE;
     858  case XML_TOK_OR:
     859    state->handler = attlist6;
     860    return XML_ROLE_NONE;
     861  }
     862  return common(state, tok);
     863}
     864
     865/* default value */
     866static
     867int attlist8(PROLOG_STATE *state,
     868         int tok,
     869         const char *ptr,
     870         const char *end,
     871         const ENCODING *enc)
     872{
     873  switch (tok) {
     874  case XML_TOK_PROLOG_S:
     875    return XML_ROLE_NONE;
     876  case XML_TOK_POUND_NAME:
     877    if (XmlNameMatchesAscii(enc,
     878                ptr + MIN_BYTES_PER_CHAR(enc),
     879                end,
     880                KW_IMPLIED)) {
     881      state->handler = attlist1;
     882      return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
     883    }
     884    if (XmlNameMatchesAscii(enc,
     885                ptr + MIN_BYTES_PER_CHAR(enc),
     886                end,
     887                KW_REQUIRED)) {
     888      state->handler = attlist1;
     889      return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
     890    }
     891    if (XmlNameMatchesAscii(enc,
     892                ptr + MIN_BYTES_PER_CHAR(enc),
     893                end,
     894                KW_FIXED)) {
     895      state->handler = attlist9;
     896      return XML_ROLE_NONE;
     897    }
     898    break;
     899  case XML_TOK_LITERAL:
     900    state->handler = attlist1;
     901    return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
     902  }
     903  return common(state, tok);
     904}
     905
     906static
     907int attlist9(PROLOG_STATE *state,
     908         int tok,
     909         const char *ptr,
     910         const char *end,
     911         const ENCODING *enc)
     912{
     913  switch (tok) {
     914  case XML_TOK_PROLOG_S:
     915    return XML_ROLE_NONE;
     916  case XML_TOK_LITERAL:
     917    state->handler = attlist1;
     918    return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
     919  }
     920  return common(state, tok);
     921}
     922
     923static
     924int element0(PROLOG_STATE *state,
     925         int tok,
     926         const char *ptr,
     927         const char *end,
     928         const ENCODING *enc)
     929{
     930  switch (tok) {
     931  case XML_TOK_PROLOG_S:
     932    return XML_ROLE_NONE;
     933  case XML_TOK_NAME:
     934  case XML_TOK_PREFIXED_NAME:
     935    state->handler = element1;
     936    return XML_ROLE_ELEMENT_NAME;
     937  }
     938  return common(state, tok);
     939}
     940
     941static
     942int element1(PROLOG_STATE *state,
     943         int tok,
     944         const char *ptr,
     945         const char *end,
     946         const ENCODING *enc)
     947{
     948  switch (tok) {
     949  case XML_TOK_PROLOG_S:
     950    return XML_ROLE_NONE;
     951  case XML_TOK_NAME:
     952    if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
     953      state->handler = declClose;
     954      return XML_ROLE_CONTENT_EMPTY;
     955    }
     956    if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
     957      state->handler = declClose;
     958      return XML_ROLE_CONTENT_ANY;
     959    }
     960    break;
     961  case XML_TOK_OPEN_PAREN:
     962    state->handler = element2;
     963    state->level = 1;
     964    return XML_ROLE_GROUP_OPEN;
     965  }
     966  return common(state, tok);
     967}
     968
     969static
     970int element2(PROLOG_STATE *state,
     971         int tok,
     972         const char *ptr,
     973         const char *end,
     974         const ENCODING *enc)
     975{
     976  switch (tok) {
     977  case XML_TOK_PROLOG_S:
     978    return XML_ROLE_NONE;
     979  case XML_TOK_POUND_NAME:
     980    if (XmlNameMatchesAscii(enc,
     981                ptr + MIN_BYTES_PER_CHAR(enc),
     982                end,
     983                KW_PCDATA)) {
     984      state->handler = element3;
     985      return XML_ROLE_CONTENT_PCDATA;
     986    }
     987    break;
     988  case XML_TOK_OPEN_PAREN:
     989    state->level = 2;
     990    state->handler = element6;
     991    return XML_ROLE_GROUP_OPEN;
     992  case XML_TOK_NAME:
     993  case XML_TOK_PREFIXED_NAME:
     994    state->handler = element7;
     995    return XML_ROLE_CONTENT_ELEMENT;
     996  case XML_TOK_NAME_QUESTION:
     997    state->handler = element7;
     998    return XML_ROLE_CONTENT_ELEMENT_OPT;
     999  case XML_TOK_NAME_ASTERISK:
     1000    state->handler = element7;
     1001    return XML_ROLE_CONTENT_ELEMENT_REP;
     1002  case XML_TOK_NAME_PLUS:
     1003    state->handler = element7;
     1004    return XML_ROLE_CONTENT_ELEMENT_PLUS;
     1005  }
     1006  return common(state, tok);
     1007}
     1008
     1009static
     1010int element3(PROLOG_STATE *state,
     1011         int tok,
     1012         const char *ptr,
     1013         const char *end,
     1014         const ENCODING *enc)
     1015{
     1016  switch (tok) {
     1017  case XML_TOK_PROLOG_S:
     1018    return XML_ROLE_NONE;
     1019  case XML_TOK_CLOSE_PAREN:
     1020    state->handler = declClose;
     1021    return XML_ROLE_GROUP_CLOSE;
     1022  case XML_TOK_CLOSE_PAREN_ASTERISK:
     1023    state->handler = declClose;
     1024    return XML_ROLE_GROUP_CLOSE_REP;
     1025  case XML_TOK_OR:
     1026    state->handler = element4;
     1027    return XML_ROLE_NONE;
     1028  }
     1029  return common(state, tok);
     1030}
     1031
     1032static
     1033int element4(PROLOG_STATE *state,
     1034         int tok,
     1035         const char *ptr,
     1036         const char *end,
     1037         const ENCODING *enc)
     1038{
     1039  switch (tok) {
     1040  case XML_TOK_PROLOG_S:
     1041    return XML_ROLE_NONE;
     1042  case XML_TOK_NAME:
     1043  case XML_TOK_PREFIXED_NAME:
     1044    state->handler = element5;
     1045    return XML_ROLE_CONTENT_ELEMENT;
     1046  }
     1047  return common(state, tok);
     1048}
     1049
     1050static
     1051int element5(PROLOG_STATE *state,
     1052         int tok,
     1053         const char *ptr,
     1054         const char *end,
     1055         const ENCODING *enc)
     1056{
     1057  switch (tok) {
     1058  case XML_TOK_PROLOG_S:
     1059    return XML_ROLE_NONE;
     1060  case XML_TOK_CLOSE_PAREN_ASTERISK:
     1061    state->handler = declClose;
     1062    return XML_ROLE_GROUP_CLOSE_REP;
     1063  case XML_TOK_OR:
     1064    state->handler = element4;
     1065    return XML_ROLE_NONE;
     1066  }
     1067  return common(state, tok);
     1068}
     1069
     1070static
     1071int element6(PROLOG_STATE *state,
     1072         int tok,
     1073         const char *ptr,
     1074         const char *end,
     1075         const ENCODING *enc)
     1076{
     1077  switch (tok) {
     1078  case XML_TOK_PROLOG_S:
     1079    return XML_ROLE_NONE;
     1080  case XML_TOK_OPEN_PAREN:
     1081    state->level += 1;
     1082    return XML_ROLE_GROUP_OPEN;
     1083  case XML_TOK_NAME:
     1084  case XML_TOK_PREFIXED_NAME:
     1085    state->handler = element7;
     1086    return XML_ROLE_CONTENT_ELEMENT;
     1087  case XML_TOK_NAME_QUESTION:
     1088    state->handler = element7;
     1089    return XML_ROLE_CONTENT_ELEMENT_OPT;
     1090  case XML_TOK_NAME_ASTERISK:
     1091    state->handler = element7;
     1092    return XML_ROLE_CONTENT_ELEMENT_REP;
     1093  case XML_TOK_NAME_PLUS:
     1094    state->handler = element7;
     1095    return XML_ROLE_CONTENT_ELEMENT_PLUS;
     1096  }
     1097  return common(state, tok);
     1098}
     1099
     1100static
     1101int element7(PROLOG_STATE *state,
     1102         int tok,
     1103         const char *ptr,
     1104         const char *end,
     1105         const ENCODING *enc)
     1106{
     1107  switch (tok) {
     1108  case XML_TOK_PROLOG_S:
     1109    return XML_ROLE_NONE;
     1110  case XML_TOK_CLOSE_PAREN:
     1111    state->level -= 1;
     1112    if (state->level == 0)
     1113      state->handler = declClose;
     1114    return XML_ROLE_GROUP_CLOSE;
     1115  case XML_TOK_CLOSE_PAREN_ASTERISK:
     1116    state->level -= 1;
     1117    if (state->level == 0)
     1118      state->handler = declClose;
     1119    return XML_ROLE_GROUP_CLOSE_REP;
     1120  case XML_TOK_CLOSE_PAREN_QUESTION:
     1121    state->level -= 1;
     1122    if (state->level == 0)
     1123      state->handler = declClose;
     1124    return XML_ROLE_GROUP_CLOSE_OPT;
     1125  case XML_TOK_CLOSE_PAREN_PLUS:
     1126    state->level -= 1;
     1127    if (state->level == 0)
     1128      state->handler = declClose;
     1129    return XML_ROLE_GROUP_CLOSE_PLUS;
     1130  case XML_TOK_COMMA:
     1131    state->handler = element6;
     1132    return XML_ROLE_GROUP_SEQUENCE;
     1133  case XML_TOK_OR:
     1134    state->handler = element6;
     1135    return XML_ROLE_GROUP_CHOICE;
     1136  }
     1137  return common(state, tok);
     1138}
     1139
    13951140#ifdef XML_DTD
    1396     if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
    1397         return XML_ROLE_INNER_PARAM_ENTITY_REF;
     1141
     1142static
     1143int condSect0(PROLOG_STATE *state,
     1144          int tok,
     1145          const char *ptr,
     1146          const char *end,
     1147          const ENCODING *enc)
     1148{
     1149  switch (tok) {
     1150  case XML_TOK_PROLOG_S:
     1151    return XML_ROLE_NONE;
     1152  case XML_TOK_NAME:
     1153    if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
     1154      state->handler = condSect1;
     1155      return XML_ROLE_NONE;
     1156    }
     1157    if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
     1158      state->handler = condSect2;
     1159      return XML_ROLE_NONE;
     1160    }
     1161    break;
     1162  }
     1163  return common(state, tok);
     1164}
     1165
     1166static
     1167int condSect1(PROLOG_STATE *state,
     1168          int tok,
     1169          const char *ptr,
     1170          const char *end,
     1171          const ENCODING *enc)
     1172{
     1173  switch (tok) {
     1174  case XML_TOK_PROLOG_S:
     1175    return XML_ROLE_NONE;
     1176  case XML_TOK_OPEN_BRACKET:
     1177    state->handler = externalSubset1;
     1178    state->includeLevel += 1;
     1179    return XML_ROLE_NONE;
     1180  }
     1181  return common(state, tok);
     1182}
     1183
     1184static
     1185int condSect2(PROLOG_STATE *state,
     1186          int tok,
     1187          const char *ptr,
     1188          const char *end,
     1189          const ENCODING *enc)
     1190{
     1191  switch (tok) {
     1192  case XML_TOK_PROLOG_S:
     1193    return XML_ROLE_NONE;
     1194  case XML_TOK_OPEN_BRACKET:
     1195    state->handler = externalSubset1;
     1196    return XML_ROLE_IGNORE_SECT;
     1197  }
     1198  return common(state, tok);
     1199}
     1200
     1201#endif /* XML_DTD */
     1202
     1203static
     1204int declClose(PROLOG_STATE *state,
     1205          int tok,
     1206          const char *ptr,
     1207          const char *end,
     1208          const ENCODING *enc)
     1209{
     1210  switch (tok) {
     1211  case XML_TOK_PROLOG_S:
     1212    return XML_ROLE_NONE;
     1213  case XML_TOK_DECL_CLOSE:
     1214    setTopLevel(state);
     1215    return XML_ROLE_NONE;
     1216  }
     1217  return common(state, tok);
     1218}
     1219
     1220#if 0
     1221
     1222static
     1223int ignore(PROLOG_STATE *state,
     1224       int tok,
     1225       const char *ptr,
     1226       const char *end,
     1227       const ENCODING *enc)
     1228{
     1229  switch (tok) {
     1230  case XML_TOK_DECL_CLOSE:
     1231    state->handler = internalSubset;
     1232    return 0;
     1233  default:
     1234    return XML_ROLE_NONE;
     1235  }
     1236  return common(state, tok);
     1237}
    13981238#endif
    1399     state->handler = error;
    1400     return XML_ROLE_ERROR;
    1401 }
    1402 
    1403 void XmlPrologStateInit(PROLOG_STATE * state)
    1404 {
    1405     state->handler = prolog0;
     1239
     1240static
     1241int error(PROLOG_STATE *state,
     1242      int tok,
     1243      const char *ptr,
     1244      const char *end,
     1245      const ENCODING *enc)
     1246{
     1247  return XML_ROLE_NONE;
     1248}
     1249
     1250static
     1251int common(PROLOG_STATE *state, int tok)
     1252{
    14061253#ifdef XML_DTD
    1407     state->documentEntity = 1;
    1408     state->includeLevel = 0;
     1254  if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
     1255    return XML_ROLE_INNER_PARAM_ENTITY_REF;
     1256#endif
     1257  state->handler = error;
     1258  return XML_ROLE_ERROR;
     1259}
     1260
     1261void XmlPrologStateInit(PROLOG_STATE *state)
     1262{
     1263  state->handler = prolog0;
     1264#ifdef XML_DTD
     1265  state->documentEntity = 1;
     1266  state->includeLevel = 0;
    14091267#endif /* XML_DTD */
    14101268}
    … …  
    14121270#ifdef XML_DTD
    14131271
    1414 void XmlPrologStateInitExternalEntity(PROLOG_STATE * state)
    1415 {
    1416     state->handler = externalSubset0;
    1417     state->documentEntity = 0;
    1418     state->includeLevel = 0;
     1272void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
     1273{
     1274  state->handler = externalSubset0;
     1275  state->documentEntity = 0;
     1276  state->includeLevel = 0;
    14191277}
    14201278

  • trunk/src/helpers/xmltok.c

    r75 r97  
    1 
    21/*
    3  *sourcefile xmltok.c
    4  *      part of the expat implementation. See xmlparse.c.
    5  *
     2 * Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
     3 * See the file COPYING for copying permission.
    64 */
    75
    8 /*
    9  *      Copyright (C) 2001 Ulrich M”ller.
    10  *      Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd.
    11  *                                     and Clark Cooper.
    12  *
    13  *      Permission is hereby granted, free of charge, to any person obtaining
    14  *      a copy of this software and associated documentation files (the
    15  *      "Software"), to deal in the Software without restriction, including
    16  *      without limitation the rights to use, copy, modify, merge, publish,
    17  *      distribute, sublicense, and/or sell copies of the Software, and to
    18  *      permit persons to whom the Software is furnished to do so, subject to
    19  *      the following conditions:
    20  *
    21  *      The above copyright notice and this permission notice shall be included
    22  *      in all copies or substantial portions of the Software.
    23  *
    24  *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    25  *      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    26  *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    27  *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    28  *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    29  *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    30  *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     6/* #ifdef COMPILED_FROM_DSP
     7 * #  include "winconfig.h"
     8 * #else
     9 * #  include <config.h>
     10 * #endif
    3111 */
    3212
    33 #include "setup.h"
    34 
    35 #include "expat\expat_setup.h"          // V0.9.9 (2001-02-10) [umoeller]
     13#include <memory.h>
     14
     15#include "expat\expat_setup.h"  // V0.9.9 (2001-02-10) [umoeller]
    3616
    3717#pragma info(norea, nogen)
    … …  
    10585#define UTF8_INVALID4(p) ((*p) == 0xF4 && ((p)[1] & 0x30) != 0)
    10686
    107 static int EXPATENTRY isNever(const ENCODING * enc, const char *p)
     87static
     88int isNever(const ENCODING * enc, const char *p)
    10889{
    10990    return 0;
    11091}
    11192
    112 static int EXPATENTRY utf8_isName2(const ENCODING * enc, const char *p)
     93static
     94int utf8_isName2(const ENCODING * enc, const char *p)
    11395{
    11496    return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
    11597}
    11698
    117 static int EXPATENTRY utf8_isName3(const ENCODING * enc, const char *p)
     99static
     100int utf8_isName3(const ENCODING * enc, const char *p)
    118101{
    119102    return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
    … …  
    122105#define utf8_isName4 isNever
    123106
    124 static int EXPATENTRY utf8_isNmstrt2(const ENCODING * enc, const char *p)
     107static
     108int utf8_isNmstrt2(const ENCODING * enc, const char *p)
    125109{
    126110    return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
    127111}
    128112
    129 static int EXPATENTRY utf8_isNmstrt3(const ENCODING * enc, const char *p)
     113static
     114int utf8_isNmstrt3(const ENCODING * enc, const char *p)
    130115{
    131116    return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
    … …  
    136121#define utf8_isInvalid2 isNever
    137122
    138 static int EXPATENTRY utf8_isInvalid3(const ENCODING * enc, const char *p)
     123static
     124int utf8_isInvalid3(const ENCODING * enc, const char *p)
    139125{
    140126    return UTF8_INVALID3((const unsigned char *)p);
    141127}
    142128
    143 static int EXPATENTRY utf8_isInvalid4(const ENCODING * enc, const char *p)
     129static
     130int utf8_isInvalid4(const ENCODING * enc, const char *p)
    144131{
    145132    return UTF8_INVALID4((const unsigned char *)p);
    … …  
    151138    unsigned char type[256];
    152139#ifdef XML_MIN_SIZE
    153     int (* EXPATENTRY byteType) (const ENCODING *, const char *);
    154     int (* EXPATENTRY isNameMin) (const ENCODING *, const char *);
    155     int (* EXPATENTRY isNmstrtMin) (const ENCODING *, const char *);
    156     int (* EXPATENTRY byteToAscii) (const ENCODING *, const char *);
    157     int (* EXPATENTRY charMatches) (const ENCODING *, const char *, int);
     140    int (*byteType) (const ENCODING *, const char *);
     141    int (*isNameMin) (const ENCODING *, const char *);
     142    int (*isNmstrtMin) (const ENCODING *, const char *);
     143    int (*byteToAscii) (const ENCODING *, const char *);
     144    int (*charMatches) (const ENCODING *, const char *, int);
    158145#endif                          /* XML_MIN_SIZE */
    159     int (* EXPATENTRY isName2) (const ENCODING *, const char *);
    160     int (* EXPATENTRY isName3) (const ENCODING *, const char *);
    161     int (* EXPATENTRY isName4) (const ENCODING *, const char *);
    162     int (* EXPATENTRY isNmstrt2) (const ENCODING *, const char *);
    163     int (* EXPATENTRY isNmstrt3) (const ENCODING *, const char *);
    164     int (* EXPATENTRY isNmstrt4) (const ENCODING *, const char *);
    165     int (* EXPATENTRY isInvalid2) (const ENCODING *, const char *);
    166     int (* EXPATENTRY isInvalid3) (const ENCODING *, const char *);
    167     int (* EXPATENTRY isInvalid4) (const ENCODING *, const char *);
     146    int (*isName2) (const ENCODING *, const char *);
     147    int (*isName3) (const ENCODING *, const char *);
     148    int (*isName4) (const ENCODING *, const char *);
     149    int (*isNmstrt2) (const ENCODING *, const char *);
     150    int (*isNmstrt3) (const ENCODING *, const char *);
     151    int (*isNmstrt4) (const ENCODING *, const char *);
     152    int (*isInvalid2) (const ENCODING *, const char *);
     153    int (*isInvalid3) (const ENCODING *, const char *);
     154    int (*isInvalid4) (const ENCODING *, const char *);
    168155};
    169156
    … …  
    215202
    216203#ifdef XML_MIN_SIZE
    217 static int EXPATENTRY sb_byteType(const ENCODING * enc, const char *p)
     204static
     205int sb_byteType(const ENCODING * enc, const char *p)
    218206{
    219207    return SB_BYTE_TYPE(enc, p);
    … …  
    228216#define BYTE_TO_ASCII(enc, p) \
    229217 (((const struct normal_encoding *)(enc))->byteToAscii(enc, p))
    230 static int EXPATENTRY sb_byteToAscii(const ENCODING * enc, const char *p)
     218static
     219int sb_byteToAscii(const ENCODING * enc, const char *p)
    231220{
    232221    return *p;
    … …  
    256245#define CHAR_MATCHES(enc, p, c) \
    257246 (((const struct normal_encoding *)(enc))->charMatches(enc, p, c))
    258 static int EXPATENTRY sb_charMatches(const ENCODING * enc, const char *p, int c)
     247static
     248int sb_charMatches(const ENCODING * enc, const char *p, int c)
    259249{
    260250    return *p == c;
    … …  
    286276};
    287277
    288 static void EXPATENTRY utf8_toUtf8(const ENCODING * enc,
    289                                  const char **fromP,
    290                                  const char *fromLim,
    291                                  char **toP,
    292                                  const char *toLim)
     278static void utf8_toUtf8(const ENCODING * enc,
     279                        const char **fromP,
     280                        const char *fromLim,
     281                        char **toP,
     282                        const char *toLim)
    293283{
    294284    char *to;
    … …  
    298288    {
    299289        /* Avoid copying partial characters. */
    300         for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
     290        for (fromLim = *fromP + (toLim - *toP);
     291             fromLim > *fromP;
     292             fromLim--)
    301293            if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
    302294                break;
    303295    }
    304     for (to = *toP, from = *fromP; from != fromLim; from++, to++)
     296    for (to = *toP, from = *fromP;
     297         from != fromLim;
     298         from++, to++)
    305299        *to = *from;
    306300    *fromP = from;
    … …  
    308302}
    309303
    310 static void EXPATENTRY utf8_toUtf16(const ENCODING * enc,
    311                   const char **fromP, const char *fromLim,
    312                   unsigned short **toP, const unsigned short *toLim)
     304static void utf8_toUtf16(const ENCODING * enc,
     305                         const char **fromP,
     306                         const char *fromLim,
     307                         unsigned short **toP,
     308                         const unsigned short *toLim)
    313309{
    314310    unsigned short *to = *toP;
    … …  
    401397};
    402398
    403 static void EXPATENTRY latin1_toUtf8(const ENCODING * enc,
    404                    const char **fromP, const char *fromLim,
    405                    char **toP, const char *toLim)
     399static void latin1_toUtf8(const ENCODING * enc,
     400                          const char **fromP,
     401                          const char *fromLim,
     402                          char **toP,
     403                          const char *toLim)
    406404{
    407405    for (;;)
    … …  
    429427}
    430428
    431 static void EXPATENTRY latin1_toUtf16(const ENCODING * enc,
    432                     const char **fromP, const char *fromLim,
    433                     unsigned short **toP, const unsigned short *toLim)
     429static void latin1_toUtf16(const ENCODING * enc,
     430                           const char **fromP,
     431                           const char *fromLim,
     432                           unsigned short **toP,
     433                           const unsigned short *toLim)
    434434{
    435435    while (*fromP != fromLim && *toP != toLim)
    … …  
    463463};
    464464
    465 static void EXPATENTRY ascii_toUtf8(const ENCODING * enc,
    466                   const char **fromP, const char *fromLim,
    467                   char **toP, const char *toLim)
     465static void ascii_toUtf8(const ENCODING * enc,
     466                         const char **fromP,
     467                         const char *fromLim,
     468                         char **toP,
     469                         const char *toLim)
    468470{
    469471    while (*fromP != fromLim && *toP != toLim)
    … …  
    524526
    525527#define DEFINE_UTF16_TO_UTF8(E) \
    526 static void EXPATENTRY E ## toUtf8(const ENCODING *enc, \
     528static \
     529void E ## toUtf8(const ENCODING *enc, \
    527530         const char **fromP, const char *fromLim, \
    528531         char **toP, const char *toLim) \
    … …  
    586589
    587590#define DEFINE_UTF16_TO_UTF16(E) \
    588 static void EXPATENTRY E ## toUtf16(const ENCODING *enc, \
     591static \
     592void E ## toUtf16(const ENCODING *enc, \
    589593          const char **fromP, const char *fromLim, \
    590594          unsigned short **toP, const unsigned short *toLim) \
    … …  
    635639#ifdef XML_MIN_SIZE
    636640
    637     static int EXPATENTRY little2_byteType(const ENCODING * enc, const char *p)
    638     {
    639         return LITTLE2_BYTE_TYPE(enc, p);
    640     }
    641 
    642     static int EXPATENTRY little2_byteToAscii(const ENCODING * enc, const char *p)
    643     {
    644         return LITTLE2_BYTE_TO_ASCII(enc, p);
    645     }
    646 
    647     static int EXPATENTRY little2_charMatches(const ENCODING * enc, const char *p, int c)
    648     {
    649         return LITTLE2_CHAR_MATCHES(enc, p, c);
    650     }
    651 
    652     static int EXPATENTRY little2_isNameMin(const ENCODING * enc, const char *p)
    653     {
    654         return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
    655     }
    656 
    657     static int EXPATENTRY little2_isNmstrtMin(const ENCODING * enc, const char *p)
    658     {
    659         return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
    660     }
    661 
    662     #undef VTABLE
    663     #define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
     641     static
     642     int little2_byteType(const ENCODING * enc, const char *p)
     643{
     644    return LITTLE2_BYTE_TYPE(enc, p);
     645}
     646
     647static int little2_byteToAscii(const ENCODING * enc, const char *p)
     648{
     649    return LITTLE2_BYTE_TO_ASCII(enc, p);
     650}
     651
     652static int little2_charMatches(const ENCODING * enc, const char *p, int c)
     653{
     654    return LITTLE2_CHAR_MATCHES(enc, p, c);
     655}
     656
     657static int little2_isNameMin(const ENCODING * enc, const char *p)
     658{
     659    return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
     660}
     661
     662static int little2_isNmstrtMin(const ENCODING * enc, const char *p)
     663{
     664    return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
     665}
     666
     667#undef VTABLE
     668#define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
    664669
    665670#else /* not XML_MIN_SIZE */
    666671
    667     #undef PREFIX
    668     #define PREFIX(ident) little2_ ## ident
    669     #define MINBPC(enc) 2
    670     /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
    671     #define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
    672     #define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
    673     #define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
    674     #define IS_NAME_CHAR(enc, p, n) 0
    675     #define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
    676     #define IS_NMSTRT_CHAR(enc, p, n) (0)
    677     #define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
    678 
    679     #include "xmltok_impl.c"
    680 
    681     #undef MINBPC
    682     #undef BYTE_TYPE
    683     #undef BYTE_TO_ASCII
    684     #undef CHAR_MATCHES
    685     #undef IS_NAME_CHAR
    686     #undef IS_NAME_CHAR_MINBPC
    687     #undef IS_NMSTRT_CHAR
    688     #undef IS_NMSTRT_CHAR_MINBPC
    689     #undef IS_INVALID_CHAR
     672#undef PREFIX
     673#define PREFIX(ident) little2_ ## ident
     674#define MINBPC(enc) 2
     675/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
     676#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
     677#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
     678#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
     679#define IS_NAME_CHAR(enc, p, n) 0
     680#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
     681#define IS_NMSTRT_CHAR(enc, p, n) (0)
     682#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
     683
     684#include "xmltok_impl.c"
     685
     686#undef MINBPC
     687#undef BYTE_TYPE
     688#undef BYTE_TO_ASCII
     689#undef CHAR_MATCHES
     690#undef IS_NAME_CHAR
     691#undef IS_NAME_CHAR_MINBPC
     692#undef IS_NMSTRT_CHAR
     693#undef IS_NMSTRT_CHAR_MINBPC
     694#undef IS_INVALID_CHAR
    690695
    691696#endif /* not XML_MIN_SIZE */
    … …  
    693698#ifdef XML_NS
    694699
    695          static const struct normal_encoding little2_encoding_ns =
     700     static const struct normal_encoding little2_encoding_ns =
     701     {
     702         {VTABLE, 2, 0,
     703#if XML_BYTE_ORDER == 12
     704          1
     705#else
     706          0
     707#endif
     708         },
    696709         {
    697              {VTABLE, 2, 0,
    698     #if XML_BYTE_ORDER == 12
    699               1
    700     #else
    701               0
    702     #endif
    703              },
    704              {
    705     #include "expat\asciitab.h"
    706     #include "expat\latin1tab.h"
    707              },
    708              STANDARD_VTABLE(little2_)
    709     };
     710#include "expat\asciitab.h"
     711#include "expat\latin1tab.h"
     712         },
     713         STANDARD_VTABLE(little2_)
     714};
    710715
    711716#endif
    … …  
    773778#ifdef XML_MIN_SIZE
    774779
    775     static int EXPATENTRY big2_byteType(const ENCODING * enc, const char *p)
    776     {
    777         return BIG2_BYTE_TYPE(enc, p);
    778     }
    779 
    780     static int EXPATENTRY big2_byteToAscii(const ENCODING * enc, const char *p)
    781     {
    782         return BIG2_BYTE_TO_ASCII(enc, p);
    783     }
    784 
    785     static int EXPATENTRY big2_charMatches(const ENCODING * enc, const char *p, int c)
    786     {
    787         return BIG2_CHAR_MATCHES(enc, p, c);
    788     }
    789 
    790     static int EXPATENTRY big2_isNameMin(const ENCODING * enc, const char *p)
    791     {
    792         return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
    793     }
    794 
    795     static int EXPATENTRY big2_isNmstrtMin(const ENCODING * enc, const char *p)
    796     {
    797         return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
    798     }
    799 
    800     #undef VTABLE
    801     #define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
     780static int big2_byteType(const ENCODING * enc, const char *p)
     781{
     782    return BIG2_BYTE_TYPE(enc, p);
     783}
     784
     785static int big2_byteToAscii(const ENCODING * enc, const char *p)
     786{
     787    return BIG2_BYTE_TO_ASCII(enc, p);
     788}
     789
     790static int big2_charMatches(const ENCODING * enc, const char *p, int c)
     791{
     792    return BIG2_CHAR_MATCHES(enc, p, c);
     793}
     794
     795static int big2_isNameMin(const ENCODING * enc, const char *p)
     796{
     797    return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
     798}
     799
     800static int big2_isNmstrtMin(const ENCODING * enc, const char *p)
     801{
     802    return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
     803}
     804
     805#undef VTABLE
     806#define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
    802807
    803808#else /* not XML_MIN_SIZE */
    804809
    805     #undef PREFIX
    806     #define PREFIX(ident) big2_ ## ident
    807     #define MINBPC(enc) 2
    808     /* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
    809     #define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
    810     #define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
    811     #define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
    812     #define IS_NAME_CHAR(enc, p, n) 0
    813     #define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
    814     #define IS_NMSTRT_CHAR(enc, p, n) (0)
    815     #define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
    816 
    817     #include "xmltok_impl.c"
    818 
    819     #undef MINBPC
    820     #undef BYTE_TYPE
    821     #undef BYTE_TO_ASCII
    822     #undef CHAR_MATCHES
    823     #undef IS_NAME_CHAR
    824     #undef IS_NAME_CHAR_MINBPC
    825     #undef IS_NMSTRT_CHAR
    826     #undef IS_NMSTRT_CHAR_MINBPC
    827     #undef IS_INVALID_CHAR
     810#undef PREFIX
     811#define PREFIX(ident) big2_ ## ident
     812#define MINBPC(enc) 2
     813/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
     814#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
     815#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
     816#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
     817#define IS_NAME_CHAR(enc, p, n) 0
     818#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
     819#define IS_NMSTRT_CHAR(enc, p, n) (0)
     820#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
     821
     822#include "xmltok_impl.c"
     823
     824#undef MINBPC
     825#undef BYTE_TYPE
     826#undef BYTE_TO_ASCII
     827#undef CHAR_MATCHES
     828#undef IS_NAME_CHAR
     829#undef IS_NAME_CHAR_MINBPC
     830#undef IS_NMSTRT_CHAR
     831#undef IS_NMSTRT_CHAR_MINBPC
     832#undef IS_INVALID_CHAR
    828833
    829834#endif /* not XML_MIN_SIZE */
    … …  
    899904#undef PREFIX
    900905
    901      static
    902      int streqci(const char *s1, const char *s2)
     906static int streqci(const char *s1, const char *s2)
    903907{
    904908    for (;;)
    … …  
    919923}
    920924
    921 static void EXPATENTRY initUpdatePosition(const ENCODING * enc,
    922                                           const char *ptr,
    923                                           const char *end,
    924                                           POSITION * pos)
     925static void initUpdatePosition(const ENCODING * enc, const char *ptr,
     926                        const char *end, POSITION * pos)
    925927{
    926928    normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
    927929}
    928930
    929 static int EXPATENTRY toAscii(const ENCODING * enc, const char *ptr, const char *end)
     931static int toAscii(const ENCODING * enc, const char *ptr, const char *end)
    930932{
    931933    char buf[1];
    … …  
    954956/* Return 1 if there's just optional white space
    955957 * or there's an S followed by name=val. */
    956 static int EXPATENTRY parsePseudoAttribute(const ENCODING * enc,
    957                                            const char *ptr,
    958                                            const char *end,
    959                                            const char **namePtr,
    960                                            const char **nameEndPtr,
    961                                            const char **valPtr,
    962                                            const char **nextTokPtr)
     958static int parsePseudoAttribute(const ENCODING * enc,
     959                                const char *ptr,
     960                                const char *end,
     961                                const char **namePtr,
     962                                const char **nameEndPtr,
     963                                const char **valPtr,
     964                                const char **nextTokPtr)
    963965{
    964966    int c;
    … …  
    10811083};
    10821084
    1083 static int doParseXmlDecl(const ENCODING* (* EXPATENTRY encodingFinder)(const ENCODING *,
    1084                                                                       const char *,
    1085                                                                       const char *),
     1085static int doParseXmlDecl(const ENCODING * (*encodingFinder) (const ENCODING *,
     1086                                                              const char *,
     1087                                                              const char *),
    10861088                          int isGeneralTextEntity,
    10871089                          const ENCODING * enc,
    … …  
    12811283};
    12821284
    1283 int EXPATENTRY XmlSizeOfUnknownEncoding(void)
     1285int XmlSizeOfUnknownEncoding(void)
    12841286{
    12851287    return sizeof(struct unknown_encoding);
    12861288}
    12871289
    1288 static int EXPATENTRY unknown_isName(const ENCODING * enc, const char *p)
     1290static int unknown_isName(const ENCODING * enc, const char *p)
    12891291{
    12901292    int c = ((const struct unknown_encoding *)enc)
    … …  
    12961298}
    12971299
    1298 static int EXPATENTRY unknown_isNmstrt(const ENCODING * enc, const char *p)
     1300static int unknown_isNmstrt(const ENCODING * enc, const char *p)
    12991301{
    13001302    int c = ((const struct unknown_encoding *)enc)
    … …  
    13061308}
    13071309
    1308 static int EXPATENTRY unknown_isInvalid(const ENCODING * enc, const char *p)
     1310static int unknown_isInvalid(const ENCODING * enc, const char *p)
    13091311{
    13101312    int c = ((const struct unknown_encoding *)enc)
    … …  
    13141316}
    13151317
    1316 static void EXPATENTRY unknown_toUtf8(const ENCODING * enc,
    1317                                     const char **fromP,
    1318                                     const char *fromLim,
    1319                                     char **toP,
    1320                                     const char *toLim)
     1318static void unknown_toUtf8(const ENCODING * enc,
     1319                           const char **fromP,
     1320                           const char *fromLim,
     1321                           char **toP,
     1322                           const char *toLim)
    13211323{
    13221324    char buf[XML_UTF8_ENCODE_MAX];
    … …  
    13571359}
    13581360
    1359 static void EXPATENTRY unknown_toUtf16(const ENCODING * enc,
    1360                                        const char **fromP,
    1361                                        const char *fromLim,
    1362                                        unsigned short **toP,
    1363                                        const unsigned short *toLim)
     1361static void unknown_toUtf16(const ENCODING * enc,
     1362                            const char **fromP,
     1363                            const char *fromLim,
     1364                            unsigned short **toP,
     1365                            const unsigned short *toLim)
    13641366{
    13651367    while (*fromP != fromLim && *toP != toLim)
    … …  
    13811383}
    13821384
    1383 ENCODING * XmlInitUnknownEncoding(void *mem,
    1384                                   int *table,
    1385                                   int (*convert) (void *userData, const char *p),
    1386                                   void *userData)
     1385/*
     1386 *@@ XmlInitUnknownEncoding:
     1387 *
     1388 *@@changed V0.9.14 (2001-08-09) [umoeller]: couple of performance hacks
     1389 */
     1390
     1391ENCODING* XmlInitUnknownEncoding(void *mem,
     1392                                 int *table,
     1393                                 int (*convert) (void *userData, const char *p),
     1394                                 void *userData)
    13871395{
    13881396    int i;
    1389     struct unknown_encoding *e = (struct unknown_encoding *)mem;
    1390     for (i = 0; i < (int)sizeof(struct normal_encoding); i++)
    1391 
    1392         ((char *)mem)[i] = ((char *)&latin1_encoding)[i];
     1397    struct unknown_encoding *e = mem;
     1398
     1399    // gee, isn't this a regular memcpy?!?
     1400    /* for (i = 0;
     1401         i < (int)sizeof(struct normal_encoding);
     1402         i++)
     1403        ((char *)mem)[i] = ((char *)&latin1_encoding)[i]; */
     1404
     1405    // replaced the above with this V0.9.14 (2001-08-09) [umoeller]
     1406    memcpy(mem, &latin1_encoding, sizeof(struct normal_encoding));
     1407
    13931408    for (i = 0; i < 128; i++)
    1394         if (latin1_encoding.type[i] != BT_OTHER
    1395             && latin1_encoding.type[i] != BT_NONXML
    1396             && table[i] != i)
     1409        if (    latin1_encoding.type[i] != BT_OTHER
     1410             && latin1_encoding.type[i] != BT_NONXML
     1411             && table[i] != i
     1412           )
    13971413            return 0;
     1414
    13981415    for (i = 0; i < 256; i++)
    13991416    {
    … …  
    14181435        else if (c < 0x80)
    14191436        {
    1420             if (latin1_encoding.type[c] != BT_OTHER
    1421                 && latin1_encoding.type[c] != BT_NONXML
    1422                 && c != i)
     1437            if (    latin1_encoding.type[c] != BT_OTHER
     1438                 && latin1_encoding.type[c] != BT_NONXML
     1439                 && c != i
     1440               )
    14231441                return 0;
    14241442            e->normal.type[i] = latin1_encoding.type[c];
    … …  
    15231541    if (name == 0)
    15241542        return NO_ENC;
    1525     for (i = 0; i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0])); i++)
     1543    for (i = 0;
     1544         i < (int)(sizeof(encodingNames) / sizeof(encodingNames[0]));
     1545         i++)
    15261546        if (streqci(name, encodingNames[i]))
    15271547            return i;
    … …  
    15431563
    15441564
    1545 static int EXPATENTRY initScan(const ENCODING ** encodingTable,
    1546                                const INIT_ENCODING * enc,
    1547                                int state,
    1548                                const char *ptr,
    1549                                const char *end,
    1550                                const char **nextTokPtr)
     1565static int initScan(const ENCODING ** encodingTable,
     1566                    const INIT_ENCODING * enc,
     1567                    int state,
     1568                    const char *ptr,
     1569                    const char *end,
     1570                    const char **nextTokPtr)
    15511571{
    15521572    const ENCODING **encPtr;
    … …  
    16301650                if ((unsigned char)ptr[2] == 0xBF)
    16311651                {
     1652                    *nextTokPtr = ptr + 3;
    16321653                    *encPtr = encodingTable[UTF_8_ENC];
    16331654                    return XML_TOK_BOM;
    … …  
    16871708ENCODING * XmlInitUnknownEncodingNS(void *mem,
    16881709                                    int *table,
    1689                                     int (* EXPATENTRY convert) (void *userData, const char *p),
     1710                                    int (*convert) (void *userData, const char *p),
    16901711                                    void *userData)
    16911712{

  • trunk/src/helpers/xmltok_impl.c

    r38 r97  
    1 
    21/*
    3  *sourcefile xmltok_impl.c
    4  *      part of the expat implementation. See xmlparse.c.
    5  *
    6  *      NOTE: This file must not be compiled directly. It is
    7  *      #include'd from xmltok.c several times.
    8  */
    9 
    10 /*
    11  *      Copyright (C) 2001 Ulrich M”ller.
    12  *      Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd.
    13  *                                     and Clark Cooper.
    14  *
    15  *      Permission is hereby granted, free of charge, to any person obtaining
    16  *      a copy of this software and associated documentation files (the
    17  *      "Software"), to deal in the Software without restriction, including
    18  *      without limitation the rights to use, copy, modify, merge, publish,
    19  *      distribute, sublicense, and/or sell copies of the Software, and to
    20  *      permit persons to whom the Software is furnished to do so, subject to
    21  *      the following conditions:
    22  *
    23  *      The above copyright notice and this permission notice shall be included
    24  *      in all copies or substantial portions of the Software.
    25  *
    26  *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    27  *      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    28  *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    29  *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    30  *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    31  *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    32  *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    33  */
     2Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
     3See the file COPYING for copying permission.
     4*/
    345
    356#ifndef IS_INVALID_CHAR
    … …  
    11788/* ptr points to character following "<!-" */
    11889
    119 static int EXPATENTRY PREFIX(scanComment)(const ENCODING * enc,
    120                                const char *ptr,
    121                                const char *end,
    122                                const char **nextTokPtr)
    123 {
    124     if (ptr != end)
    125     {
    126         if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS))
    127         {
    128             *nextTokPtr = ptr;
    129             return XML_TOK_INVALID;
    130         }
    131         ptr += MINBPC(enc);
    132         while (ptr != end)
    133         {
    134             switch (BYTE_TYPE(enc, ptr))
    135             {
    136                     INVALID_CASES(ptr, nextTokPtr)
    137                 case BT_MINUS:
    138                     if ((ptr += MINBPC(enc)) == end)
    139                         return XML_TOK_PARTIAL;
    140                     if (CHAR_MATCHES(enc, ptr, ASCII_MINUS))
    141                     {
    142                         if ((ptr += MINBPC(enc)) == end)
    143                             return XML_TOK_PARTIAL;
    144                         if (!CHAR_MATCHES(enc, ptr, ASCII_GT))
    145                         {
    146                             *nextTokPtr = ptr;
    147                             return XML_TOK_INVALID;
    148                         }
    149                         *nextTokPtr = ptr + MINBPC(enc);
    150                         return XML_TOK_COMMENT;
    151                     }
    152                     break;
    153                 default:
    154                     ptr += MINBPC(enc);
    155                     break;
    156             }
    157         }
    158     }
    159     return XML_TOK_PARTIAL;
     90static
     91int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
     92            const char **nextTokPtr)
     93{
     94  if (ptr != end) {
     95    if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
     96      *nextTokPtr = ptr;
     97      return XML_TOK_INVALID;
     98    }
     99    ptr += MINBPC(enc);
     100    while (ptr != end) {
     101      switch (BYTE_TYPE(enc, ptr)) {
     102      INVALID_CASES(ptr, nextTokPtr)
     103      case BT_MINUS:
     104    if ((ptr += MINBPC(enc)) == end)
     105      return XML_TOK_PARTIAL;
     106    if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
     107      if ((ptr += MINBPC(enc)) == end)
     108        return XML_TOK_PARTIAL;
     109      if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     110        *nextTokPtr = ptr;
     111        return XML_TOK_INVALID;
     112      }
     113      *nextTokPtr = ptr + MINBPC(enc);
     114      return XML_TOK_COMMENT;
     115    }
     116    break;
     117      default:
     118    ptr += MINBPC(enc);
     119    break;
     120      }
     121    }
     122  }
     123  return XML_TOK_PARTIAL;
    160124}
    161125
    162126/* ptr points to character following "<!" */
    163127
    164 static int EXPATENTRY PREFIX(scanDecl)(const ENCODING * enc,
    165                                      const char *ptr,
    166                                      const char *end,
    167                                      const char **nextTokPtr)
    168 {
     128static
     129int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
     130             const char **nextTokPtr)
     131{
     132  if (ptr == end)
     133    return XML_TOK_PARTIAL;
     134  switch (BYTE_TYPE(enc, ptr)) {
     135  case BT_MINUS:
     136    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     137  case BT_LSQB:
     138    *nextTokPtr = ptr + MINBPC(enc);
     139    return XML_TOK_COND_SECT_OPEN;
     140  case BT_NMSTRT:
     141  case BT_HEX:
     142    ptr += MINBPC(enc);
     143    break;
     144  default:
     145    *nextTokPtr = ptr;
     146    return XML_TOK_INVALID;
     147  }
     148  while (ptr != end) {
     149    switch (BYTE_TYPE(enc, ptr)) {
     150    case BT_PERCNT:
     151      if (ptr + MINBPC(enc) == end)
     152    return XML_TOK_PARTIAL;
     153      /* don't allow <!ENTITY% foo "whatever"> */
     154      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
     155      case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
     156    *nextTokPtr = ptr;
     157    return XML_TOK_INVALID;
     158      }
     159      /* fall through */
     160    case BT_S: case BT_CR: case BT_LF:
     161      *nextTokPtr = ptr;
     162      return XML_TOK_DECL_OPEN;
     163    case BT_NMSTRT:
     164    case BT_HEX:
     165      ptr += MINBPC(enc);
     166      break;
     167    default:
     168      *nextTokPtr = ptr;
     169      return XML_TOK_INVALID;
     170    }
     171  }
     172  return XML_TOK_PARTIAL;
     173}
     174
     175static
     176int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr)
     177{
     178  int upper = 0;
     179  *tokPtr = XML_TOK_PI;
     180  if (end - ptr != MINBPC(enc)*3)
     181    return 1;
     182  switch (BYTE_TO_ASCII(enc, ptr)) {
     183  case ASCII_x:
     184    break;
     185  case ASCII_X:
     186    upper = 1;
     187    break;
     188  default:
     189    return 1;
     190  }
     191  ptr += MINBPC(enc);
     192  switch (BYTE_TO_ASCII(enc, ptr)) {
     193  case ASCII_m:
     194    break;
     195  case ASCII_M:
     196    upper = 1;
     197    break;
     198  default:
     199    return 1;
     200  }
     201  ptr += MINBPC(enc);
     202  switch (BYTE_TO_ASCII(enc, ptr)) {
     203  case ASCII_l:
     204    break;
     205  case ASCII_L:
     206    upper = 1;
     207    break;
     208  default:
     209    return 1;
     210  }
     211  if (upper)
     212    return 0;
     213  *tokPtr = XML_TOK_XML_DECL;
     214  return 1;
     215}
     216
     217/* ptr points to character following "<?" */
     218
     219static
     220int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
     221           const char **nextTokPtr)
     222{
     223  int tok;
     224  const char *target = ptr;
     225  if (ptr == end)
     226    return XML_TOK_PARTIAL;
     227  switch (BYTE_TYPE(enc, ptr)) {
     228  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     229  default:
     230    *nextTokPtr = ptr;
     231    return XML_TOK_INVALID;
     232  }
     233  while (ptr != end) {
     234    switch (BYTE_TYPE(enc, ptr)) {
     235    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     236    case BT_S: case BT_CR: case BT_LF:
     237      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
     238    *nextTokPtr = ptr;
     239    return XML_TOK_INVALID;
     240      }
     241      ptr += MINBPC(enc);
     242      while (ptr != end) {
     243        switch (BYTE_TYPE(enc, ptr)) {
     244        INVALID_CASES(ptr, nextTokPtr)
     245    case BT_QUEST:
     246      ptr += MINBPC(enc);
     247      if (ptr == end)
     248        return XML_TOK_PARTIAL;
     249      if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     250        *nextTokPtr = ptr + MINBPC(enc);
     251        return tok;
     252      }
     253      break;
     254    default:
     255      ptr += MINBPC(enc);
     256      break;
     257    }
     258      }
     259      return XML_TOK_PARTIAL;
     260    case BT_QUEST:
     261      if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
     262    *nextTokPtr = ptr;
     263    return XML_TOK_INVALID;
     264      }
     265      ptr += MINBPC(enc);
     266      if (ptr == end)
     267    return XML_TOK_PARTIAL;
     268      if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     269    *nextTokPtr = ptr + MINBPC(enc);
     270    return tok;
     271      }
     272      /* fall through */
     273    default:
     274      *nextTokPtr = ptr;
     275      return XML_TOK_INVALID;
     276    }
     277  }
     278  return XML_TOK_PARTIAL;
     279}
     280
     281
     282static
     283int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
     284                 const char **nextTokPtr)
     285{
     286  static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB };
     287  int i;
     288  /* CDATA[ */
     289  if (end - ptr < 6 * MINBPC(enc))
     290    return XML_TOK_PARTIAL;
     291  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
     292    if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
     293      *nextTokPtr = ptr;
     294      return XML_TOK_INVALID;
     295    }
     296  }
     297  *nextTokPtr = ptr;
     298  return XML_TOK_CDATA_SECT_OPEN;
     299}
     300
     301static
     302int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
     303                const char **nextTokPtr)
     304{
     305  if (ptr == end)
     306    return XML_TOK_NONE;
     307  if (MINBPC(enc) > 1) {
     308    size_t n = end - ptr;
     309    if (n & (MINBPC(enc) - 1)) {
     310      n &= ~(MINBPC(enc) - 1);
     311      if (n == 0)
     312    return XML_TOK_PARTIAL;
     313      end = ptr + n;
     314    }
     315  }
     316  switch (BYTE_TYPE(enc, ptr)) {
     317  case BT_RSQB:
     318    ptr += MINBPC(enc);
    169319    if (ptr == end)
    170         return XML_TOK_PARTIAL;
    171     switch (BYTE_TYPE(enc, ptr))
    172     {
    173         case BT_MINUS:
    174             return PREFIX(scanComment) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    175         case BT_LSQB:
    176             *nextTokPtr = ptr + MINBPC(enc);
    177             return XML_TOK_COND_SECT_OPEN;
    178         case BT_NMSTRT:
    179         case BT_HEX:
    180             ptr += MINBPC(enc);
    181             break;
    182         default:
    183             *nextTokPtr = ptr;
    184             return XML_TOK_INVALID;
    185     }
    186     while (ptr != end)
    187     {
    188         switch (BYTE_TYPE(enc, ptr))
    189         {
    190             case BT_PERCNT:
    191                 if (ptr + MINBPC(enc) == end)
    192                     return XML_TOK_PARTIAL;
    193                 /* don't allow <!ENTITY% foo "whatever"> */
    194                 switch (BYTE_TYPE(enc, ptr + MINBPC(enc)))
    195                 {
    196                     case BT_S:
    197                     case BT_CR:
    198                     case BT_LF:
    199                     case BT_PERCNT:
    200                         *nextTokPtr = ptr;
    201                         return XML_TOK_INVALID;
    202                 }
    203                 /* fall through */
    204             case BT_S:
    205             case BT_CR:
    206             case BT_LF:
    207                 *nextTokPtr = ptr;
    208                 return XML_TOK_DECL_OPEN;
    209             case BT_NMSTRT:
    210             case BT_HEX:
    211                 ptr += MINBPC(enc);
    212                 break;
    213             default:
    214                 *nextTokPtr = ptr;
    215                 return XML_TOK_INVALID;
    216         }
    217     }
    218     return XML_TOK_PARTIAL;
    219 }
    220 
    221 static int EXPATENTRY PREFIX(checkPiTarget) (const ENCODING * enc, const char *ptr, const char *end, int *tokPtr)
    222 {
    223     int upper = 0;
    224 
    225     *tokPtr = XML_TOK_PI;
    226     if (end - ptr != MINBPC(enc) * 3)
    227         return 1;
    228     switch (BYTE_TO_ASCII(enc, ptr))
    229     {
    230         case ASCII_x:
    231             break;
    232         case ASCII_X:
    233             upper = 1;
    234             break;
    235         default:
    236             return 1;
    237     }
    238     ptr += MINBPC(enc);
    239     switch (BYTE_TO_ASCII(enc, ptr))
    240     {
    241         case ASCII_m:
    242             break;
    243         case ASCII_M:
    244             upper = 1;
    245             break;
    246         default:
    247             return 1;
    248     }
    249     ptr += MINBPC(enc);
    250     switch (BYTE_TO_ASCII(enc, ptr))
    251     {
    252         case ASCII_l:
    253             break;
    254         case ASCII_L:
    255             upper = 1;
    256             break;
    257         default:
    258             return 1;
    259     }
    260     if (upper)
    261         return 0;
    262     *tokPtr = XML_TOK_XML_DECL;
    263     return 1;
    264 }
    265 
    266 /* ptr points to character following "<?" */
    267 
    268 static
    269 int EXPATENTRY PREFIX(scanPi) (const ENCODING * enc, const char *ptr, const char *end,
    270                     const char **nextTokPtr)
    271 {
    272     int tok;
    273     const char *target = ptr;
    274 
     320      return XML_TOK_PARTIAL;
     321    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
     322      break;
     323    ptr += MINBPC(enc);
    275324    if (ptr == end)
    276         return XML_TOK_PARTIAL;
    277     switch (BYTE_TYPE(enc, ptr))
    278     {
    279             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    280         default:
    281             *nextTokPtr = ptr;
    282             return XML_TOK_INVALID;
    283     }
    284     while (ptr != end)
    285     {
    286         switch (BYTE_TYPE(enc, ptr))
    287         {
    288                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    289             case BT_S:
    290             case BT_CR:
    291             case BT_LF:
    292                 if (!PREFIX(checkPiTarget) (enc, target, ptr, &tok))
    293                 {
    294                     *nextTokPtr = ptr;
    295                     return XML_TOK_INVALID;
    296                 }
    297                 ptr += MINBPC(enc);
    298                 while (ptr != end)
    299                 {
    300                     switch (BYTE_TYPE(enc, ptr))
    301                     {
    302                             INVALID_CASES(ptr, nextTokPtr)
    303                         case BT_QUEST:
    304                             ptr += MINBPC(enc);
    305                             if (ptr == end)
    306                                 return XML_TOK_PARTIAL;
    307                             if (CHAR_MATCHES(enc, ptr, ASCII_GT))
    308                             {
    309                                 *nextTokPtr = ptr + MINBPC(enc);
    310                                 return tok;
    311                             }
    312                             break;
    313                         default:
    314                             ptr += MINBPC(enc);
    315                             break;
    316                     }
    317                 }
    318                 return XML_TOK_PARTIAL;
    319             case BT_QUEST:
    320                 if (!PREFIX(checkPiTarget) (enc, target, ptr, &tok))
    321                 {
    322                     *nextTokPtr = ptr;
    323                     return XML_TOK_INVALID;
    324                 }
    325                 ptr += MINBPC(enc);
    326                 if (ptr == end)
    327                     return XML_TOK_PARTIAL;
    328                 if (CHAR_MATCHES(enc, ptr, ASCII_GT))
    329                 {
    330                     *nextTokPtr = ptr + MINBPC(enc);
    331                     return tok;
    332                 }
    333                 /* fall through */
    334             default:
    335                 *nextTokPtr = ptr;
    336                 return XML_TOK_INVALID;
    337         }
    338     }
    339     return XML_TOK_PARTIAL;
    340 }
    341 
    342 
    343 static
    344 int EXPATENTRY PREFIX(scanCdataSection) (const ENCODING * enc, const char *ptr, const char *end,
    345                               const char **nextTokPtr)
    346 {
    347     static const char CDATA_LSQB[] =
    348     {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
    349     int i;
    350 
    351     /* CDATA[ */
    352     if (end - ptr < 6 * MINBPC(enc))
    353         return XML_TOK_PARTIAL;
    354     for (i = 0; i < 6; i++, ptr += MINBPC(enc))
    355     {
    356         if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i]))
    357         {
    358             *nextTokPtr = ptr;
    359             return XML_TOK_INVALID;
    360         }
    361     }
    362     *nextTokPtr = ptr;
    363     return XML_TOK_CDATA_SECT_OPEN;
    364 }
    365 
    366 static
    367 int EXPATENTRY PREFIX(cdataSectionTok) (const ENCODING * enc, const char *ptr, const char *end,
    368                              const char **nextTokPtr)
    369 {
     325      return XML_TOK_PARTIAL;
     326    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     327      ptr -= MINBPC(enc);
     328      break;
     329    }
     330    *nextTokPtr = ptr + MINBPC(enc);
     331    return XML_TOK_CDATA_SECT_CLOSE;
     332  case BT_CR:
     333    ptr += MINBPC(enc);
    370334    if (ptr == end)
    371         return XML_TOK_NONE;
    372     if (MINBPC(enc) > 1)
    373     {
    374         size_t n = end - ptr;
    375 
    376         if (n & (MINBPC(enc) - 1))
    377         {
    378             n &= ~(MINBPC(enc) - 1);
    379             if (n == 0)
    380                 return XML_TOK_PARTIAL;
    381             end = ptr + n;
    382         }
    383     }
    384     switch (BYTE_TYPE(enc, ptr))
    385     {
    386         case BT_RSQB:
    387             ptr += MINBPC(enc);
    388             if (ptr == end)
    389                 return XML_TOK_PARTIAL;
    390             if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
    391                 break;
    392             ptr += MINBPC(enc);
    393             if (ptr == end)
    394                 return XML_TOK_PARTIAL;
    395             if (!CHAR_MATCHES(enc, ptr, ASCII_GT))
    396             {
    397                 ptr -= MINBPC(enc);
    398                 break;
    399             }
    400             *nextTokPtr = ptr + MINBPC(enc);
    401             return XML_TOK_CDATA_SECT_CLOSE;
    402         case BT_CR:
    403             ptr += MINBPC(enc);
    404             if (ptr == end)
    405                 return XML_TOK_PARTIAL;
    406             if (BYTE_TYPE(enc, ptr) == BT_LF)
    407                 ptr += MINBPC(enc);
    408             *nextTokPtr = ptr;
    409             return XML_TOK_DATA_NEWLINE;
    410         case BT_LF:
    411             *nextTokPtr = ptr + MINBPC(enc);
    412             return XML_TOK_DATA_NEWLINE;
    413             INVALID_CASES(ptr, nextTokPtr)
    414         default:
    415             ptr += MINBPC(enc);
    416             break;
    417     }
    418     while (ptr != end)
    419     {
    420         switch (BYTE_TYPE(enc, ptr))
    421         {
     335      return XML_TOK_PARTIAL;
     336    if (BYTE_TYPE(enc, ptr) == BT_LF)
     337      ptr += MINBPC(enc);
     338    *nextTokPtr = ptr;
     339    return XML_TOK_DATA_NEWLINE;
     340  case BT_LF:
     341    *nextTokPtr = ptr + MINBPC(enc);
     342    return XML_TOK_DATA_NEWLINE;
     343  INVALID_CASES(ptr, nextTokPtr)
     344  default:
     345    ptr += MINBPC(enc);
     346    break;
     347  }
     348  while (ptr != end) {
     349    switch (BYTE_TYPE(enc, ptr)) {
    422350#define LEAD_CASE(n) \
    423351    case BT_LEAD ## n: \
    … …  
    428356      ptr += n; \
    429357      break;
    430                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     358    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    431359#undef LEAD_CASE
    432             case BT_NONXML:
    433             case BT_MALFORM:
    434             case BT_TRAIL:
    435             case BT_CR:
    436             case BT_LF:
    437             case BT_RSQB:
    438                 *nextTokPtr = ptr;
    439                 return XML_TOK_DATA_CHARS;
    440             default:
    441                 ptr += MINBPC(enc);
    442                 break;
    443         }
    444     }
    445     *nextTokPtr = ptr;
    446     return XML_TOK_DATA_CHARS;
     360    case BT_NONXML:
     361    case BT_MALFORM:
     362    case BT_TRAIL:
     363    case BT_CR:
     364    case BT_LF:
     365    case BT_RSQB:
     366      *nextTokPtr = ptr;
     367      return XML_TOK_DATA_CHARS;
     368    default:
     369      ptr += MINBPC(enc);
     370      break;
     371    }
     372  }
     373  *nextTokPtr = ptr;
     374  return XML_TOK_DATA_CHARS;
    447375}
    448376
    … …  
    450378
    451379static
    452 int EXPATENTRY PREFIX(scanEndTag) (const ENCODING * enc, const char *ptr, const char *end,
    453                         const char **nextTokPtr)
    454 {
     380int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
     381               const char **nextTokPtr)
     382{
     383  if (ptr == end)
     384    return XML_TOK_PARTIAL;
     385  switch (BYTE_TYPE(enc, ptr)) {
     386  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     387  default:
     388    *nextTokPtr = ptr;
     389    return XML_TOK_INVALID;
     390  }
     391  while (ptr != end) {
     392    switch (BYTE_TYPE(enc, ptr)) {
     393    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     394    case BT_S: case BT_CR: case BT_LF:
     395      for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
     396    switch (BYTE_TYPE(enc, ptr)) {
     397    case BT_S: case BT_CR: case BT_LF:
     398      break;
     399    case BT_GT:
     400      *nextTokPtr = ptr + MINBPC(enc);
     401          return XML_TOK_END_TAG;
     402    default:
     403      *nextTokPtr = ptr;
     404      return XML_TOK_INVALID;
     405    }
     406      }
     407      return XML_TOK_PARTIAL;
     408#ifdef XML_NS
     409    case BT_COLON:
     410      /* no need to check qname syntax here, since end-tag must match exactly */
     411      ptr += MINBPC(enc);
     412      break;
     413#endif
     414    case BT_GT:
     415      *nextTokPtr = ptr + MINBPC(enc);
     416      return XML_TOK_END_TAG;
     417    default:
     418      *nextTokPtr = ptr;
     419      return XML_TOK_INVALID;
     420    }
     421  }
     422  return XML_TOK_PARTIAL;
     423}
     424
     425/* ptr points to character following "&#X" */
     426
     427static
     428int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
     429               const char **nextTokPtr)
     430{
     431  if (ptr != end) {
     432    switch (BYTE_TYPE(enc, ptr)) {
     433    case BT_DIGIT:
     434    case BT_HEX:
     435      break;
     436    default:
     437      *nextTokPtr = ptr;
     438      return XML_TOK_INVALID;
     439    }
     440    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
     441      switch (BYTE_TYPE(enc, ptr)) {
     442      case BT_DIGIT:
     443      case BT_HEX:
     444    break;
     445      case BT_SEMI:
     446    *nextTokPtr = ptr + MINBPC(enc);
     447    return XML_TOK_CHAR_REF;
     448      default:
     449    *nextTokPtr = ptr;
     450    return XML_TOK_INVALID;
     451      }
     452    }
     453  }
     454  return XML_TOK_PARTIAL;
     455}
     456
     457/* ptr points to character following "&#" */
     458
     459static
     460int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
     461            const char **nextTokPtr)
     462{
     463  if (ptr != end) {
     464    if (CHAR_MATCHES(enc, ptr, ASCII_x))
     465      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     466    switch (BYTE_TYPE(enc, ptr)) {
     467    case BT_DIGIT:
     468      break;
     469    default:
     470      *nextTokPtr = ptr;
     471      return XML_TOK_INVALID;
     472    }
     473    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
     474      switch (BYTE_TYPE(enc, ptr)) {
     475      case BT_DIGIT:
     476    break;
     477      case BT_SEMI:
     478    *nextTokPtr = ptr + MINBPC(enc);
     479    return XML_TOK_CHAR_REF;
     480      default:
     481    *nextTokPtr = ptr;
     482    return XML_TOK_INVALID;
     483      }
     484    }
     485  }
     486  return XML_TOK_PARTIAL;
     487}
     488
     489/* ptr points to character following "&" */
     490
     491static
     492int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
     493            const char **nextTokPtr)
     494{
     495  if (ptr == end)
     496    return XML_TOK_PARTIAL;
     497  switch (BYTE_TYPE(enc, ptr)) {
     498  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     499  case BT_NUM:
     500    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     501  default:
     502    *nextTokPtr = ptr;
     503    return XML_TOK_INVALID;
     504  }
     505  while (ptr != end) {
     506    switch (BYTE_TYPE(enc, ptr)) {
     507    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     508    case BT_SEMI:
     509      *nextTokPtr = ptr + MINBPC(enc);
     510      return XML_TOK_ENTITY_REF;
     511    default:
     512      *nextTokPtr = ptr;
     513      return XML_TOK_INVALID;
     514    }
     515  }
     516  return XML_TOK_PARTIAL;
     517}
     518
     519/* ptr points to character following first character of attribute name */
     520
     521static
     522int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
     523             const char **nextTokPtr)
     524{
     525#ifdef XML_NS
     526  int hadColon = 0;
     527#endif
     528  while (ptr != end) {
     529    switch (BYTE_TYPE(enc, ptr)) {
     530    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     531#ifdef XML_NS
     532    case BT_COLON:
     533      if (hadColon) {
     534    *nextTokPtr = ptr;
     535    return XML_TOK_INVALID;
     536      }
     537      hadColon = 1;
     538      ptr += MINBPC(enc);
     539      if (ptr == end)
     540    return XML_TOK_PARTIAL;
     541      switch (BYTE_TYPE(enc, ptr)) {
     542      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     543      default:
     544    *nextTokPtr = ptr;
     545    return XML_TOK_INVALID;
     546      }
     547      break;
     548#endif
     549    case BT_S: case BT_CR: case BT_LF:
     550      for (;;) {
     551    int t;
     552
     553    ptr += MINBPC(enc);
    455554    if (ptr == end)
    456         return XML_TOK_PARTIAL;
    457     switch (BYTE_TYPE(enc, ptr))
    458     {
    459             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    460         default:
    461             *nextTokPtr = ptr;
    462             return XML_TOK_INVALID;
    463     }
    464     while (ptr != end)
    465     {
    466         switch (BYTE_TYPE(enc, ptr))
    467         {
    468                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    469             case BT_S:
    470             case BT_CR:
    471             case BT_LF:
    472                 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc))
    473                 {
    474                     switch (BYTE_TYPE(enc, ptr))
    475                     {
    476                         case BT_S:
    477                         case BT_CR:
    478                         case BT_LF:
    479                             break;
    480                         case BT_GT:
    481                             *nextTokPtr = ptr + MINBPC(enc);
    482                             return XML_TOK_END_TAG;
    483                         default:
    484                             *nextTokPtr = ptr;
    485                             return XML_TOK_INVALID;
    486                     }
    487                 }
    488                 return XML_TOK_PARTIAL;
    489 #ifdef XML_NS
    490             case BT_COLON:
    491                 /* no need to check qname syntax here, since end-tag must match exactly */
    492                 ptr += MINBPC(enc);
    493                 break;
    494 #endif
    495             case BT_GT:
    496                 *nextTokPtr = ptr + MINBPC(enc);
    497                 return XML_TOK_END_TAG;
    498             default:
    499                 *nextTokPtr = ptr;
    500                 return XML_TOK_INVALID;
    501         }
    502     }
    503     return XML_TOK_PARTIAL;
    504 }
    505 
    506 /* ptr points to character following "&#X" */
    507 
    508 static
    509 int EXPATENTRY PREFIX(scanHexCharRef) (const ENCODING * enc, const char *ptr, const char *end,
    510                             const char **nextTokPtr)
    511 {
    512     if (ptr != end)
    513     {
    514         switch (BYTE_TYPE(enc, ptr))
    515         {
    516             case BT_DIGIT:
    517             case BT_HEX:
    518                 break;
    519             default:
    520                 *nextTokPtr = ptr;
    521                 return XML_TOK_INVALID;
    522         }
    523         for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc))
    524         {
    525             switch (BYTE_TYPE(enc, ptr))
    526             {
    527                 case BT_DIGIT:
    528                 case BT_HEX:
    529                     break;
    530                 case BT_SEMI:
    531                     *nextTokPtr = ptr + MINBPC(enc);
    532                     return XML_TOK_CHAR_REF;
    533                 default:
    534                     *nextTokPtr = ptr;
    535                     return XML_TOK_INVALID;
    536             }
    537         }
    538     }
    539     return XML_TOK_PARTIAL;
    540 }
    541 
    542 /* ptr points to character following "&#" */
    543 
    544 static
    545 int EXPATENTRY PREFIX(scanCharRef) (const ENCODING * enc, const char *ptr, const char *end,
    546                          const char **nextTokPtr)
    547 {
    548     if (ptr != end)
    549     {
    550         if (CHAR_MATCHES(enc, ptr, ASCII_x))
    551             return PREFIX(scanHexCharRef) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    552         switch (BYTE_TYPE(enc, ptr))
    553         {
    554             case BT_DIGIT:
    555                 break;
    556             default:
    557                 *nextTokPtr = ptr;
    558                 return XML_TOK_INVALID;
    559         }
    560         for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc))
    561         {
    562             switch (BYTE_TYPE(enc, ptr))
    563             {
    564                 case BT_DIGIT:
    565                     break;
    566                 case BT_SEMI:
    567                     *nextTokPtr = ptr + MINBPC(enc);
    568                     return XML_TOK_CHAR_REF;
    569                 default:
    570                     *nextTokPtr = ptr;
    571                     return XML_TOK_INVALID;
    572             }
    573         }
    574     }
    575     return XML_TOK_PARTIAL;
    576 }
    577 
    578 /* ptr points to character following "&" */
    579 
    580 static
    581 int EXPATENTRY PREFIX(scanRef) (const ENCODING * enc, const char *ptr, const char *end,
    582                      const char **nextTokPtr)
    583 {
    584     if (ptr == end)
    585         return XML_TOK_PARTIAL;
    586     switch (BYTE_TYPE(enc, ptr))
    587     {
    588             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    589         case BT_NUM:
    590             return PREFIX(scanCharRef) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    591         default:
    592             *nextTokPtr = ptr;
    593             return XML_TOK_INVALID;
    594     }
    595     while (ptr != end)
    596     {
    597         switch (BYTE_TYPE(enc, ptr))
    598         {
    599                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    600             case BT_SEMI:
    601                 *nextTokPtr = ptr + MINBPC(enc);
    602                 return XML_TOK_ENTITY_REF;
    603             default:
    604                 *nextTokPtr = ptr;
    605                 return XML_TOK_INVALID;
    606         }
    607     }
    608     return XML_TOK_PARTIAL;
    609 }
    610 
    611 /* ptr points to character following first character of attribute name */
    612 
    613 static
    614 int EXPATENTRY PREFIX(scanAtts) (const ENCODING * enc, const char *ptr, const char *end,
    615                       const char **nextTokPtr)
    616 {
    617 #ifdef XML_NS
    618     int hadColon = 0;
    619 
    620 #endif
    621     while (ptr != end)
    622     {
    623         switch (BYTE_TYPE(enc, ptr))
    624         {
    625                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    626 #ifdef XML_NS
    627             case BT_COLON:
    628                 if (hadColon)
    629                 {
    630                     *nextTokPtr = ptr;
    631                     return XML_TOK_INVALID;
    632                 }
    633                 hadColon = 1;
    634                 ptr += MINBPC(enc);
    635                 if (ptr == end)
    636                     return XML_TOK_PARTIAL;
    637                 switch (BYTE_TYPE(enc, ptr))
    638                 {
    639                         CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    640                     default:
    641                         *nextTokPtr = ptr;
    642                         return XML_TOK_INVALID;
    643                 }
    644                 break;
    645 #endif
    646             case BT_S:
    647             case BT_CR:
    648             case BT_LF:
    649                 for (;;)
    650                 {
    651                     int t;
    652 
    653                     ptr += MINBPC(enc);
    654                     if (ptr == end)
    655                         return XML_TOK_PARTIAL;
    656                     t = BYTE_TYPE(enc, ptr);
    657                     if (t == BT_EQUALS)
    658                         break;
    659                     switch (t)
    660                     {
    661                         case BT_S:
    662                         case BT_LF:
    663                         case BT_CR:
    664                             break;
    665                         default:
    666                             *nextTokPtr = ptr;
    667                             return XML_TOK_INVALID;
    668                     }
    669                 }
    670                 /* fall through */
    671             case BT_EQUALS:
    672                 {
    673                     int open;
    674 
    675 #ifdef XML_NS
    676                     hadColon = 0;
    677 #endif
    678                     for (;;)
    679                     {
    680 
    681                         ptr += MINBPC(enc);
    682                         if (ptr == end)
    683                             return XML_TOK_PARTIAL;
    684                         open = BYTE_TYPE(enc, ptr);
    685                         if (open == BT_QUOT || open == BT_APOS)
    686                             break;
    687                         switch (open)
    688                         {
    689                             case BT_S:
    690                             case BT_LF:
    691                             case BT_CR:
    692                                 break;
    693                             default:
    694                                 *nextTokPtr = ptr;
    695                                 return XML_TOK_INVALID;
    696                         }
    697                     }
    698                     ptr += MINBPC(enc);
    699                     /* in attribute value */
    700                     for (;;)
    701                     {
    702                         int t;
    703 
    704                         if (ptr == end)
    705                             return XML_TOK_PARTIAL;
    706                         t = BYTE_TYPE(enc, ptr);
    707                         if (t == open)
    708                             break;
    709                         switch (t)
    710                         {
    711                                 INVALID_CASES(ptr, nextTokPtr)
    712                             case BT_AMP:
    713                                 {
    714                                     int tok = PREFIX(scanRef) (enc, ptr + MINBPC(enc), end, &ptr);
    715 
    716                                     if (tok <= 0)
    717                                     {
    718                                         if (tok == XML_TOK_INVALID)
    719                                             *nextTokPtr = ptr;
    720                                         return tok;
    721                                     }
    722                                     break;
    723                                 }
    724                             case BT_LT:
    725                                 *nextTokPtr = ptr;
    726                                 return XML_TOK_INVALID;
    727                             default:
    728                                 ptr += MINBPC(enc);
    729                                 break;
    730                         }
    731                     }
    732                     ptr += MINBPC(enc);
    733                     if (ptr == end)
    734                         return XML_TOK_PARTIAL;
    735                     switch (BYTE_TYPE(enc, ptr))
    736                     {
    737                         case BT_S:
    738                         case BT_CR:
    739                         case BT_LF:
    740                             break;
    741                         case BT_SOL:
    742                             goto sol;
    743                         case BT_GT:
    744                             goto gt;
    745                         default:
    746                             *nextTokPtr = ptr;
    747                             return XML_TOK_INVALID;
    748                     }
    749                     /* ptr points to closing quote */
    750                     for (;;)
    751                     {
    752                         ptr += MINBPC(enc);
    753                         if (ptr == end)
    754                             return XML_TOK_PARTIAL;
    755                         switch (BYTE_TYPE(enc, ptr))
    756                         {
    757                                 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    758                             case BT_S:
    759                             case BT_CR:
    760                             case BT_LF:
    761                                 continue;
    762                             case BT_GT:
    763                               gt:
    764                                 *nextTokPtr = ptr + MINBPC(enc);
    765                                 return XML_TOK_START_TAG_WITH_ATTS;
    766                             case BT_SOL:
    767                               sol:
    768                                 ptr += MINBPC(enc);
    769                                 if (ptr == end)
    770                                     return XML_TOK_PARTIAL;
    771                                 if (!CHAR_MATCHES(enc, ptr, ASCII_GT))
    772                                 {
    773                                     *nextTokPtr = ptr;
    774                                     return XML_TOK_INVALID;
    775                                 }
    776                                 *nextTokPtr = ptr + MINBPC(enc);
    777                                 return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
    778                             default:
    779                                 *nextTokPtr = ptr;
    780                                 return XML_TOK_INVALID;
    781                         }
    782                         break;
    783                     }
    784                     break;
    785                 }
    786             default:
    787                 *nextTokPtr = ptr;
    788                 return XML_TOK_INVALID;
    789         }
    790     }
    791     return XML_TOK_PARTIAL;
    792 }
    793 
    794 /* ptr points to character following "<" */
    795 
    796 static
    797 int EXPATENTRY PREFIX(scanLt) (const ENCODING * enc, const char *ptr, const char *end,
    798                     const char **nextTokPtr)
    799 {
    800 #ifdef XML_NS
    801     int hadColon;
    802 
    803 #endif
    804     if (ptr == end)
    805         return XML_TOK_PARTIAL;
    806     switch (BYTE_TYPE(enc, ptr))
    807     {
    808             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    809         case BT_EXCL:
    810             if ((ptr += MINBPC(enc)) == end)
    811                 return XML_TOK_PARTIAL;
    812             switch (BYTE_TYPE(enc, ptr))
    813             {
    814                 case BT_MINUS:
    815                     return PREFIX(scanComment) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    816                 case BT_LSQB:
    817                     return PREFIX(scanCdataSection) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    818             }
    819             *nextTokPtr = ptr;
    820             return XML_TOK_INVALID;
    821         case BT_QUEST:
    822             return PREFIX(scanPi) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    823         case BT_SOL:
    824             return PREFIX(scanEndTag) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    825         default:
    826             *nextTokPtr = ptr;
    827             return XML_TOK_INVALID;
    828     }
     555      return XML_TOK_PARTIAL;
     556    t = BYTE_TYPE(enc, ptr);
     557    if (t == BT_EQUALS)
     558      break;
     559    switch (t) {
     560    case BT_S:
     561    case BT_LF:
     562    case BT_CR:
     563      break;
     564    default:
     565      *nextTokPtr = ptr;
     566      return XML_TOK_INVALID;
     567    }
     568      }
     569    /* fall through */
     570    case BT_EQUALS:
     571      {
     572    int open;
    829573#ifdef XML_NS
    830574    hadColon = 0;
    831575#endif
    832     /* we have a start-tag */
    833     while (ptr != end)
    834     {
    835         switch (BYTE_TYPE(enc, ptr))
     576    for (;;) {
     577
     578      ptr += MINBPC(enc);
     579      if (ptr == end)
     580        return XML_TOK_PARTIAL;
     581      open = BYTE_TYPE(enc, ptr);
     582      if (open == BT_QUOT || open == BT_APOS)
     583        break;
     584      switch (open) {
     585      case BT_S:
     586      case BT_LF:
     587      case BT_CR:
     588        break;
     589      default:
     590        *nextTokPtr = ptr;
     591        return XML_TOK_INVALID;
     592      }
     593    }
     594    ptr += MINBPC(enc);
     595    /* in attribute value */
     596    for (;;) {
     597      int t;
     598      if (ptr == end)
     599        return XML_TOK_PARTIAL;
     600      t = BYTE_TYPE(enc, ptr);
     601      if (t == open)
     602        break;
     603      switch (t) {
     604      INVALID_CASES(ptr, nextTokPtr)
     605      case BT_AMP:
    836606        {
    837                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     607          int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
     608          if (tok <= 0) {
     609        if (tok == XML_TOK_INVALID)
     610          *nextTokPtr = ptr;
     611        return tok;
     612          }
     613          break;
     614        }
     615      case BT_LT:
     616        *nextTokPtr = ptr;
     617        return XML_TOK_INVALID;
     618      default:
     619        ptr += MINBPC(enc);
     620        break;
     621      }
     622    }
     623    ptr += MINBPC(enc);
     624    if (ptr == end)
     625      return XML_TOK_PARTIAL;
     626    switch (BYTE_TYPE(enc, ptr)) {
     627    case BT_S:
     628    case BT_CR:
     629    case BT_LF:
     630      break;
     631    case BT_SOL:
     632      goto sol;
     633    case BT_GT:
     634      goto gt;
     635    default:
     636      *nextTokPtr = ptr;
     637      return XML_TOK_INVALID;
     638    }
     639    /* ptr points to closing quote */
     640    for (;;) {
     641      ptr += MINBPC(enc);
     642      if (ptr == end)
     643        return XML_TOK_PARTIAL;
     644      switch (BYTE_TYPE(enc, ptr)) {
     645      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     646      case BT_S: case BT_CR: case BT_LF:
     647        continue;
     648      case BT_GT:
     649          gt:
     650        *nextTokPtr = ptr + MINBPC(enc);
     651        return XML_TOK_START_TAG_WITH_ATTS;
     652      case BT_SOL:
     653          sol:
     654        ptr += MINBPC(enc);
     655        if (ptr == end)
     656          return XML_TOK_PARTIAL;
     657        if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     658          *nextTokPtr = ptr;
     659          return XML_TOK_INVALID;
     660        }
     661        *nextTokPtr = ptr + MINBPC(enc);
     662        return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
     663      default:
     664        *nextTokPtr = ptr;
     665        return XML_TOK_INVALID;
     666      }
     667      break;
     668    }
     669    break;
     670      }
     671    default:
     672      *nextTokPtr = ptr;
     673      return XML_TOK_INVALID;
     674    }
     675  }
     676  return XML_TOK_PARTIAL;
     677}
     678
     679/* ptr points to character following "<" */
     680
     681static
     682int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
     683           const char **nextTokPtr)
     684{
    838685#ifdef XML_NS
    839             case BT_COLON:
    840                 if (hadColon)
    841                 {
    842                     *nextTokPtr = ptr;
    843                     return XML_TOK_INVALID;
    844                 }
    845                 hadColon = 1;
    846                 ptr += MINBPC(enc);
    847                 if (ptr == end)
    848                     return XML_TOK_PARTIAL;
    849                 switch (BYTE_TYPE(enc, ptr))
    850                 {
    851                         CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    852                     default:
    853                         *nextTokPtr = ptr;
    854                         return XML_TOK_INVALID;
    855                 }
    856                 break;
     686  int hadColon;
    857687#endif
    858             case BT_S:
    859             case BT_CR:
    860             case BT_LF:
    861                 {
    862                     ptr += MINBPC(enc);
    863                     while (ptr != end)
    864                     {
    865                         switch (BYTE_TYPE(enc, ptr))
    866                         {
    867                                 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    868                             case BT_GT:
    869                                 goto gt;
    870                             case BT_SOL:
    871                                 goto sol;
    872                             case BT_S:
    873                             case BT_CR:
    874                             case BT_LF:
    875                                 ptr += MINBPC(enc);
    876                                 continue;
    877                             default:
    878                                 *nextTokPtr = ptr;
    879                                 return XML_TOK_INVALID;
    880                         }
    881                         return PREFIX(scanAtts) (enc, ptr, end, nextTokPtr);
    882                     }
    883                     return XML_TOK_PARTIAL;
    884                 }
    885             case BT_GT:
    886               gt:
    887                 *nextTokPtr = ptr + MINBPC(enc);
    888                 return XML_TOK_START_TAG_NO_ATTS;
    889             case BT_SOL:
    890               sol:
    891                 ptr += MINBPC(enc);
    892                 if (ptr == end)
    893                     return XML_TOK_PARTIAL;
    894                 if (!CHAR_MATCHES(enc, ptr, ASCII_GT))
    895                 {
    896                     *nextTokPtr = ptr;
    897                     return XML_TOK_INVALID;
    898                 }
    899                 *nextTokPtr = ptr + MINBPC(enc);
    900                 return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
    901             default:
    902                 *nextTokPtr = ptr;
    903                 return XML_TOK_INVALID;
    904         }
    905     }
    906     return XML_TOK_PARTIAL;
    907 }
    908 
    909 static
    910 int EXPATENTRY PREFIX(contentTok) (const ENCODING * enc, const char *ptr, const char *end,
    911                         const char **nextTokPtr)
    912 {
     688  if (ptr == end)
     689    return XML_TOK_PARTIAL;
     690  switch (BYTE_TYPE(enc, ptr)) {
     691  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     692  case BT_EXCL:
     693    if ((ptr += MINBPC(enc)) == end)
     694      return XML_TOK_PARTIAL;
     695    switch (BYTE_TYPE(enc, ptr)) {
     696    case BT_MINUS:
     697      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     698    case BT_LSQB:
     699      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     700    }
     701    *nextTokPtr = ptr;
     702    return XML_TOK_INVALID;
     703  case BT_QUEST:
     704    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     705  case BT_SOL:
     706    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     707  default:
     708    *nextTokPtr = ptr;
     709    return XML_TOK_INVALID;
     710  }
     711#ifdef XML_NS
     712  hadColon = 0;
     713#endif
     714  /* we have a start-tag */
     715  while (ptr != end) {
     716    switch (BYTE_TYPE(enc, ptr)) {
     717    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     718#ifdef XML_NS
     719    case BT_COLON:
     720      if (hadColon) {
     721    *nextTokPtr = ptr;
     722    return XML_TOK_INVALID;
     723      }
     724      hadColon = 1;
     725      ptr += MINBPC(enc);
     726      if (ptr == end)
     727    return XML_TOK_PARTIAL;
     728      switch (BYTE_TYPE(enc, ptr)) {
     729      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     730      default:
     731        *nextTokPtr = ptr;
     732        return XML_TOK_INVALID;
     733      }
     734      break;
     735#endif
     736    case BT_S: case BT_CR: case BT_LF:
     737      {
     738        ptr += MINBPC(enc);
     739    while (ptr != end) {
     740      switch (BYTE_TYPE(enc, ptr)) {
     741      CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     742      case BT_GT:
     743        goto gt;
     744      case BT_SOL:
     745        goto sol;
     746      case BT_S: case BT_CR: case BT_LF:
     747        ptr += MINBPC(enc);
     748        continue;
     749      default:
     750        *nextTokPtr = ptr;
     751        return XML_TOK_INVALID;
     752      }
     753      return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
     754    }
     755    return XML_TOK_PARTIAL;
     756      }
     757    case BT_GT:
     758    gt:
     759      *nextTokPtr = ptr + MINBPC(enc);
     760      return XML_TOK_START_TAG_NO_ATTS;
     761    case BT_SOL:
     762    sol:
     763      ptr += MINBPC(enc);
     764      if (ptr == end)
     765    return XML_TOK_PARTIAL;
     766      if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     767    *nextTokPtr = ptr;
     768    return XML_TOK_INVALID;
     769      }
     770      *nextTokPtr = ptr + MINBPC(enc);
     771      return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
     772    default:
     773      *nextTokPtr = ptr;
     774      return XML_TOK_INVALID;
     775    }
     776  }
     777  return XML_TOK_PARTIAL;
     778}
     779
     780static
     781int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
     782               const char **nextTokPtr)
     783{
     784  if (ptr == end)
     785    return XML_TOK_NONE;
     786  if (MINBPC(enc) > 1) {
     787    size_t n = end - ptr;
     788    if (n & (MINBPC(enc) - 1)) {
     789      n &= ~(MINBPC(enc) - 1);
     790      if (n == 0)
     791    return XML_TOK_PARTIAL;
     792      end = ptr + n;
     793    }
     794  }
     795  switch (BYTE_TYPE(enc, ptr)) {
     796  case BT_LT:
     797    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     798  case BT_AMP:
     799    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     800  case BT_CR:
     801    ptr += MINBPC(enc);
    913802    if (ptr == end)
    914         return XML_TOK_NONE;
    915     if (MINBPC(enc) > 1)
    916     {
    917         size_t n = end - ptr;
    918 
    919         if (n & (MINBPC(enc) - 1))
    920         {
    921             n &= ~(MINBPC(enc) - 1);
    922             if (n == 0)
    923                 return XML_TOK_PARTIAL;
    924             end = ptr + n;
    925         }
    926     }
    927     switch (BYTE_TYPE(enc, ptr))
    928     {
    929         case BT_LT:
    930             return PREFIX(scanLt) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    931         case BT_AMP:
    932             return PREFIX(scanRef) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    933         case BT_CR:
    934             ptr += MINBPC(enc);
    935             if (ptr == end)
    936                 return XML_TOK_TRAILING_CR;
    937             if (BYTE_TYPE(enc, ptr) == BT_LF)
    938                 ptr += MINBPC(enc);
    939             *nextTokPtr = ptr;
    940             return XML_TOK_DATA_NEWLINE;
    941         case BT_LF:
    942             *nextTokPtr = ptr + MINBPC(enc);
    943             return XML_TOK_DATA_NEWLINE;
    944         case BT_RSQB:
    945             ptr += MINBPC(enc);
    946             if (ptr == end)
    947                 return XML_TOK_TRAILING_RSQB;
    948             if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
    949                 break;
    950             ptr += MINBPC(enc);
    951             if (ptr == end)
    952                 return XML_TOK_TRAILING_RSQB;
    953             if (!CHAR_MATCHES(enc, ptr, ASCII_GT))
    954             {
    955                 ptr -= MINBPC(enc);
    956                 break;
    957             }
    958             *nextTokPtr = ptr;
    959             return XML_TOK_INVALID;
    960             INVALID_CASES(ptr, nextTokPtr)
    961         default:
    962             ptr += MINBPC(enc);
    963             break;
    964     }
    965     while (ptr != end)
    966     {
    967         switch (BYTE_TYPE(enc, ptr))
    968         {
     803      return XML_TOK_TRAILING_CR;
     804    if (BYTE_TYPE(enc, ptr) == BT_LF)
     805      ptr += MINBPC(enc);
     806    *nextTokPtr = ptr;
     807    return XML_TOK_DATA_NEWLINE;
     808  case BT_LF:
     809    *nextTokPtr = ptr + MINBPC(enc);
     810    return XML_TOK_DATA_NEWLINE;
     811  case BT_RSQB:
     812    ptr += MINBPC(enc);
     813    if (ptr == end)
     814      return XML_TOK_TRAILING_RSQB;
     815    if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
     816      break;
     817    ptr += MINBPC(enc);
     818    if (ptr == end)
     819      return XML_TOK_TRAILING_RSQB;
     820    if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     821      ptr -= MINBPC(enc);
     822      break;
     823    }
     824    *nextTokPtr = ptr;
     825    return XML_TOK_INVALID;
     826  INVALID_CASES(ptr, nextTokPtr)
     827  default:
     828    ptr += MINBPC(enc);
     829    break;
     830  }
     831  while (ptr != end) {
     832    switch (BYTE_TYPE(enc, ptr)) {
    969833#define LEAD_CASE(n) \
    970834    case BT_LEAD ## n: \
    … …  
    975839      ptr += n; \
    976840      break;
    977                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     841    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    978842#undef LEAD_CASE
    979             case BT_RSQB:
    980                 if (ptr + MINBPC(enc) != end)
    981                 {
    982                     if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB))
    983                     {
    984                         ptr += MINBPC(enc);
    985                         break;
    986                     }
    987                     if (ptr + 2 * MINBPC(enc) != end)
    988                     {
    989                         if (!CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT))
    990                         {
    991                             ptr += MINBPC(enc);
    992                             break;
    993                         }
    994                         *nextTokPtr = ptr + 2 * MINBPC(enc);
    995                         return XML_TOK_INVALID;
    996                     }
    997                 }
    998                 /* fall through */
    999             case BT_AMP:
    1000             case BT_LT:
    1001             case BT_NONXML:
    1002             case BT_MALFORM:
    1003             case BT_TRAIL:
    1004             case BT_CR:
    1005             case BT_LF:
    1006                 *nextTokPtr = ptr;
    1007                 return XML_TOK_DATA_CHARS;
    1008             default:
    1009                 ptr += MINBPC(enc);
    1010                 break;
    1011         }
    1012     }
    1013     *nextTokPtr = ptr;
    1014     return XML_TOK_DATA_CHARS;
     843    case BT_RSQB:
     844      if (ptr + MINBPC(enc) != end) {
     845     if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
     846       ptr += MINBPC(enc);
     847       break;
     848     }
     849     if (ptr + 2*MINBPC(enc) != end) {
     850       if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
     851         ptr += MINBPC(enc);
     852         break;
     853       }
     854       *nextTokPtr = ptr + 2*MINBPC(enc);
     855       return XML_TOK_INVALID;
     856     }
     857      }
     858      /* fall through */
     859    case BT_AMP:
     860    case BT_LT:
     861    case BT_NONXML:
     862    case BT_MALFORM:
     863    case BT_TRAIL:
     864    case BT_CR:
     865    case BT_LF:
     866      *nextTokPtr = ptr;
     867      return XML_TOK_DATA_CHARS;
     868    default:
     869      ptr += MINBPC(enc);
     870      break;
     871    }
     872  }
     873  *nextTokPtr = ptr;
     874  return XML_TOK_DATA_CHARS;
    1015875}
    1016876
    … …  
    1018878
    1019879static
    1020 int EXPATENTRY PREFIX(scanPercent) (const ENCODING * enc, const char *ptr, const char *end,
    1021                          const char **nextTokPtr)
    1022 {
     880int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
     881            const char **nextTokPtr)
     882{
     883  if (ptr == end)
     884    return XML_TOK_PARTIAL;
     885  switch (BYTE_TYPE(enc, ptr)) {
     886  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     887  case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
     888    *nextTokPtr = ptr;
     889    return XML_TOK_PERCENT;
     890  default:
     891    *nextTokPtr = ptr;
     892    return XML_TOK_INVALID;
     893  }
     894  while (ptr != end) {
     895    switch (BYTE_TYPE(enc, ptr)) {
     896    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     897    case BT_SEMI:
     898      *nextTokPtr = ptr + MINBPC(enc);
     899      return XML_TOK_PARAM_ENTITY_REF;
     900    default:
     901      *nextTokPtr = ptr;
     902      return XML_TOK_INVALID;
     903    }
     904  }
     905  return XML_TOK_PARTIAL;
     906}
     907
     908static
     909int PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
     910              const char **nextTokPtr)
     911{
     912  if (ptr == end)
     913    return XML_TOK_PARTIAL;
     914  switch (BYTE_TYPE(enc, ptr)) {
     915  CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
     916  default:
     917    *nextTokPtr = ptr;
     918    return XML_TOK_INVALID;
     919  }
     920  while (ptr != end) {
     921    switch (BYTE_TYPE(enc, ptr)) {
     922    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     923    case BT_CR: case BT_LF: case BT_S:
     924    case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
     925      *nextTokPtr = ptr;
     926      return XML_TOK_POUND_NAME;
     927    default:
     928      *nextTokPtr = ptr;
     929      return XML_TOK_INVALID;
     930    }
     931  }
     932  return -XML_TOK_POUND_NAME;
     933}
     934
     935static
     936int PREFIX(scanLit)(int open, const ENCODING *enc,
     937            const char *ptr, const char *end,
     938            const char **nextTokPtr)
     939{
     940  while (ptr != end) {
     941    int t = BYTE_TYPE(enc, ptr);
     942    switch (t) {
     943    INVALID_CASES(ptr, nextTokPtr)
     944    case BT_QUOT:
     945    case BT_APOS:
     946      ptr += MINBPC(enc);
     947      if (t != open)
     948    break;
     949      if (ptr == end)
     950    return -XML_TOK_LITERAL;
     951      *nextTokPtr = ptr;
     952      switch (BYTE_TYPE(enc, ptr)) {
     953      case BT_S: case BT_CR: case BT_LF:
     954      case BT_GT: case BT_PERCNT: case BT_LSQB:
     955    return XML_TOK_LITERAL;
     956      default:
     957    return XML_TOK_INVALID;
     958      }
     959    default:
     960      ptr += MINBPC(enc);
     961      break;
     962    }
     963  }
     964  return XML_TOK_PARTIAL;
     965}
     966
     967static
     968int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     969              const char **nextTokPtr)
     970{
     971  int tok;
     972  if (ptr == end)
     973    return XML_TOK_NONE;
     974  if (MINBPC(enc) > 1) {
     975    size_t n = end - ptr;
     976    if (n & (MINBPC(enc) - 1)) {
     977      n &= ~(MINBPC(enc) - 1);
     978      if (n == 0)
     979    return XML_TOK_PARTIAL;
     980      end = ptr + n;
     981    }
     982  }
     983  switch (BYTE_TYPE(enc, ptr)) {
     984  case BT_QUOT:
     985    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
     986  case BT_APOS:
     987    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
     988  case BT_LT:
     989    {
     990      ptr += MINBPC(enc);
     991      if (ptr == end)
     992    return XML_TOK_PARTIAL;
     993      switch (BYTE_TYPE(enc, ptr)) {
     994      case BT_EXCL:
     995    return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     996      case BT_QUEST:
     997    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     998      case BT_NMSTRT:
     999      case BT_HEX:
     1000      case BT_NONASCII:
     1001      case BT_LEAD2:
     1002      case BT_LEAD3:
     1003      case BT_LEAD4:
     1004    *nextTokPtr = ptr - MINBPC(enc);
     1005    return XML_TOK_INSTANCE_START;
     1006      }
     1007      *nextTokPtr = ptr;
     1008      return XML_TOK_INVALID;
     1009    }
     1010  case BT_CR:
     1011    if (ptr + MINBPC(enc) == end)
     1012      return -XML_TOK_PROLOG_S;
     1013    /* fall through */
     1014  case BT_S: case BT_LF:
     1015    for (;;) {
     1016      ptr += MINBPC(enc);
     1017      if (ptr == end)
     1018    break;
     1019      switch (BYTE_TYPE(enc, ptr)) {
     1020      case BT_S: case BT_LF:
     1021    break;
     1022      case BT_CR:
     1023    /* don't split CR/LF pair */
     1024    if (ptr + MINBPC(enc) != end)
     1025      break;
     1026    /* fall through */
     1027      default:
     1028    *nextTokPtr = ptr;
     1029    return XML_TOK_PROLOG_S;
     1030      }
     1031    }
     1032    *nextTokPtr = ptr;
     1033    return XML_TOK_PROLOG_S;
     1034  case BT_PERCNT:
     1035    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     1036  case BT_COMMA:
     1037    *nextTokPtr = ptr + MINBPC(enc);
     1038    return XML_TOK_COMMA;
     1039  case BT_LSQB:
     1040    *nextTokPtr = ptr + MINBPC(enc);
     1041    return XML_TOK_OPEN_BRACKET;
     1042  case BT_RSQB:
     1043    ptr += MINBPC(enc);
    10231044    if (ptr == end)
    1024         return XML_TOK_PARTIAL;
    1025     switch (BYTE_TYPE(enc, ptr))
    1026     {
    1027             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    1028         case BT_S:
    1029         case BT_LF:
    1030         case BT_CR:
    1031         case BT_PERCNT:
    1032             *nextTokPtr = ptr;
    1033             return XML_TOK_PERCENT;
    1034         default:
    1035             *nextTokPtr = ptr;
    1036             return XML_TOK_INVALID;
    1037     }
    1038     while (ptr != end)
    1039     {
    1040         switch (BYTE_TYPE(enc, ptr))
    1041         {
    1042                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    1043             case BT_SEMI:
    1044                 *nextTokPtr = ptr + MINBPC(enc);
    1045                 return XML_TOK_PARAM_ENTITY_REF;
    1046             default:
    1047                 *nextTokPtr = ptr;
    1048                 return XML_TOK_INVALID;
    1049         }
    1050     }
    1051     return XML_TOK_PARTIAL;
    1052 }
    1053 
    1054 static
    1055 int EXPATENTRY PREFIX(scanPoundName) (const ENCODING * enc, const char *ptr, const char *end,
    1056                            const char **nextTokPtr)
    1057 {
     1045      return -XML_TOK_CLOSE_BRACKET;
     1046    if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
     1047      if (ptr + MINBPC(enc) == end)
     1048    return XML_TOK_PARTIAL;
     1049      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
     1050    *nextTokPtr = ptr + 2*MINBPC(enc);
     1051    return XML_TOK_COND_SECT_CLOSE;
     1052      }
     1053    }
     1054    *nextTokPtr = ptr;
     1055    return XML_TOK_CLOSE_BRACKET;
     1056  case BT_LPAR:
     1057    *nextTokPtr = ptr + MINBPC(enc);
     1058    return XML_TOK_OPEN_PAREN;
     1059  case BT_RPAR:
     1060    ptr += MINBPC(enc);
    10581061    if (ptr == end)
    1059         return XML_TOK_PARTIAL;
    1060     switch (BYTE_TYPE(enc, ptr))
    1061     {
    1062             CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
    1063         default:
    1064             *nextTokPtr = ptr;
    1065             return XML_TOK_INVALID;
    1066     }
    1067     while (ptr != end)
    1068     {
    1069         switch (BYTE_TYPE(enc, ptr))
    1070         {
    1071                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    1072             case BT_CR:
    1073             case BT_LF:
    1074             case BT_S:
    1075             case BT_RPAR:
    1076             case BT_GT:
    1077             case BT_PERCNT:
    1078             case BT_VERBAR:
    1079                 *nextTokPtr = ptr;
    1080                 return XML_TOK_POUND_NAME;
    1081             default:
    1082                 *nextTokPtr = ptr;
    1083                 return XML_TOK_INVALID;
    1084         }
    1085     }
    1086     return -XML_TOK_POUND_NAME;
    1087 }
    1088 
    1089 static
    1090 int EXPATENTRY PREFIX(scanLit) (int open, const ENCODING * enc,
    1091                      const char *ptr, const char *end,
    1092                      const char **nextTokPtr)
    1093 {
    1094     while (ptr != end)
    1095     {
    1096         int t = BYTE_TYPE(enc, ptr);
    1097 
    1098         switch (t)
    1099         {
    1100                 INVALID_CASES(ptr, nextTokPtr)
    1101             case BT_QUOT:
    1102             case BT_APOS:
    1103                 ptr += MINBPC(enc);
    1104                 if (t != open)
    1105                     break;
    1106                 if (ptr == end)
    1107                     return -XML_TOK_LITERAL;
    1108                 *nextTokPtr = ptr;
    1109                 switch (BYTE_TYPE(enc, ptr))
    1110                 {
    1111                     case BT_S:
    1112                     case BT_CR:
    1113                     case BT_LF:
    1114                     case BT_GT:
    1115                     case BT_PERCNT:
    1116                     case BT_LSQB:
    1117                         return XML_TOK_LITERAL;
    1118                     default:
    1119                         return XML_TOK_INVALID;
    1120                 }
    1121             default:
    1122                 ptr += MINBPC(enc);
    1123                 break;
    1124         }
    1125     }
    1126     return XML_TOK_PARTIAL;
    1127 }
    1128 
    1129 static
    1130 int EXPATENTRY PREFIX(prologTok) (const ENCODING * enc, const char *ptr, const char *end,
    1131                        const char **nextTokPtr)
    1132 {
    1133     int tok;
    1134 
    1135     if (ptr == end)
    1136         return XML_TOK_NONE;
    1137     if (MINBPC(enc) > 1)
    1138     {
    1139         size_t n = end - ptr;
    1140 
    1141         if (n & (MINBPC(enc) - 1))
    1142         {
    1143             n &= ~(MINBPC(enc) - 1);
    1144             if (n == 0)
    1145                 return XML_TOK_PARTIAL;
    1146             end = ptr + n;
    1147         }
    1148     }
    1149     switch (BYTE_TYPE(enc, ptr))
    1150     {
    1151         case BT_QUOT:
    1152             return PREFIX(scanLit) (BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
    1153         case BT_APOS:
    1154             return PREFIX(scanLit) (BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
    1155         case BT_LT:
    1156             {
    1157                 ptr += MINBPC(enc);
    1158                 if (ptr == end)
    1159                     return XML_TOK_PARTIAL;
    1160                 switch (BYTE_TYPE(enc, ptr))
    1161                 {
    1162                     case BT_EXCL:
    1163                         return PREFIX(scanDecl) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    1164                     case BT_QUEST:
    1165                         return PREFIX(scanPi) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    1166                     case BT_NMSTRT:
    1167                     case BT_HEX:
    1168                     case BT_NONASCII:
    1169                     case BT_LEAD2:
    1170                     case BT_LEAD3:
    1171                     case BT_LEAD4:
    1172                         *nextTokPtr = ptr - MINBPC(enc);
    1173                         return XML_TOK_INSTANCE_START;
    1174                 }
    1175                 *nextTokPtr = ptr;
    1176                 return XML_TOK_INVALID;
    1177             }
    1178         case BT_CR:
    1179             if (ptr + MINBPC(enc) == end)
    1180                 return -XML_TOK_PROLOG_S;
    1181             /* fall through */
    1182         case BT_S:
    1183         case BT_LF:
    1184             for (;;)
    1185             {
    1186                 ptr += MINBPC(enc);
    1187                 if (ptr == end)
    1188                     break;
    1189                 switch (BYTE_TYPE(enc, ptr))
    1190                 {
    1191                     case BT_S:
    1192                     case BT_LF:
    1193                         break;
    1194                     case BT_CR:
    1195                         /* don't split CR/LF pair */
    1196                         if (ptr + MINBPC(enc) != end)
    1197                             break;
    1198                         /* fall through */
    1199                     default:
    1200                         *nextTokPtr = ptr;
    1201                         return XML_TOK_PROLOG_S;
    1202                 }
    1203             }
    1204             *nextTokPtr = ptr;
    1205             return XML_TOK_PROLOG_S;
    1206         case BT_PERCNT:
    1207             return PREFIX(scanPercent) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    1208         case BT_COMMA:
    1209             *nextTokPtr = ptr + MINBPC(enc);
    1210             return XML_TOK_COMMA;
    1211         case BT_LSQB:
    1212             *nextTokPtr = ptr + MINBPC(enc);
    1213             return XML_TOK_OPEN_BRACKET;
    1214         case BT_RSQB:
    1215             ptr += MINBPC(enc);
    1216             if (ptr == end)
    1217                 return -XML_TOK_CLOSE_BRACKET;
    1218             if (CHAR_MATCHES(enc, ptr, ASCII_RSQB))
    1219             {
    1220                 if (ptr + MINBPC(enc) == end)
    1221                     return XML_TOK_PARTIAL;
    1222                 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT))
    1223                 {
    1224                     *nextTokPtr = ptr + 2 * MINBPC(enc);
    1225                     return XML_TOK_COND_SECT_CLOSE;
    1226                 }
    1227             }
    1228             *nextTokPtr = ptr;
    1229             return XML_TOK_CLOSE_BRACKET;
    1230         case BT_LPAR:
    1231             *nextTokPtr = ptr + MINBPC(enc);
    1232             return XML_TOK_OPEN_PAREN;
    1233         case BT_RPAR:
    1234             ptr += MINBPC(enc);
    1235             if (ptr == end)
    1236                 return -XML_TOK_CLOSE_PAREN;
    1237             switch (BYTE_TYPE(enc, ptr))
    1238             {
    1239                 case BT_AST:
    1240                     *nextTokPtr = ptr + MINBPC(enc);
    1241                     return XML_TOK_CLOSE_PAREN_ASTERISK;
    1242                 case BT_QUEST:
    1243                     *nextTokPtr = ptr + MINBPC(enc);
    1244                     return XML_TOK_CLOSE_PAREN_QUESTION;
    1245                 case BT_PLUS:
    1246                     *nextTokPtr = ptr + MINBPC(enc);
    1247                     return XML_TOK_CLOSE_PAREN_PLUS;
    1248                 case BT_CR:
    1249                 case BT_LF:
    1250                 case BT_S:
    1251                 case BT_GT:
    1252                 case BT_COMMA:
    1253                 case BT_VERBAR:
    1254                 case BT_RPAR:
    1255                     *nextTokPtr = ptr;
    1256                     return XML_TOK_CLOSE_PAREN;
    1257             }
    1258             *nextTokPtr = ptr;
    1259             return XML_TOK_INVALID;
    1260         case BT_VERBAR:
    1261             *nextTokPtr = ptr + MINBPC(enc);
    1262             return XML_TOK_OR;
    1263         case BT_GT:
    1264             *nextTokPtr = ptr + MINBPC(enc);
    1265             return XML_TOK_DECL_CLOSE;
    1266         case BT_NUM:
    1267             return PREFIX(scanPoundName) (enc, ptr + MINBPC(enc), end, nextTokPtr);
     1062      return -XML_TOK_CLOSE_PAREN;
     1063    switch (BYTE_TYPE(enc, ptr)) {
     1064    case BT_AST:
     1065      *nextTokPtr = ptr + MINBPC(enc);
     1066      return XML_TOK_CLOSE_PAREN_ASTERISK;
     1067    case BT_QUEST:
     1068      *nextTokPtr = ptr + MINBPC(enc);
     1069      return XML_TOK_CLOSE_PAREN_QUESTION;
     1070    case BT_PLUS:
     1071      *nextTokPtr = ptr + MINBPC(enc);
     1072      return XML_TOK_CLOSE_PAREN_PLUS;
     1073    case BT_CR: case BT_LF: case BT_S:
     1074    case BT_GT: case BT_COMMA: case BT_VERBAR:
     1075    case BT_RPAR:
     1076      *nextTokPtr = ptr;
     1077      return XML_TOK_CLOSE_PAREN;
     1078    }
     1079    *nextTokPtr = ptr;
     1080    return XML_TOK_INVALID;
     1081  case BT_VERBAR:
     1082    *nextTokPtr = ptr + MINBPC(enc);
     1083    return XML_TOK_OR;
     1084  case BT_GT:
     1085    *nextTokPtr = ptr + MINBPC(enc);
     1086    return XML_TOK_DECL_CLOSE;
     1087  case BT_NUM:
     1088    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
    12681089#define LEAD_CASE(n) \
    12691090  case BT_LEAD ## n: \
    … …  
    12821103    *nextTokPtr = ptr; \
    12831104    return XML_TOK_INVALID;
    1284             LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1105    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    12851106#undef LEAD_CASE
    1286         case BT_NMSTRT:
    1287         case BT_HEX:
    1288             tok = XML_TOK_NAME;
    1289             ptr += MINBPC(enc);
    1290             break;
    1291         case BT_DIGIT:
    1292         case BT_NAME:
    1293         case BT_MINUS:
     1107  case BT_NMSTRT:
     1108  case BT_HEX:
     1109    tok = XML_TOK_NAME;
     1110    ptr += MINBPC(enc);
     1111    break;
     1112  case BT_DIGIT:
     1113  case BT_NAME:
     1114  case BT_MINUS:
    12941115#ifdef XML_NS
    1295         case BT_COLON:
     1116  case BT_COLON:
    12961117#endif
    1297             tok = XML_TOK_NMTOKEN;
    1298             ptr += MINBPC(enc);
    1299             break;
    1300         case BT_NONASCII:
    1301             if (IS_NMSTRT_CHAR_MINBPC(enc, ptr))
    1302             {
    1303                 ptr += MINBPC(enc);
    1304                 tok = XML_TOK_NAME;
    1305                 break;
    1306             }
    1307             if (IS_NAME_CHAR_MINBPC(enc, ptr))
    1308             {
    1309                 ptr += MINBPC(enc);
    1310                 tok = XML_TOK_NMTOKEN;
    1311                 break;
    1312             }
    1313             /* fall through */
    1314         default:
    1315             *nextTokPtr = ptr;
    1316             return XML_TOK_INVALID;
    1317     }
    1318     while (ptr != end)
    1319     {
    1320         switch (BYTE_TYPE(enc, ptr))
    1321         {
    1322                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    1323             case BT_GT:
    1324             case BT_RPAR:
    1325             case BT_COMMA:
    1326             case BT_VERBAR:
    1327             case BT_LSQB:
    1328             case BT_PERCNT:
    1329             case BT_S:
    1330             case BT_CR:
    1331             case BT_LF:
    1332                 *nextTokPtr = ptr;
    1333                 return tok;
     1118    tok = XML_TOK_NMTOKEN;
     1119    ptr += MINBPC(enc);
     1120    break;
     1121  case BT_NONASCII:
     1122    if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
     1123      ptr += MINBPC(enc);
     1124      tok = XML_TOK_NAME;
     1125      break;
     1126    }
     1127    if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
     1128      ptr += MINBPC(enc);
     1129      tok = XML_TOK_NMTOKEN;
     1130      break;
     1131    }
     1132    /* fall through */
     1133  default:
     1134    *nextTokPtr = ptr;
     1135    return XML_TOK_INVALID;
     1136  }
     1137  while (ptr != end) {
     1138    switch (BYTE_TYPE(enc, ptr)) {
     1139    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     1140    case BT_GT: case BT_RPAR: case BT_COMMA:
     1141    case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
     1142    case BT_S: case BT_CR: case BT_LF:
     1143      *nextTokPtr = ptr;
     1144      return tok;
    13341145#ifdef XML_NS
    1335             case BT_COLON:
    1336                 ptr += MINBPC(enc);
    1337                 switch (tok)
    1338                 {
    1339                     case XML_TOK_NAME:
    1340                         if (ptr == end)
    1341                             return XML_TOK_PARTIAL;
    1342                         tok = XML_TOK_PREFIXED_NAME;
    1343                         switch (BYTE_TYPE(enc, ptr))
    1344                         {
    1345                                 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
    1346                             default:
    1347                                 tok = XML_TOK_NMTOKEN;
    1348                                 break;
    1349                         }
    1350                         break;
    1351                     case XML_TOK_PREFIXED_NAME:
    1352                         tok = XML_TOK_NMTOKEN;
    1353                         break;
    1354                 }
    1355                 break;
     1146    case BT_COLON:
     1147      ptr += MINBPC(enc);
     1148      switch (tok) {
     1149      case XML_TOK_NAME:
     1150    if (ptr == end)
     1151      return XML_TOK_PARTIAL;
     1152    tok = XML_TOK_PREFIXED_NAME;
     1153    switch (BYTE_TYPE(enc, ptr)) {
     1154    CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     1155    default:
     1156      tok = XML_TOK_NMTOKEN;
     1157      break;
     1158    }
     1159    break;
     1160      case XML_TOK_PREFIXED_NAME:
     1161    tok = XML_TOK_NMTOKEN;
     1162    break;
     1163      }
     1164      break;
    13561165#endif
    1357             case BT_PLUS:
    1358                 if (tok == XML_TOK_NMTOKEN)
    1359                 {
    1360                     *nextTokPtr = ptr;
    1361                     return XML_TOK_INVALID;
    1362                 }
    1363                 *nextTokPtr = ptr + MINBPC(enc);
    1364                 return XML_TOK_NAME_PLUS;
    1365             case BT_AST:
    1366                 if (tok == XML_TOK_NMTOKEN)
    1367                 {
    1368                     *nextTokPtr = ptr;
    1369                     return XML_TOK_INVALID;
    1370                 }
    1371                 *nextTokPtr = ptr + MINBPC(enc);
    1372                 return XML_TOK_NAME_ASTERISK;
    1373             case BT_QUEST:
    1374                 if (tok == XML_TOK_NMTOKEN)
    1375                 {
    1376                     *nextTokPtr = ptr;
    1377                     return XML_TOK_INVALID;
    1378                 }
    1379                 *nextTokPtr = ptr + MINBPC(enc);
    1380                 return XML_TOK_NAME_QUESTION;
    1381             default:
    1382                 *nextTokPtr = ptr;
    1383                 return XML_TOK_INVALID;
    1384         }
    1385     }
    1386     return -tok;
    1387 }
    1388 
    1389 static
    1390 int EXPATENTRY PREFIX(attributeValueTok) (const ENCODING * enc, const char *ptr, const char *end,
    1391                                const char **nextTokPtr)
    1392 {
    1393     const char *start;
    1394 
    1395     if (ptr == end)
    1396         return XML_TOK_NONE;
    1397     start = ptr;
    1398     while (ptr != end)
    1399     {
    1400         switch (BYTE_TYPE(enc, ptr))
    1401         {
     1166    case BT_PLUS:
     1167      if (tok == XML_TOK_NMTOKEN)  {
     1168    *nextTokPtr = ptr;
     1169    return XML_TOK_INVALID;
     1170      }
     1171      *nextTokPtr = ptr + MINBPC(enc);
     1172      return XML_TOK_NAME_PLUS;
     1173    case BT_AST:
     1174      if (tok == XML_TOK_NMTOKEN)  {
     1175    *nextTokPtr = ptr;
     1176    return XML_TOK_INVALID;
     1177      }
     1178      *nextTokPtr = ptr + MINBPC(enc);
     1179      return XML_TOK_NAME_ASTERISK;
     1180    case BT_QUEST:
     1181      if (tok == XML_TOK_NMTOKEN)  {
     1182    *nextTokPtr = ptr;
     1183    return XML_TOK_INVALID;
     1184      }
     1185      *nextTokPtr = ptr + MINBPC(enc);
     1186      return XML_TOK_NAME_QUESTION;
     1187    default:
     1188      *nextTokPtr = ptr;
     1189      return XML_TOK_INVALID;
     1190    }
     1191  }
     1192  return -tok;
     1193}
     1194
     1195static
     1196int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
     1197                  const char **nextTokPtr)
     1198{
     1199  const char *start;
     1200  if (ptr == end)
     1201    return XML_TOK_NONE;
     1202  start = ptr;
     1203  while (ptr != end) {
     1204    switch (BYTE_TYPE(enc, ptr)) {
    14021205#define LEAD_CASE(n) \
    14031206    case BT_LEAD ## n: ptr += n; break;
    1404                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1207    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    14051208#undef LEAD_CASE
    1406             case BT_AMP:
    1407                 if (ptr == start)
    1408                     return PREFIX(scanRef) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    1409                 *nextTokPtr = ptr;
    1410                 return XML_TOK_DATA_CHARS;
    1411             case BT_LT:
    1412                 /* this is for inside entity references */
    1413                 *nextTokPtr = ptr;
    1414                 return XML_TOK_INVALID;
    1415             case BT_LF:
    1416                 if (ptr == start)
    1417                 {
    1418                     *nextTokPtr = ptr + MINBPC(enc);
    1419                     return XML_TOK_DATA_NEWLINE;
    1420                 }
    1421                 *nextTokPtr = ptr;
    1422                 return XML_TOK_DATA_CHARS;
    1423             case BT_CR:
    1424                 if (ptr == start)
    1425                 {
    1426                     ptr += MINBPC(enc);
    1427                     if (ptr == end)
    1428                         return XML_TOK_TRAILING_CR;
    1429                     if (BYTE_TYPE(enc, ptr) == BT_LF)
    1430                         ptr += MINBPC(enc);
    1431                     *nextTokPtr = ptr;
    1432                     return XML_TOK_DATA_NEWLINE;
    1433                 }
    1434                 *nextTokPtr = ptr;
    1435                 return XML_TOK_DATA_CHARS;
    1436             case BT_S:
    1437                 if (ptr == start)
    1438                 {
    1439                     *nextTokPtr = ptr + MINBPC(enc);
    1440                     return XML_TOK_ATTRIBUTE_VALUE_S;
    1441                 }
    1442                 *nextTokPtr = ptr;
    1443                 return XML_TOK_DATA_CHARS;
    1444             default:
    1445                 ptr += MINBPC(enc);
    1446                 break;
    1447         }
    1448     }
    1449     *nextTokPtr = ptr;
    1450     return XML_TOK_DATA_CHARS;
    1451 }
    1452 
    1453 static
    1454 int EXPATENTRY PREFIX(entityValueTok) (const ENCODING * enc, const char *ptr, const char *end,
    1455                             const char **nextTokPtr)
    1456 {
    1457     const char *start;
    1458 
     1209    case BT_AMP:
     1210      if (ptr == start)
     1211    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     1212      *nextTokPtr = ptr;
     1213      return XML_TOK_DATA_CHARS;
     1214    case BT_LT:
     1215      /* this is for inside entity references */
     1216      *nextTokPtr = ptr;
     1217      return XML_TOK_INVALID;
     1218    case BT_LF:
     1219      if (ptr == start) {
     1220    *nextTokPtr = ptr + MINBPC(enc);
     1221    return XML_TOK_DATA_NEWLINE;
     1222      }
     1223      *nextTokPtr = ptr;
     1224      return XML_TOK_DATA_CHARS;
     1225    case BT_CR:
     1226      if (ptr == start) {
     1227    ptr += MINBPC(enc);
    14591228    if (ptr == end)
    1460         return XML_TOK_NONE;
    1461     start = ptr;
    1462     while (ptr != end)
    1463     {
    1464         switch (BYTE_TYPE(enc, ptr))
    1465         {
     1229      return XML_TOK_TRAILING_CR;
     1230    if (BYTE_TYPE(enc, ptr) == BT_LF)
     1231      ptr += MINBPC(enc);
     1232    *nextTokPtr = ptr;
     1233    return XML_TOK_DATA_NEWLINE;
     1234      }
     1235      *nextTokPtr = ptr;
     1236      return XML_TOK_DATA_CHARS;
     1237    case BT_S:
     1238      if (ptr == start) {
     1239    *nextTokPtr = ptr + MINBPC(enc);
     1240    return XML_TOK_ATTRIBUTE_VALUE_S;
     1241      }
     1242      *nextTokPtr = ptr;
     1243      return XML_TOK_DATA_CHARS;
     1244    default:
     1245      ptr += MINBPC(enc);
     1246      break;
     1247    }
     1248  }
     1249  *nextTokPtr = ptr;
     1250  return XML_TOK_DATA_CHARS;
     1251}
     1252
     1253static
     1254int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
     1255               const char **nextTokPtr)
     1256{
     1257  const char *start;
     1258  if (ptr == end)
     1259    return XML_TOK_NONE;
     1260  start = ptr;
     1261  while (ptr != end) {
     1262    switch (BYTE_TYPE(enc, ptr)) {
    14661263#define LEAD_CASE(n) \
    14671264    case BT_LEAD ## n: ptr += n; break;
    1468                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1265    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    14691266#undef LEAD_CASE
    1470             case BT_AMP:
    1471                 if (ptr == start)
    1472                     return PREFIX(scanRef) (enc, ptr + MINBPC(enc), end, nextTokPtr);
    1473                 *nextTokPtr = ptr;
    1474                 return XML_TOK_DATA_CHARS;
    1475             case BT_PERCNT:
    1476                 if (ptr == start)
    1477                 {
    1478                     int tok = PREFIX(scanPercent) (enc, ptr + MINBPC(enc),
    1479                                                    end, nextTokPtr);
    1480 
    1481                     return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
    1482                 }
    1483                 *nextTokPtr = ptr;
    1484                 return XML_TOK_DATA_CHARS;
    1485             case BT_LF:
    1486                 if (ptr == start)
    1487                 {
    1488                     *nextTokPtr = ptr + MINBPC(enc);
    1489                     return XML_TOK_DATA_NEWLINE;
    1490                 }
    1491                 *nextTokPtr = ptr;
    1492                 return XML_TOK_DATA_CHARS;
    1493             case BT_CR:
    1494                 if (ptr == start)
    1495                 {
    1496                     ptr += MINBPC(enc);
    1497                     if (ptr == end)
    1498                         return XML_TOK_TRAILING_CR;
    1499                     if (BYTE_TYPE(enc, ptr) == BT_LF)
    1500                         ptr += MINBPC(enc);
    1501                     *nextTokPtr = ptr;
    1502                     return XML_TOK_DATA_NEWLINE;
    1503                 }
    1504                 *nextTokPtr = ptr;
    1505                 return XML_TOK_DATA_CHARS;
    1506             default:
    1507                 ptr += MINBPC(enc);
    1508                 break;
    1509         }
    1510     }
    1511     *nextTokPtr = ptr;
    1512     return XML_TOK_DATA_CHARS;
     1267    case BT_AMP:
     1268      if (ptr == start)
     1269    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     1270      *nextTokPtr = ptr;
     1271      return XML_TOK_DATA_CHARS;
     1272    case BT_PERCNT:
     1273      if (ptr == start) {
     1274    int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
     1275                       end, nextTokPtr);
     1276    return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
     1277      }
     1278      *nextTokPtr = ptr;
     1279      return XML_TOK_DATA_CHARS;
     1280    case BT_LF:
     1281      if (ptr == start) {
     1282    *nextTokPtr = ptr + MINBPC(enc);
     1283    return XML_TOK_DATA_NEWLINE;
     1284      }
     1285      *nextTokPtr = ptr;
     1286      return XML_TOK_DATA_CHARS;
     1287    case BT_CR:
     1288      if (ptr == start) {
     1289    ptr += MINBPC(enc);
     1290    if (ptr == end)
     1291      return XML_TOK_TRAILING_CR;
     1292    if (BYTE_TYPE(enc, ptr) == BT_LF)
     1293      ptr += MINBPC(enc);
     1294    *nextTokPtr = ptr;
     1295    return XML_TOK_DATA_NEWLINE;
     1296      }
     1297      *nextTokPtr = ptr;
     1298      return XML_TOK_DATA_CHARS;
     1299    default:
     1300      ptr += MINBPC(enc);
     1301      break;
     1302    }
     1303  }
     1304  *nextTokPtr = ptr;
     1305  return XML_TOK_DATA_CHARS;
    15131306}
    15141307
    … …  
    15161309
    15171310static
    1518 int EXPATENTRY PREFIX(ignoreSectionTok) (const ENCODING * enc, const char *ptr, const char *end,
    1519                               const char **nextTokPtr)
    1520 {
    1521     int level = 0;
    1522 
    1523     if (MINBPC(enc) > 1)
    1524     {
    1525         size_t n = end - ptr;
    1526 
    1527         if (n & (MINBPC(enc) - 1))
    1528         {
    1529             n &= ~(MINBPC(enc) - 1);
    1530             end = ptr + n;
    1531         }
    1532     }
    1533     while (ptr != end)
    1534     {
    1535         switch (BYTE_TYPE(enc, ptr))
    1536         {
    1537                 INVALID_CASES(ptr, nextTokPtr)
    1538             case BT_LT:
    1539                 if ((ptr += MINBPC(enc)) == end)
    1540                     return XML_TOK_PARTIAL;
    1541                 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL))
    1542                 {
    1543                     if ((ptr += MINBPC(enc)) == end)
    1544                         return XML_TOK_PARTIAL;
    1545                     if (CHAR_MATCHES(enc, ptr, ASCII_LSQB))
    1546                     {
    1547                         ++level;
    1548                         ptr += MINBPC(enc);
    1549                     }
    1550                 }
    1551                 break;
    1552             case BT_RSQB:
    1553                 if ((ptr += MINBPC(enc)) == end)
    1554                     return XML_TOK_PARTIAL;
    1555                 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB))
    1556                 {
    1557                     if ((ptr += MINBPC(enc)) == end)
    1558                         return XML_TOK_PARTIAL;
    1559                     if (CHAR_MATCHES(enc, ptr, ASCII_GT))
    1560                     {
    1561                         ptr += MINBPC(enc);
    1562                         if (level == 0)
    1563                         {
    1564                             *nextTokPtr = ptr;
    1565                             return XML_TOK_IGNORE_SECT;
    1566                         }
    1567                         --level;
    1568                     }
    1569                 }
    1570                 break;
    1571             default:
    1572                 ptr += MINBPC(enc);
    1573                 break;
    1574         }
    1575     }
    1576     return XML_TOK_PARTIAL;
     1311int PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
     1312                 const char **nextTokPtr)
     1313{
     1314  int level = 0;
     1315  if (MINBPC(enc) > 1) {
     1316    size_t n = end - ptr;
     1317    if (n & (MINBPC(enc) - 1)) {
     1318      n &= ~(MINBPC(enc) - 1);
     1319      end = ptr + n;
     1320    }
     1321  }
     1322  while (ptr != end) {
     1323    switch (BYTE_TYPE(enc, ptr)) {
     1324    INVALID_CASES(ptr, nextTokPtr)
     1325    case BT_LT:
     1326      if ((ptr += MINBPC(enc)) == end)
     1327    return XML_TOK_PARTIAL;
     1328      if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
     1329    if ((ptr += MINBPC(enc)) == end)
     1330      return XML_TOK_PARTIAL;
     1331    if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
     1332      ++level;
     1333      ptr += MINBPC(enc);
     1334    }
     1335      }
     1336      break;
     1337    case BT_RSQB:
     1338      if ((ptr += MINBPC(enc)) == end)
     1339    return XML_TOK_PARTIAL;
     1340      if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
     1341    if ((ptr += MINBPC(enc)) == end)
     1342      return XML_TOK_PARTIAL;
     1343    if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
     1344      ptr += MINBPC(enc);
     1345      if (level == 0) {
     1346        *nextTokPtr = ptr;
     1347        return XML_TOK_IGNORE_SECT;
     1348      }
     1349      --level;
     1350    }
     1351      }
     1352      break;
     1353    default:
     1354      ptr += MINBPC(enc);
     1355      break;
     1356    }
     1357  }
     1358  return XML_TOK_PARTIAL;
    15771359}
    15781360
    … …  
    15801362
    15811363static
    1582 int EXPATENTRY PREFIX(isPublicId) (const ENCODING * enc, const char *ptr, const char *end,
    1583                         const char **badPtr)
    1584 {
    1585     ptr += MINBPC(enc);
    1586     end -= MINBPC(enc);
    1587     for (; ptr != end; ptr += MINBPC(enc))
    1588     {
    1589         switch (BYTE_TYPE(enc, ptr))
    1590         {
    1591             case BT_DIGIT:
    1592             case BT_HEX:
    1593             case BT_MINUS:
    1594             case BT_APOS:
    1595             case BT_LPAR:
    1596             case BT_RPAR:
    1597             case BT_PLUS:
    1598             case BT_COMMA:
    1599             case BT_SOL:
    1600             case BT_EQUALS:
    1601             case BT_QUEST:
    1602             case BT_CR:
    1603             case BT_LF:
    1604             case BT_SEMI:
    1605             case BT_EXCL:
    1606             case BT_AST:
    1607             case BT_PERCNT:
    1608             case BT_NUM:
     1364int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
     1365               const char **badPtr)
     1366{
     1367  ptr += MINBPC(enc);
     1368  end -= MINBPC(enc);
     1369  for (; ptr != end; ptr += MINBPC(enc)) {
     1370    switch (BYTE_TYPE(enc, ptr)) {
     1371    case BT_DIGIT:
     1372    case BT_HEX:
     1373    case BT_MINUS:
     1374    case BT_APOS:
     1375    case BT_LPAR:
     1376    case BT_RPAR:
     1377    case BT_PLUS:
     1378    case BT_COMMA:
     1379    case BT_SOL:
     1380    case BT_EQUALS:
     1381    case BT_QUEST:
     1382    case BT_CR:
     1383    case BT_LF:
     1384    case BT_SEMI:
     1385    case BT_EXCL:
     1386    case BT_AST:
     1387    case BT_PERCNT:
     1388    case BT_NUM:
    16091389#ifdef XML_NS
    1610             case BT_COLON:
     1390    case BT_COLON:
    16111391#endif
    1612                 break;
    1613             case BT_S:
    1614                 if (CHAR_MATCHES(enc, ptr, ASCII_TAB))
    1615                 {
    1616                     *badPtr = ptr;
    1617                     return 0;
    1618                 }
    1619                 break;
    1620             case BT_NAME:
    1621             case BT_NMSTRT:
    1622                 if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
    1623                     break;
    1624             default:
    1625                 switch (BYTE_TO_ASCII(enc, ptr))
    1626                 {
    1627                     case 0x24:  /* $ */
    1628                     case 0x40:  /* @ */
    1629                         break;
    1630                     default:
    1631                         *badPtr = ptr;
    1632                         return 0;
    1633                 }
    1634                 break;
    1635         }
    1636     }
    1637     return 1;
     1392      break;
     1393    case BT_S:
     1394      if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
     1395    *badPtr = ptr;
     1396    return 0;
     1397      }
     1398      break;
     1399    case BT_NAME:
     1400    case BT_NMSTRT:
     1401      if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
     1402    break;
     1403    default:
     1404      switch (BYTE_TO_ASCII(enc, ptr)) {
     1405      case 0x24: /* $ */
     1406      case 0x40: /* @ */
     1407    break;
     1408      default:
     1409    *badPtr = ptr;
     1410    return 0;
     1411      }
     1412      break;
     1413    }
     1414  }
     1415  return 1;
    16381416}
    16391417
    16401418/* This must only be called for a well-formed start-tag or empty element tag.
    1641  * Returns the number of attributes.  Pointers to the first attsMax attributes
    1642  * are stored in atts. */
    1643 
    1644 static
    1645 int EXPATENTRY PREFIX(getAtts) (const ENCODING * enc, const char *ptr,
    1646                      int attsMax, ATTRIBUTE * atts)
    1647 {
    1648     enum
    1649     {
    1650         other, inName, inValue
    1651     }
    1652     state = inName;
    1653     int nAtts = 0;
    1654     int open = 0;               /* defined when state == inValue;
    1655 
    1656                                  * initialization just to shut up compilers */
    1657 
    1658     for (ptr += MINBPC(enc);; ptr += MINBPC(enc))
    1659     {
    1660         switch (BYTE_TYPE(enc, ptr))
    1661         {
     1419Returns the number of attributes.  Pointers to the first attsMax attributes
     1420are stored in atts. */
     1421
     1422static
     1423int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
     1424            int attsMax, ATTRIBUTE *atts)
     1425{
     1426  enum { other, inName, inValue } state = inName;
     1427  int nAtts = 0;
     1428  int open = 0; /* defined when state == inValue;
     1429           initialization just to shut up compilers */
     1430
     1431  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
     1432    switch (BYTE_TYPE(enc, ptr)) {
    16621433#define START_NAME \
    16631434      if (state == other) { \
    … …  
    16701441#define LEAD_CASE(n) \
    16711442    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
    1672                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1443    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    16731444#undef LEAD_CASE
    1674             case BT_NONASCII:
    1675             case BT_NMSTRT:
    1676             case BT_HEX:
    1677                 START_NAME
    1678                     break;
     1445    case BT_NONASCII:
     1446    case BT_NMSTRT:
     1447    case BT_HEX:
     1448      START_NAME
     1449      break;
    16791450#undef START_NAME
    1680             case BT_QUOT:
    1681                 if (state != inValue)
    1682                 {
    1683                     if (nAtts < attsMax)
    1684                         atts[nAtts].valuePtr = ptr + MINBPC(enc);
    1685                     state = inValue;
    1686                     open = BT_QUOT;
    1687                 }
    1688                 else if (open == BT_QUOT)
    1689                 {
    1690                     state = other;
    1691                     if (nAtts < attsMax)
    1692                         atts[nAtts].valueEnd = ptr;
    1693                     nAtts++;
    1694                 }
    1695                 break;
    1696             case BT_APOS:
    1697                 if (state != inValue)
    1698                 {
    1699                     if (nAtts < attsMax)
    1700                         atts[nAtts].valuePtr = ptr + MINBPC(enc);
    1701                     state = inValue;
    1702                     open = BT_APOS;
    1703                 }
    1704                 else if (open == BT_APOS)
    1705                 {
    1706                     state = other;
    1707                     if (nAtts < attsMax)
    1708                         atts[nAtts].valueEnd = ptr;
    1709                     nAtts++;
    1710                 }
    1711                 break;
    1712             case BT_AMP:
    1713                 if (nAtts < attsMax)
    1714                     atts[nAtts].normalized = 0;
    1715                 break;
    1716             case BT_S:
    1717                 if (state == inName)
    1718                     state = other;
    1719                 else if (state == inValue
    1720                          && nAtts < attsMax
    1721                          && atts[nAtts].normalized
    1722                          && (ptr == atts[nAtts].valuePtr
    1723                              || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
    1724                        || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
    1725                              || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
    1726                     atts[nAtts].normalized = 0;
    1727                 break;
    1728             case BT_CR:
    1729             case BT_LF:
    1730                 /* This case ensures that the first attribute name is counted
    1731                  * Apart from that we could just change state on the quote. */
    1732                 if (state == inName)
    1733                     state = other;
    1734                 else if (state == inValue && nAtts < attsMax)
    1735                     atts[nAtts].normalized = 0;
    1736                 break;
    1737             case BT_GT:
    1738             case BT_SOL:
    1739                 if (state != inValue)
    1740                     return nAtts;
    1741                 break;
    1742             default:
    1743                 break;
    1744         }
    1745     }
    1746     /* not reached */
    1747 }
    1748 
    1749 static
    1750 int EXPATENTRY PREFIX(charRefNumber) (const ENCODING * enc, const char *ptr)
    1751 {
    1752     int result = 0;
    1753 
    1754     /* skip &# */
    1755     ptr += 2 * MINBPC(enc);
    1756     if (CHAR_MATCHES(enc, ptr, ASCII_x))
    1757     {
    1758         for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc))
    1759         {
    1760             int c = BYTE_TO_ASCII(enc, ptr);
    1761 
    1762             switch (c)
    1763             {
    1764                 case ASCII_0:
    1765                 case ASCII_1:
    1766                 case ASCII_2:
    1767                 case ASCII_3:
    1768                 case ASCII_4:
    1769                 case ASCII_5:
    1770                 case ASCII_6:
    1771                 case ASCII_7:
    1772                 case ASCII_8:
    1773                 case ASCII_9:
    1774                     result <<= 4;
    1775                     result |= (c - ASCII_0);
    1776                     break;
    1777                 case ASCII_A:
    1778                 case ASCII_B:
    1779                 case ASCII_C:
    1780                 case ASCII_D:
    1781                 case ASCII_E:
    1782                 case ASCII_F:
    1783                     result <<= 4;
    1784                     result += 10 + (c - ASCII_A);
    1785                     break;
    1786                 case ASCII_a:
    1787                 case ASCII_b:
    1788                 case ASCII_c:
    1789                 case ASCII_d:
    1790                 case ASCII_e:
    1791                 case ASCII_f:
    1792                     result <<= 4;
    1793                     result += 10 + (c - ASCII_a);
    1794                     break;
    1795             }
    1796             if (result >= 0x110000)
    1797                 return -1;
    1798         }
    1799     }
    1800     else
    1801     {
    1802         for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc))
    1803         {
    1804             int c = BYTE_TO_ASCII(enc, ptr);
    1805 
    1806             result *= 10;
    1807             result += (c - ASCII_0);
    1808             if (result >= 0x110000)
    1809                 return -1;
    1810         }
    1811     }
    1812     return checkCharRefNumber(result);
    1813 }
    1814 
    1815 static
    1816 int EXPATENTRY PREFIX(predefinedEntityName) (const ENCODING * enc, const char *ptr, const char *end)
    1817 {
    1818     switch ((end - ptr) / MINBPC(enc))
    1819     {
    1820         case 2:
    1821             if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t))
    1822             {
    1823                 switch (BYTE_TO_ASCII(enc, ptr))
    1824                 {
    1825                     case ASCII_l:
    1826                         return ASCII_LT;
    1827                     case ASCII_g:
    1828                         return ASCII_GT;
    1829                 }
    1830             }
    1831             break;
    1832         case 3:
    1833             if (CHAR_MATCHES(enc, ptr, ASCII_a))
    1834             {
    1835                 ptr += MINBPC(enc);
    1836                 if (CHAR_MATCHES(enc, ptr, ASCII_m))
    1837                 {
    1838                     ptr += MINBPC(enc);
    1839                     if (CHAR_MATCHES(enc, ptr, ASCII_p))
    1840                         return ASCII_AMP;
    1841                 }
    1842             }
    1843             break;
    1844         case 4:
    1845             switch (BYTE_TO_ASCII(enc, ptr))
    1846             {
    1847                 case ASCII_q:
    1848                     ptr += MINBPC(enc);
    1849                     if (CHAR_MATCHES(enc, ptr, ASCII_u))
    1850                     {
    1851                         ptr += MINBPC(enc);
    1852                         if (CHAR_MATCHES(enc, ptr, ASCII_o))
    1853                         {
    1854                             ptr += MINBPC(enc);
    1855                             if (CHAR_MATCHES(enc, ptr, ASCII_t))
    1856                                 return ASCII_QUOT;
    1857                         }
    1858                     }
    1859                     break;
    1860                 case ASCII_a:
    1861                     ptr += MINBPC(enc);
    1862                     if (CHAR_MATCHES(enc, ptr, ASCII_p))
    1863                     {
    1864                         ptr += MINBPC(enc);
    1865                         if (CHAR_MATCHES(enc, ptr, ASCII_o))
    1866                         {
    1867                             ptr += MINBPC(enc);
    1868                             if (CHAR_MATCHES(enc, ptr, ASCII_s))
    1869                                 return ASCII_APOS;
    1870                         }
    1871                     }
    1872                     break;
    1873             }
    1874     }
    1875     return 0;
    1876 }
    1877 
    1878 static
    1879 int EXPATENTRY PREFIX(sameName) (const ENCODING * enc, const char *ptr1, const char *ptr2)
    1880 {
    1881     for (;;)
    1882     {
    1883         switch (BYTE_TYPE(enc, ptr1))
    1884         {
     1451    case BT_QUOT:
     1452      if (state != inValue) {
     1453    if (nAtts < attsMax)
     1454      atts[nAtts].valuePtr = ptr + MINBPC(enc);
     1455        state = inValue;
     1456        open = BT_QUOT;
     1457      }
     1458      else if (open == BT_QUOT) {
     1459        state = other;
     1460    if (nAtts < attsMax)
     1461      atts[nAtts].valueEnd = ptr;
     1462    nAtts++;
     1463      }
     1464      break;
     1465    case BT_APOS:
     1466      if (state != inValue) {
     1467    if (nAtts < attsMax)
     1468      atts[nAtts].valuePtr = ptr + MINBPC(enc);
     1469        state = inValue;
     1470        open = BT_APOS;
     1471      }
     1472      else if (open == BT_APOS) {
     1473        state = other;
     1474    if (nAtts < attsMax)
     1475      atts[nAtts].valueEnd = ptr;
     1476    nAtts++;
     1477      }
     1478      break;
     1479    case BT_AMP:
     1480      if (nAtts < attsMax)
     1481    atts[nAtts].normalized = 0;
     1482      break;
     1483    case BT_S:
     1484      if (state == inName)
     1485        state = other;
     1486      else if (state == inValue
     1487           && nAtts < attsMax
     1488           && atts[nAtts].normalized
     1489           && (ptr == atts[nAtts].valuePtr
     1490           || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
     1491           || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
     1492               || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
     1493    atts[nAtts].normalized = 0;
     1494      break;
     1495    case BT_CR: case BT_LF:
     1496      /* This case ensures that the first attribute name is counted
     1497         Apart from that we could just change state on the quote. */
     1498      if (state == inName)
     1499        state = other;
     1500      else if (state == inValue && nAtts < attsMax)
     1501    atts[nAtts].normalized = 0;
     1502      break;
     1503    case BT_GT:
     1504    case BT_SOL:
     1505      if (state != inValue)
     1506    return nAtts;
     1507      break;
     1508    default:
     1509      break;
     1510    }
     1511  }
     1512  /* not reached */
     1513}
     1514
     1515static
     1516int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
     1517{
     1518  int result = 0;
     1519  /* skip &# */
     1520  ptr += 2*MINBPC(enc);
     1521  if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
     1522    for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
     1523      int c = BYTE_TO_ASCII(enc, ptr);
     1524      switch (c) {
     1525      case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
     1526      case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
     1527    result <<= 4;
     1528    result |= (c - ASCII_0);
     1529    break;
     1530      case ASCII_A: case ASCII_B: case ASCII_C: case ASCII_D: case ASCII_E: case ASCII_F:
     1531    result <<= 4;
     1532    result += 10 + (c - ASCII_A);
     1533    break;
     1534      case ASCII_a: case ASCII_b: case ASCII_c: case ASCII_d: case ASCII_e: case ASCII_f:
     1535    result <<= 4;
     1536    result += 10 + (c - ASCII_a);
     1537    break;
     1538      }
     1539      if (result >= 0x110000)
     1540    return -1;
     1541    }
     1542  }
     1543  else {
     1544    for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
     1545      int c = BYTE_TO_ASCII(enc, ptr);
     1546      result *= 10;
     1547      result += (c - ASCII_0);
     1548      if (result >= 0x110000)
     1549    return -1;
     1550    }
     1551  }
     1552  return checkCharRefNumber(result);
     1553}
     1554
     1555static
     1556int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end)
     1557{
     1558  switch ((end - ptr)/MINBPC(enc)) {
     1559  case 2:
     1560    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
     1561      switch (BYTE_TO_ASCII(enc, ptr)) {
     1562      case ASCII_l:
     1563    return ASCII_LT;
     1564      case ASCII_g:
     1565    return ASCII_GT;
     1566      }
     1567    }
     1568    break;
     1569  case 3:
     1570    if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
     1571      ptr += MINBPC(enc);
     1572      if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
     1573    ptr += MINBPC(enc);
     1574    if (CHAR_MATCHES(enc, ptr, ASCII_p))
     1575      return ASCII_AMP;
     1576      }
     1577    }
     1578    break;
     1579  case 4:
     1580    switch (BYTE_TO_ASCII(enc, ptr)) {
     1581    case ASCII_q:
     1582      ptr += MINBPC(enc);
     1583      if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
     1584    ptr += MINBPC(enc);
     1585    if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
     1586      ptr += MINBPC(enc);
     1587      if (CHAR_MATCHES(enc, ptr, ASCII_t))
     1588        return ASCII_QUOT;
     1589    }
     1590      }
     1591      break;
     1592    case ASCII_a:
     1593      ptr += MINBPC(enc);
     1594      if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
     1595    ptr += MINBPC(enc);
     1596    if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
     1597      ptr += MINBPC(enc);
     1598      if (CHAR_MATCHES(enc, ptr, ASCII_s))
     1599        return ASCII_APOS;
     1600    }
     1601      }
     1602      break;
     1603    }
     1604  }
     1605  return 0;
     1606}
     1607
     1608static
     1609int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
     1610{
     1611  for (;;) {
     1612    switch (BYTE_TYPE(enc, ptr1)) {
    18851613#define LEAD_CASE(n) \
    18861614    case BT_LEAD ## n: \
    18871615      if (*ptr1++ != *ptr2++) \
    18881616    return 0;
    1889                 LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
     1617    LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
    18901618#undef LEAD_CASE
    1891                 /* fall through */
    1892                     if (*ptr1++ != *ptr2++)
    1893                     return 0;
    1894                 break;
    1895             case BT_NONASCII:
    1896             case BT_NMSTRT:
     1619      /* fall through */
     1620      if (*ptr1++ != *ptr2++)
     1621    return 0;
     1622      break;
     1623    case BT_NONASCII:
     1624    case BT_NMSTRT:
    18971625#ifdef XML_NS
    1898             case BT_COLON:
     1626    case BT_COLON:
    18991627#endif
    1900             case BT_HEX:
    1901             case BT_DIGIT:
    1902             case BT_NAME:
    1903             case BT_MINUS:
    1904                 if (*ptr2++ != *ptr1++)
    1905                     return 0;
    1906                 if (MINBPC(enc) > 1)
    1907                 {
    1908                     if (*ptr2++ != *ptr1++)
    1909                         return 0;
    1910                     if (MINBPC(enc) > 2)
    1911                     {
    1912                         if (*ptr2++ != *ptr1++)
    1913                             return 0;
    1914                         if (MINBPC(enc) > 3)
    1915                         {
    1916                             if (*ptr2++ != *ptr1++)
    1917                                 return 0;
    1918                         }
    1919                     }
    1920                 }
    1921                 break;
    1922             default:
    1923                 if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
    1924                     return 1;
    1925                 switch (BYTE_TYPE(enc, ptr2))
    1926                 {
    1927                     case BT_LEAD2:
    1928                     case BT_LEAD3:
    1929                     case BT_LEAD4:
    1930                     case BT_NONASCII:
    1931                     case BT_NMSTRT:
     1628    case BT_HEX:
     1629    case BT_DIGIT:
     1630    case BT_NAME:
     1631    case BT_MINUS:
     1632      if (*ptr2++ != *ptr1++)
     1633    return 0;
     1634      if (MINBPC(enc) > 1) {
     1635    if (*ptr2++ != *ptr1++)
     1636      return 0;
     1637    if (MINBPC(enc) > 2) {
     1638      if (*ptr2++ != *ptr1++)
     1639        return 0;
     1640          if (MINBPC(enc) > 3) {
     1641        if (*ptr2++ != *ptr1++)
     1642              return 0;
     1643      }
     1644    }
     1645      }
     1646      break;
     1647    default:
     1648      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
     1649    return 1;
     1650      switch (BYTE_TYPE(enc, ptr2)) {
     1651      case BT_LEAD2:
     1652      case BT_LEAD3:
     1653      case BT_LEAD4:
     1654      case BT_NONASCII:
     1655      case BT_NMSTRT:
    19321656#ifdef XML_NS
    1933                     case BT_COLON:
     1657      case BT_COLON:
    19341658#endif
    1935                     case BT_HEX:
    1936                     case BT_DIGIT:
    1937                     case BT_NAME:
    1938                     case BT_MINUS:
    1939                         return 0;
    1940                     default:
    1941                         return 1;
    1942                 }
    1943         }
    1944     }
    1945     /* not reached */
    1946 }
    1947 
    1948 static
    1949 int EXPATENTRY PREFIX(nameMatchesAscii) (const ENCODING * enc, const char *ptr1,
    1950                               const char *end1, const char *ptr2)
    1951 {
    1952     for (; *ptr2; ptr1 += MINBPC(enc), ptr2++)
    1953     {
    1954         if (ptr1 == end1)
    1955             return 0;
    1956         if (!CHAR_MATCHES(enc, ptr1, *ptr2))
    1957             return 0;
    1958     }
    1959     return ptr1 == end1;
    1960 }
    1961 
    1962 static
    1963 int EXPATENTRY PREFIX(nameLength) (const ENCODING * enc, const char *ptr)
    1964 {
    1965     const char *start = ptr;
    1966 
    1967     for (;;)
    1968     {
    1969         switch (BYTE_TYPE(enc, ptr))
    1970         {
     1659      case BT_HEX:
     1660      case BT_DIGIT:
     1661      case BT_NAME:
     1662      case BT_MINUS:
     1663    return 0;
     1664      default:
     1665    return 1;
     1666      }
     1667    }
     1668  }
     1669  /* not reached */
     1670}
     1671
     1672static
     1673int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
     1674                 const char *end1, const char *ptr2)
     1675{
     1676  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
     1677    if (ptr1 == end1)
     1678      return 0;
     1679    if (!CHAR_MATCHES(enc, ptr1, *ptr2))
     1680      return 0;
     1681  }
     1682  return ptr1 == end1;
     1683}
     1684
     1685static
     1686int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
     1687{
     1688  const char *start = ptr;
     1689  for (;;) {
     1690    switch (BYTE_TYPE(enc, ptr)) {
    19711691#define LEAD_CASE(n) \
    19721692    case BT_LEAD ## n: ptr += n; break;
    1973                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1693    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    19741694#undef LEAD_CASE
    1975             case BT_NONASCII:
    1976             case BT_NMSTRT:
     1695    case BT_NONASCII:
     1696    case BT_NMSTRT:
    19771697#ifdef XML_NS
    1978             case BT_COLON:
     1698    case BT_COLON:
    19791699#endif
    1980             case BT_HEX:
    1981             case BT_DIGIT:
    1982             case BT_NAME:
    1983             case BT_MINUS:
    1984                 ptr += MINBPC(enc);
    1985                 break;
    1986             default:
    1987                 return ptr - start;
    1988         }
    1989     }
    1990 }
    1991 
    1992 static
    1993 const char *EXPATENTRY PREFIX(skipS) (const ENCODING * enc, const char *ptr)
    1994 {
    1995     for (;;)
    1996     {
    1997         switch (BYTE_TYPE(enc, ptr))
    1998         {
    1999             case BT_LF:
    2000             case BT_CR:
    2001             case BT_S:
    2002                 ptr += MINBPC(enc);
    2003                 break;
    2004             default:
    2005                 return ptr;
    2006         }
    2007     }
    2008 }
    2009 
    2010 static
    2011 void EXPATENTRY PREFIX(updatePosition) (const ENCODING * enc,
    2012                              const char *ptr,
    2013                              const char *end,
    2014                              POSITION * pos)
    2015 {
    2016     while (ptr != end)
    2017     {
    2018         switch (BYTE_TYPE(enc, ptr))
    2019         {
     1700    case BT_HEX:
     1701    case BT_DIGIT:
     1702    case BT_NAME:
     1703    case BT_MINUS:
     1704      ptr += MINBPC(enc);
     1705      break;
     1706    default:
     1707      return ptr - start;
     1708    }
     1709  }
     1710}
     1711
     1712static
     1713const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
     1714{
     1715  for (;;) {
     1716    switch (BYTE_TYPE(enc, ptr)) {
     1717    case BT_LF:
     1718    case BT_CR:
     1719    case BT_S:
     1720      ptr += MINBPC(enc);
     1721      break;
     1722    default:
     1723      return ptr;
     1724    }
     1725  }
     1726}
     1727
     1728static
     1729void PREFIX(updatePosition)(const ENCODING *enc,
     1730                const char *ptr,
     1731                const char *end,
     1732                POSITION *pos)
     1733{
     1734  while (ptr != end) {
     1735    switch (BYTE_TYPE(enc, ptr)) {
    20201736#define LEAD_CASE(n) \
    20211737    case BT_LEAD ## n: \
    20221738      ptr += n; \
    20231739      break;
    2024                 LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
     1740    LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
    20251741#undef LEAD_CASE
    2026             case BT_LF:
    2027                 pos->columnNumber = (unsigned)-1;
    2028                 pos->lineNumber++;
    2029                 ptr += MINBPC(enc);
    2030                 break;
    2031             case BT_CR:
    2032                 pos->lineNumber++;
    2033                 ptr += MINBPC(enc);
    2034                 if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
    2035                     ptr += MINBPC(enc);
    2036                 pos->columnNumber = (unsigned)-1;
    2037                 break;
    2038             default:
    2039                 ptr += MINBPC(enc);
    2040                 break;
    2041         }
    2042         pos->columnNumber++;
    2043     }
     1742    case BT_LF:
     1743      pos->columnNumber = (unsigned)-1;
     1744      pos->lineNumber++;
     1745      ptr += MINBPC(enc);
     1746      break;
     1747    case BT_CR:
     1748      pos->lineNumber++;
     1749      ptr += MINBPC(enc);
     1750      if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
     1751    ptr += MINBPC(enc);
     1752      pos->columnNumber = (unsigned)-1;
     1753      break;
     1754    default:
     1755      ptr += MINBPC(enc);
     1756      break;
     1757    }
     1758    pos->columnNumber++;
     1759  }
    20441760}
    20451761

  • trunk/src/helpers/xmltok_ns.c

    r38 r97  
    1 
    2 /*
    3  *sourcefile xmltok_ns.c
    4  *      part of the expat implementation. See xmlparse.c.
    5  *
    6  *      NOTE: This file must not be compiled directly. It is
    7  *      #include'd from xmltok.c several times.
    8  */
    9 
    10 /*
    11  *      Copyright (C) 2001 Ulrich M”ller.
    12  *      Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd.
    13  *                                     and Clark Cooper.
    14  *
    15  *      Permission is hereby granted, free of charge, to any person obtaining
    16  *      a copy of this software and associated documentation files (the
    17  *      "Software"), to deal in the Software without restriction, including
    18  *      without limitation the rights to use, copy, modify, merge, publish,
    19  *      distribute, sublicense, and/or sell copies of the Software, and to
    20  *      permit persons to whom the Software is furnished to do so, subject to
    21  *      the following conditions:
    22  *
    23  *      The above copyright notice and this permission notice shall be included
    24  *      in all copies or substantial portions of the Software.
    25  *
    26  *      THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
    27  *      EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
    28  *      MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
    29  *      IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
    30  *      CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
    31  *      TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
    32  *      SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    33  */
    34 
    35 const ENCODING* EXPATENTRY NS(XmlGetUtf8InternalEncoding) (void)
     1const ENCODING *NS(XmlGetUtf8InternalEncoding)(void)
    362{
    37     return &ns(internal_utf8_encoding).enc;
     3  return &ns(internal_utf8_encoding).enc;
    384}
    395
    40 const ENCODING* EXPATENTRY NS(XmlGetUtf16InternalEncoding) (void)
     6const ENCODING *NS(XmlGetUtf16InternalEncoding)(void)
    417{
    428#if XML_BYTE_ORDER == 12
    43     return &ns(internal_little2_encoding).enc;
     9  return &ns(internal_little2_encoding).enc;
    4410#elif XML_BYTE_ORDER == 21
    45     return &ns(internal_big2_encoding).enc;
     11  return &ns(internal_big2_encoding).enc;
    4612#else
    47     const short n = 1;
    48 
    49     return *(const char *)&n ? &ns(internal_little2_encoding).enc : &ns(internal_big2_encoding).enc;
     13  const short n = 1;
     14  return *(const char *)&n ? &ns(internal_little2_encoding).enc : &ns(internal_big2_encoding).enc;
    5015#endif
    5116}
    5217
    5318static
    54 const ENCODING *NS(encodings)[] =
    55 {
    56     &ns(latin1_encoding).enc,
    57         &ns(ascii_encoding).enc,
    58         &ns(utf8_encoding).enc,
    59         &ns(big2_encoding).enc,
    60         &ns(big2_encoding).enc,
    61         &ns(little2_encoding).enc,
    62         &ns(utf8_encoding).enc  /* NO_ENC */
     19const ENCODING *NS(encodings)[] = {
     20  &ns(latin1_encoding).enc,
     21  &ns(ascii_encoding).enc,
     22  &ns(utf8_encoding).enc,
     23  &ns(big2_encoding).enc,
     24  &ns(big2_encoding).enc,
     25  &ns(little2_encoding).enc,
     26  &ns(utf8_encoding).enc /* NO_ENC */
    6327};
    6428
    65 static int EXPATENTRY NS(initScanProlog)(const ENCODING * enc,
    66                                           const char *ptr,
    67                                           const char *end,
    68                                           const char **nextTokPtr)
     29static
     30int NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
     31               const char **nextTokPtr)
    6932{
    70     return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ptr, end, nextTokPtr);
     33  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE, ptr, end, nextTokPtr);
    7134}
    7235
    73 static int EXPATENTRY NS(initScanContent)(const ENCODING * enc,
    74                                            const char *ptr,
    75                                            const char *end,
    76                                            const char **nextTokPtr)
     36static
     37int NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
     38               const char **nextTokPtr)
    7739{
    78     return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE, ptr, end, nextTokPtr);
     40  return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE, ptr, end, nextTokPtr);
    7941}
    8042
    81 int EXPATENTRY NS(XmlInitEncoding)(INIT_ENCODING * p, const ENCODING ** encPtr, const char *name)
     43int NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr, const char *name)
    8244{
    83     int i = getEncodingIndex(name);
    84 
    85     if (i == UNKNOWN_ENC)
    86         return 0;
    87     SET_INIT_ENC_INDEX(p, i);
    88     p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
    89     p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
    90     p->initEnc.updatePosition = initUpdatePosition;
    91     p->encPtr = encPtr;
    92     *encPtr = &(p->initEnc);
    93     return 1;
     45  int i = getEncodingIndex(name);
     46  if (i == UNKNOWN_ENC)
     47    return 0;
     48  SET_INIT_ENC_INDEX(p, i);
     49  p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
     50  p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
     51  p->initEnc.updatePosition = initUpdatePosition;
     52  p->encPtr = encPtr;
     53  *encPtr = &(p->initEnc);
     54  return 1;
    9455}
    9556
    96 static const ENCODING* EXPATENTRY NS(findEncoding)(const ENCODING * enc,
    97                                                    const char *ptr,
    98                                                    const char *end)
     57static
     58const ENCODING *NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
    9959{
    10060#define ENCODING_MAX 128
    101     char buf[ENCODING_MAX];
    102     char *p = buf;
    103     int i;
    104 
    105     XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
    106     if (ptr != end)
    107         return 0;
    108     *p = 0;
    109     if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
    110         return enc;
    111     i = getEncodingIndex(buf);
    112     if (i == UNKNOWN_ENC)
    113         return 0;
    114     return NS(encodings)[i];
     61  char buf[ENCODING_MAX];
     62  char *p = buf;
     63  int i;
     64  XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
     65  if (ptr != end)
     66    return 0;
     67  *p = 0;
     68  if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
     69    return enc;
     70  i = getEncodingIndex(buf);
     71  if (i == UNKNOWN_ENC)
     72    return 0;
     73  return NS(encodings)[i];
    11574}
    11675
    117 int NS(XmlParseXmlDecl) (int isGeneralTextEntity,
    118                          const ENCODING * enc,
    119                          const char *ptr,
    120                          const char *end,
    121                          const char **badPtr,
    122                          const char **versionPtr,
    123                          const char **versionEndPtr,
    124                          const char **encodingName,
    125                          const ENCODING ** encoding,
    126                          int *standalone)
     76int NS(XmlParseXmlDecl)(int isGeneralTextEntity,
     77            const ENCODING *enc,
     78            const char *ptr,
     79            const char *end,
     80            const char **badPtr,
     81            const char **versionPtr,
     82            const char **versionEndPtr,
     83            const char **encodingName,
     84            const ENCODING **encoding,
     85            int *standalone)
    12786{
    128     return doParseXmlDecl(NS(findEncoding),
    129                           isGeneralTextEntity,
    130                           enc,
    131                           ptr,
    132                           end,
    133                           badPtr,
    134                           versionPtr,
    135                           versionEndPtr,
    136                           encodingName,
    137                           encoding,
    138                           standalone);
     87  return doParseXmlDecl(NS(findEncoding),
     88            isGeneralTextEntity,
     89            enc,
     90            ptr,
     91            end,
     92            badPtr,
     93            versionPtr,
     94            versionEndPtr,
     95            encodingName,
     96            encoding,
     97            standalone);
    13998}
Note: See TracChangeset for help on using the changeset viewer.