lib/xmlrole.c

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