git.maemo.org Git - xmlrpc-c/blob - lib/expat/xmltok/xmlrole.c

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