contrib/expat/lib/xmlrole.c

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