LCOV - app.info - parser/expat/lib/xmlrole.c

LCOV - code coverage report
| Current view: | directory - parser/expat/lib - xmlrole.c (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 499 | 124 | 24.8 %
| Date: | 2012-07-07 | Functions: | 54 | 18 | 33.3 %

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

Generated by: LCOV version 1.7