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