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