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

XML updates.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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
Note: See TracChangeset for help on using the changeset viewer.