FryingPan/Expat/xmlrole.c

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