simgear/xml/xmlrole.c

   1 /*
   2 The contents of this file are subject to the Mozilla Public License
   3 Version 1.1 (the "License"); you may not use this file except in
   4 compliance with the License. You may obtain a copy of the License at
   5 http://www.mozilla.org/MPL/
   6
   7 Software distributed under the License is distributed on an "AS IS"
   8 basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
   9 License for the specific language governing rights and limitations
  10 under the License.
  11
  12 The Original Code is expat.
  13
  14 The Initial Developer of the Original Code is James Clark.
  15 Portions created by James Clark are Copyright (C) 1998, 1999
  16 James Clark. All Rights Reserved.
  17
  18 Contributor(s):
  19
  20 Alternatively, the contents of this file may be used under the terms
  21 of the GNU General Public License (the "GPL"), in which case the
  22 provisions of the GPL are applicable instead of those above.  If you
  23 wish to allow use of your version of this file only under the terms of
  24 the GPL and not to allow others to use your version of this file under
  25 the MPL, indicate your decision by deleting the provisions above and
  26 replace them with the notice and other provisions required by the
  27 GPL. If you do not delete the provisions above, a recipient may use
  28 your version of this file under either the MPL or the GPL.
  29 */
  30
  31 #include "xmldef.h"
  32 #include "xmlrole.h"
  33
  34 /* Doesn't check:
  35
  36  that ,| are not mixed in a model group
  37  content of literals
  38
  39 */
  40
  41 #ifndef MIN_BYTES_PER_CHAR
  42 #define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
  43 #endif
  44
  45 typedef int PROLOG_HANDLER(struct prolog_state *state,
  46                            int tok,
  47                            const char *ptr,
  48                            const char *end,
  49                            const ENCODING *enc);
  50
  51 static PROLOG_HANDLER
  52   prolog0, prolog1, prolog2,
  53   doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
  54   internalSubset,
  55   entity0, entity1, entity2, entity3, entity4, entity5, entity6,
  56   entity7, entity8, entity9,
  57   notation0, notation1, notation2, notation3, notation4,
  58   attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
  59   attlist7, attlist8, attlist9,
  60   element0, element1, element2, element3, element4, element5, element6,
  61   element7,
  62   declClose,
  63   error;
  64
  65 static
  66 int syntaxError(PROLOG_STATE *);
  67
  68 static
  69 int prolog0(PROLOG_STATE *state,
  70             int tok,
  71             const char *ptr,
  72             const char *end,
  73             const ENCODING *enc)
  74 {
  75   switch (tok) {
  76   case XML_TOK_PROLOG_S:
  77     state->handler = prolog1;
  78     return XML_ROLE_NONE;
  79   case XML_TOK_XML_DECL:
  80     state->handler = prolog1;
  81     return XML_ROLE_XML_DECL;
  82   case XML_TOK_PI:
  83     state->handler = prolog1;
  84     return XML_ROLE_NONE;
  85   case XML_TOK_COMMENT:
  86     state->handler = prolog1;
  87   case XML_TOK_BOM:
  88     return XML_ROLE_NONE;
  89   case XML_TOK_DECL_OPEN:
  90     if (!XmlNameMatchesAscii(enc,
  91                              ptr + 2 * MIN_BYTES_PER_CHAR(enc),
  92                              "DOCTYPE"))
  93       break;
  94     state->handler = doctype0;
  95     return XML_ROLE_NONE;
  96   case XML_TOK_INSTANCE_START:
  97     state->handler = error;
  98     return XML_ROLE_INSTANCE_START;
  99   }
 100   return syntaxError(state);
 101 }
 102
 103 static
 104 int prolog1(PROLOG_STATE *state,
 105             int tok,
 106             const char *ptr,
 107             const char *end,
 108             const ENCODING *enc)
 109 {
 110   switch (tok) {
 111   case XML_TOK_PROLOG_S:
 112     return XML_ROLE_NONE;
 113   case XML_TOK_PI:
 114   case XML_TOK_COMMENT:
 115   case XML_TOK_BOM:
 116     return XML_ROLE_NONE;
 117   case XML_TOK_DECL_OPEN:
 118     if (!XmlNameMatchesAscii(enc,
 119                              ptr + 2 * MIN_BYTES_PER_CHAR(enc),
 120                              "DOCTYPE"))
 121       break;
 122     state->handler = doctype0;
 123     return XML_ROLE_NONE;
 124   case XML_TOK_INSTANCE_START:
 125     state->handler = error;
 126     return XML_ROLE_INSTANCE_START;
 127   }
 128   return syntaxError(state);
 129 }
 130
 131 static
 132 int prolog2(PROLOG_STATE *state,
 133             int tok,
 134             const char *ptr,
 135             const char *end,
 136             const ENCODING *enc)
 137 {
 138   switch (tok) {
 139   case XML_TOK_PROLOG_S:
 140     return XML_ROLE_NONE;
 141   case XML_TOK_PI:
 142   case XML_TOK_COMMENT:
 143     return XML_ROLE_NONE;
 144   case XML_TOK_INSTANCE_START:
 145     state->handler = error;
 146     return XML_ROLE_INSTANCE_START;
 147   }
 148   return syntaxError(state);
 149 }
 150
 151 static
 152 int doctype0(PROLOG_STATE *state,
 153              int tok,
 154              const char *ptr,
 155              const char *end,
 156              const ENCODING *enc)
 157 {
 158   switch (tok) {
 159   case XML_TOK_PROLOG_S:
 160     return XML_ROLE_NONE;
 161   case XML_TOK_NAME:
 162   case XML_TOK_PREFIXED_NAME:
 163     state->handler = doctype1;
 164     return XML_ROLE_DOCTYPE_NAME;
 165   }
 166   return syntaxError(state);
 167 }
 168
 169 static
 170 int doctype1(PROLOG_STATE *state,
 171              int tok,
 172              const char *ptr,
 173              const char *end,
 174              const ENCODING *enc)
 175 {
 176   switch (tok) {
 177   case XML_TOK_PROLOG_S:
 178     return XML_ROLE_NONE;
 179   case XML_TOK_OPEN_BRACKET:
 180     state->handler = internalSubset;
 181     return XML_ROLE_NONE;
 182   case XML_TOK_DECL_CLOSE:
 183     state->handler = prolog2;
 184     return XML_ROLE_DOCTYPE_CLOSE;
 185   case XML_TOK_NAME:
 186     if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
 187       state->handler = doctype3;
 188       return XML_ROLE_NONE;
 189     }
 190     if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
 191       state->handler = doctype2;
 192       return XML_ROLE_NONE;
 193     }
 194     break;
 195   }
 196   return syntaxError(state);
 197 }
 198
 199 static
 200 int doctype2(PROLOG_STATE *state,
 201              int tok,
 202              const char *ptr,
 203              const char *end,
 204              const ENCODING *enc)
 205 {
 206   switch (tok) {
 207   case XML_TOK_PROLOG_S:
 208     return XML_ROLE_NONE;
 209   case XML_TOK_LITERAL:
 210     state->handler = doctype3;
 211     return XML_ROLE_DOCTYPE_PUBLIC_ID;
 212   }
 213   return syntaxError(state);
 214 }
 215
 216 static
 217 int doctype3(PROLOG_STATE *state,
 218              int tok,
 219              const char *ptr,
 220              const char *end,
 221              const ENCODING *enc)
 222 {
 223   switch (tok) {
 224   case XML_TOK_PROLOG_S:
 225     return XML_ROLE_NONE;
 226   case XML_TOK_LITERAL:
 227     state->handler = doctype4;
 228     return XML_ROLE_DOCTYPE_SYSTEM_ID;
 229   }
 230   return syntaxError(state);
 231 }
 232
 233 static
 234 int doctype4(PROLOG_STATE *state,
 235              int tok,
 236              const char *ptr,
 237              const char *end,
 238              const ENCODING *enc)
 239 {
 240   switch (tok) {
 241   case XML_TOK_PROLOG_S:
 242     return XML_ROLE_NONE;
 243   case XML_TOK_OPEN_BRACKET:
 244     state->handler = internalSubset;
 245     return XML_ROLE_NONE;
 246   case XML_TOK_DECL_CLOSE:
 247     state->handler = prolog2;
 248     return XML_ROLE_DOCTYPE_CLOSE;
 249   }
 250   return syntaxError(state);
 251 }
 252
 253 static
 254 int doctype5(PROLOG_STATE *state,
 255              int tok,
 256              const char *ptr,
 257              const char *end,
 258              const ENCODING *enc)
 259 {
 260   switch (tok) {
 261   case XML_TOK_PROLOG_S:
 262     return XML_ROLE_NONE;
 263   case XML_TOK_DECL_CLOSE:
 264     state->handler = prolog2;
 265     return XML_ROLE_DOCTYPE_CLOSE;
 266   }
 267   return syntaxError(state);
 268 }
 269
 270 static
 271 int internalSubset(PROLOG_STATE *state,
 272                    int tok,
 273                    const char *ptr,
 274                    const char *end,
 275                    const ENCODING *enc)
 276 {
 277   switch (tok) {
 278   case XML_TOK_PROLOG_S:
 279     return XML_ROLE_NONE;
 280   case XML_TOK_DECL_OPEN:
 281     if (XmlNameMatchesAscii(enc,
 282                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
 283                             "ENTITY")) {
 284       state->handler = entity0;
 285       return XML_ROLE_NONE;
 286     }
 287     if (XmlNameMatchesAscii(enc,
 288                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
 289                             "ATTLIST")) {
 290       state->handler = attlist0;
 291       return XML_ROLE_NONE;
 292     }
 293     if (XmlNameMatchesAscii(enc,
 294                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
 295                             "ELEMENT")) {
 296       state->handler = element0;
 297       return XML_ROLE_NONE;
 298     }
 299     if (XmlNameMatchesAscii(enc,
 300                             ptr + 2 * MIN_BYTES_PER_CHAR(enc),
 301                             "NOTATION")) {
 302       state->handler = notation0;
 303       return XML_ROLE_NONE;
 304     }
 305     break;
 306   case XML_TOK_PI:
 307   case XML_TOK_COMMENT:
 308     return XML_ROLE_NONE;
 309   case XML_TOK_PARAM_ENTITY_REF:
 310     return XML_ROLE_PARAM_ENTITY_REF;
 311   case XML_TOK_CLOSE_BRACKET:
 312     state->handler = doctype5;
 313     return XML_ROLE_NONE;
 314   }
 315   return syntaxError(state);
 316 }
 317
 318 static
 319 int entity0(PROLOG_STATE *state,
 320             int tok,
 321             const char *ptr,
 322             const char *end,
 323             const ENCODING *enc)
 324 {
 325   switch (tok) {
 326   case XML_TOK_PROLOG_S:
 327     return XML_ROLE_NONE;
 328   case XML_TOK_PERCENT:
 329     state->handler = entity1;
 330     return XML_ROLE_NONE;
 331   case XML_TOK_NAME:
 332     state->handler = entity2;
 333     return XML_ROLE_GENERAL_ENTITY_NAME;
 334   }
 335   return syntaxError(state);
 336 }
 337
 338 static
 339 int entity1(PROLOG_STATE *state,
 340             int tok,
 341             const char *ptr,
 342             const char *end,
 343             const ENCODING *enc)
 344 {
 345   switch (tok) {
 346   case XML_TOK_PROLOG_S:
 347     return XML_ROLE_NONE;
 348   case XML_TOK_NAME:
 349     state->handler = entity7;
 350     return XML_ROLE_PARAM_ENTITY_NAME;
 351   }
 352   return syntaxError(state);
 353 }
 354
 355 static
 356 int entity2(PROLOG_STATE *state,
 357             int tok,
 358             const char *ptr,
 359             const char *end,
 360             const ENCODING *enc)
 361 {
 362   switch (tok) {
 363   case XML_TOK_PROLOG_S:
 364     return XML_ROLE_NONE;
 365   case XML_TOK_NAME:
 366     if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
 367       state->handler = entity4;
 368       return XML_ROLE_NONE;
 369     }
 370     if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
 371       state->handler = entity3;
 372       return XML_ROLE_NONE;
 373     }
 374     break;
 375   case XML_TOK_LITERAL:
 376     state->handler = declClose;
 377     return XML_ROLE_ENTITY_VALUE;
 378   }
 379   return syntaxError(state);
 380 }
 381
 382 static
 383 int entity3(PROLOG_STATE *state,
 384             int tok,
 385             const char *ptr,
 386             const char *end,
 387             const ENCODING *enc)
 388 {
 389   switch (tok) {
 390   case XML_TOK_PROLOG_S:
 391     return XML_ROLE_NONE;
 392   case XML_TOK_LITERAL:
 393     state->handler = entity4;
 394     return XML_ROLE_ENTITY_PUBLIC_ID;
 395   }
 396   return syntaxError(state);
 397 }
 398
 399
 400 static
 401 int entity4(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_PROLOG_S:
 409     return XML_ROLE_NONE;
 410   case XML_TOK_LITERAL:
 411     state->handler = entity5;
 412     return XML_ROLE_ENTITY_SYSTEM_ID;
 413   }
 414   return syntaxError(state);
 415 }
 416
 417 static
 418 int entity5(PROLOG_STATE *state,
 419             int tok,
 420             const char *ptr,
 421             const char *end,
 422             const ENCODING *enc)
 423 {
 424   switch (tok) {
 425   case XML_TOK_PROLOG_S:
 426     return XML_ROLE_NONE;
 427   case XML_TOK_DECL_CLOSE:
 428     state->handler = internalSubset;
 429     return XML_ROLE_NONE;
 430   case XML_TOK_NAME:
 431     if (XmlNameMatchesAscii(enc, ptr, "NDATA")) {
 432       state->handler = entity6;
 433       return XML_ROLE_NONE;
 434     }
 435     break;
 436   }
 437   return syntaxError(state);
 438 }
 439
 440 static
 441 int entity6(PROLOG_STATE *state,
 442             int tok,
 443             const char *ptr,
 444             const char *end,
 445             const ENCODING *enc)
 446 {
 447   switch (tok) {
 448   case XML_TOK_PROLOG_S:
 449     return XML_ROLE_NONE;
 450   case XML_TOK_NAME:
 451     state->handler = declClose;
 452     return XML_ROLE_ENTITY_NOTATION_NAME;
 453   }
 454   return syntaxError(state);
 455 }
 456
 457 static
 458 int entity7(PROLOG_STATE *state,
 459             int tok,
 460             const char *ptr,
 461             const char *end,
 462             const ENCODING *enc)
 463 {
 464   switch (tok) {
 465   case XML_TOK_PROLOG_S:
 466     return XML_ROLE_NONE;
 467   case XML_TOK_NAME:
 468     if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
 469       state->handler = entity9;
 470       return XML_ROLE_NONE;
 471     }
 472     if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
 473       state->handler = entity8;
 474       return XML_ROLE_NONE;
 475     }
 476     break;
 477   case XML_TOK_LITERAL:
 478     state->handler = declClose;
 479     return XML_ROLE_ENTITY_VALUE;
 480   }
 481   return syntaxError(state);
 482 }
 483
 484 static
 485 int entity8(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_LITERAL:
 495     state->handler = entity9;
 496     return XML_ROLE_ENTITY_PUBLIC_ID;
 497   }
 498   return syntaxError(state);
 499 }
 500
 501 static
 502 int entity9(PROLOG_STATE *state,
 503             int tok,
 504             const char *ptr,
 505             const char *end,
 506             const ENCODING *enc)
 507 {
 508   switch (tok) {
 509   case XML_TOK_PROLOG_S:
 510     return XML_ROLE_NONE;
 511   case XML_TOK_LITERAL:
 512     state->handler = declClose;
 513     return XML_ROLE_ENTITY_SYSTEM_ID;
 514   }
 515   return syntaxError(state);
 516 }
 517
 518 static
 519 int notation0(PROLOG_STATE *state,
 520               int tok,
 521               const char *ptr,
 522               const char *end,
 523               const ENCODING *enc)
 524 {
 525   switch (tok) {
 526   case XML_TOK_PROLOG_S:
 527     return XML_ROLE_NONE;
 528   case XML_TOK_NAME:
 529     state->handler = notation1;
 530     return XML_ROLE_NOTATION_NAME;
 531   }
 532   return syntaxError(state);
 533 }
 534
 535 static
 536 int notation1(PROLOG_STATE *state,
 537               int tok,
 538               const char *ptr,
 539               const char *end,
 540               const ENCODING *enc)
 541 {
 542   switch (tok) {
 543   case XML_TOK_PROLOG_S:
 544     return XML_ROLE_NONE;
 545   case XML_TOK_NAME:
 546     if (XmlNameMatchesAscii(enc, ptr, "SYSTEM")) {
 547       state->handler = notation3;
 548       return XML_ROLE_NONE;
 549     }
 550     if (XmlNameMatchesAscii(enc, ptr, "PUBLIC")) {
 551       state->handler = notation2;
 552       return XML_ROLE_NONE;
 553     }
 554     break;
 555   }
 556   return syntaxError(state);
 557 }
 558
 559 static
 560 int notation2(PROLOG_STATE *state,
 561               int tok,
 562               const char *ptr,
 563               const char *end,
 564               const ENCODING *enc)
 565 {
 566   switch (tok) {
 567   case XML_TOK_PROLOG_S:
 568     return XML_ROLE_NONE;
 569   case XML_TOK_LITERAL:
 570     state->handler = notation4;
 571     return XML_ROLE_NOTATION_PUBLIC_ID;
 572   }
 573   return syntaxError(state);
 574 }
 575
 576 static
 577 int notation3(PROLOG_STATE *state,
 578               int tok,
 579               const char *ptr,
 580               const char *end,
 581               const ENCODING *enc)
 582 {
 583   switch (tok) {
 584   case XML_TOK_PROLOG_S:
 585     return XML_ROLE_NONE;
 586   case XML_TOK_LITERAL:
 587     state->handler = declClose;
 588     return XML_ROLE_NOTATION_SYSTEM_ID;
 589   }
 590   return syntaxError(state);
 591 }
 592
 593 static
 594 int notation4(PROLOG_STATE *state,
 595               int tok,
 596               const char *ptr,
 597               const char *end,
 598               const ENCODING *enc)
 599 {
 600   switch (tok) {
 601   case XML_TOK_PROLOG_S:
 602     return XML_ROLE_NONE;
 603   case XML_TOK_LITERAL:
 604     state->handler = declClose;
 605     return XML_ROLE_NOTATION_SYSTEM_ID;
 606   case XML_TOK_DECL_CLOSE:
 607     state->handler = internalSubset;
 608     return XML_ROLE_NOTATION_NO_SYSTEM_ID;
 609   }
 610   return syntaxError(state);
 611 }
 612
 613 static
 614 int attlist0(PROLOG_STATE *state,
 615              int tok,
 616              const char *ptr,
 617              const char *end,
 618              const ENCODING *enc)
 619 {
 620   switch (tok) {
 621   case XML_TOK_PROLOG_S:
 622     return XML_ROLE_NONE;
 623   case XML_TOK_NAME:
 624   case XML_TOK_PREFIXED_NAME:
 625     state->handler = attlist1;
 626     return XML_ROLE_ATTLIST_ELEMENT_NAME;
 627   }
 628   return syntaxError(state);
 629 }
 630
 631 static
 632 int attlist1(PROLOG_STATE *state,
 633              int tok,
 634              const char *ptr,
 635              const char *end,
 636              const ENCODING *enc)
 637 {
 638   switch (tok) {
 639   case XML_TOK_PROLOG_S:
 640     return XML_ROLE_NONE;
 641   case XML_TOK_DECL_CLOSE:
 642     state->handler = internalSubset;
 643     return XML_ROLE_NONE;
 644   case XML_TOK_NAME:
 645   case XML_TOK_PREFIXED_NAME:
 646     state->handler = attlist2;
 647     return XML_ROLE_ATTRIBUTE_NAME;
 648   }
 649   return syntaxError(state);
 650 }
 651
 652 static
 653 int attlist2(PROLOG_STATE *state,
 654              int tok,
 655              const char *ptr,
 656              const char *end,
 657              const ENCODING *enc)
 658 {
 659   switch (tok) {
 660   case XML_TOK_PROLOG_S:
 661     return XML_ROLE_NONE;
 662   case XML_TOK_NAME:
 663     {
 664       static const char *types[] = {
 665         "CDATA",
 666         "ID",
 667         "IDREF",
 668         "IDREFS",
 669         "ENTITY",
 670         "ENTITIES",
 671         "NMTOKEN",
 672         "NMTOKENS",
 673       };
 674       int i;
 675       for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
 676         if (XmlNameMatchesAscii(enc, ptr, types[i])) {
 677           state->handler = attlist8;
 678           return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
 679         }
 680     }
 681     if (XmlNameMatchesAscii(enc, ptr, "NOTATION")) {
 682       state->handler = attlist5;
 683       return XML_ROLE_NONE;
 684     }
 685     break;
 686   case XML_TOK_OPEN_PAREN:
 687     state->handler = attlist3;
 688     return XML_ROLE_NONE;
 689   }
 690   return syntaxError(state);
 691 }
 692
 693 static
 694 int attlist3(PROLOG_STATE *state,
 695              int tok,
 696              const char *ptr,
 697              const char *end,
 698              const ENCODING *enc)
 699 {
 700   switch (tok) {
 701   case XML_TOK_PROLOG_S:
 702     return XML_ROLE_NONE;
 703   case XML_TOK_NMTOKEN:
 704   case XML_TOK_NAME:
 705   case XML_TOK_PREFIXED_NAME:
 706     state->handler = attlist4;
 707     return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
 708   }
 709   return syntaxError(state);
 710 }
 711
 712 static
 713 int attlist4(PROLOG_STATE *state,
 714              int tok,
 715              const char *ptr,
 716              const char *end,
 717              const ENCODING *enc)
 718 {
 719   switch (tok) {
 720   case XML_TOK_PROLOG_S:
 721     return XML_ROLE_NONE;
 722   case XML_TOK_CLOSE_PAREN:
 723     state->handler = attlist8;
 724     return XML_ROLE_NONE;
 725   case XML_TOK_OR:
 726     state->handler = attlist3;
 727     return XML_ROLE_NONE;
 728   }
 729   return syntaxError(state);
 730 }
 731
 732 static
 733 int attlist5(PROLOG_STATE *state,
 734              int tok,
 735              const char *ptr,
 736              const char *end,
 737              const ENCODING *enc)
 738 {
 739   switch (tok) {
 740   case XML_TOK_PROLOG_S:
 741     return XML_ROLE_NONE;
 742   case XML_TOK_OPEN_PAREN:
 743     state->handler = attlist6;
 744     return XML_ROLE_NONE;
 745   }
 746   return syntaxError(state);
 747 }
 748
 749
 750 static
 751 int attlist6(PROLOG_STATE *state,
 752              int tok,
 753              const char *ptr,
 754              const char *end,
 755              const ENCODING *enc)
 756 {
 757   switch (tok) {
 758   case XML_TOK_PROLOG_S:
 759     return XML_ROLE_NONE;
 760   case XML_TOK_NAME:
 761     state->handler = attlist7;
 762     return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
 763   }
 764   return syntaxError(state);
 765 }
 766
 767 static
 768 int attlist7(PROLOG_STATE *state,
 769              int tok,
 770              const char *ptr,
 771              const char *end,
 772              const ENCODING *enc)
 773 {
 774   switch (tok) {
 775   case XML_TOK_PROLOG_S:
 776     return XML_ROLE_NONE;
 777   case XML_TOK_CLOSE_PAREN:
 778     state->handler = attlist8;
 779     return XML_ROLE_NONE;
 780   case XML_TOK_OR:
 781     state->handler = attlist6;
 782     return XML_ROLE_NONE;
 783   }
 784   return syntaxError(state);
 785 }
 786
 787 /* default value */
 788 static
 789 int attlist8(PROLOG_STATE *state,
 790              int tok,
 791              const char *ptr,
 792              const char *end,
 793              const ENCODING *enc)
 794 {
 795   switch (tok) {
 796   case XML_TOK_PROLOG_S:
 797     return XML_ROLE_NONE;
 798   case XML_TOK_POUND_NAME:
 799     if (XmlNameMatchesAscii(enc,
 800                             ptr + MIN_BYTES_PER_CHAR(enc),
 801                             "IMPLIED")) {
 802       state->handler = attlist1;
 803       return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
 804     }
 805     if (XmlNameMatchesAscii(enc,
 806                             ptr + MIN_BYTES_PER_CHAR(enc),
 807                             "REQUIRED")) {
 808       state->handler = attlist1;
 809       return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
 810     }
 811     if (XmlNameMatchesAscii(enc,
 812                             ptr + MIN_BYTES_PER_CHAR(enc),
 813                             "FIXED")) {
 814       state->handler = attlist9;
 815       return XML_ROLE_NONE;
 816     }
 817     break;
 818   case XML_TOK_LITERAL:
 819     state->handler = attlist1;
 820     return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
 821   }
 822   return syntaxError(state);
 823 }
 824
 825 static
 826 int attlist9(PROLOG_STATE *state,
 827              int tok,
 828              const char *ptr,
 829              const char *end,
 830              const ENCODING *enc)
 831 {
 832   switch (tok) {
 833   case XML_TOK_PROLOG_S:
 834     return XML_ROLE_NONE;
 835   case XML_TOK_LITERAL:
 836     state->handler = attlist1;
 837     return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
 838   }
 839   return syntaxError(state);
 840 }
 841
 842 static
 843 int element0(PROLOG_STATE *state,
 844              int tok,
 845              const char *ptr,
 846              const char *end,
 847              const ENCODING *enc)
 848 {
 849   switch (tok) {
 850   case XML_TOK_PROLOG_S:
 851     return XML_ROLE_NONE;
 852   case XML_TOK_NAME:
 853   case XML_TOK_PREFIXED_NAME:
 854     state->handler = element1;
 855     return XML_ROLE_ELEMENT_NAME;
 856   }
 857   return syntaxError(state);
 858 }
 859
 860 static
 861 int element1(PROLOG_STATE *state,
 862              int tok,
 863              const char *ptr,
 864              const char *end,
 865              const ENCODING *enc)
 866 {
 867   switch (tok) {
 868   case XML_TOK_PROLOG_S:
 869     return XML_ROLE_NONE;
 870   case XML_TOK_NAME:
 871     if (XmlNameMatchesAscii(enc, ptr, "EMPTY")) {
 872       state->handler = declClose;
 873       return XML_ROLE_CONTENT_EMPTY;
 874     }
 875     if (XmlNameMatchesAscii(enc, ptr, "ANY")) {
 876       state->handler = declClose;
 877       return XML_ROLE_CONTENT_ANY;
 878     }
 879     break;
 880   case XML_TOK_OPEN_PAREN:
 881     state->handler = element2;
 882     state->level = 1;
 883     return XML_ROLE_GROUP_OPEN;
 884   }
 885   return syntaxError(state);
 886 }
 887
 888 static
 889 int element2(PROLOG_STATE *state,
 890              int tok,
 891              const char *ptr,
 892              const char *end,
 893              const ENCODING *enc)
 894 {
 895   switch (tok) {
 896   case XML_TOK_PROLOG_S:
 897     return XML_ROLE_NONE;
 898   case XML_TOK_POUND_NAME:
 899     if (XmlNameMatchesAscii(enc,
 900                             ptr + MIN_BYTES_PER_CHAR(enc),
 901                             "PCDATA")) {
 902       state->handler = element3;
 903       return XML_ROLE_CONTENT_PCDATA;
 904     }
 905     break;
 906   case XML_TOK_OPEN_PAREN:
 907     state->level = 2;
 908     state->handler = element6;
 909     return XML_ROLE_GROUP_OPEN;
 910   case XML_TOK_NAME:
 911   case XML_TOK_PREFIXED_NAME:
 912     state->handler = element7;
 913     return XML_ROLE_CONTENT_ELEMENT;
 914   case XML_TOK_NAME_QUESTION:
 915     state->handler = element7;
 916     return XML_ROLE_CONTENT_ELEMENT_OPT;
 917   case XML_TOK_NAME_ASTERISK:
 918     state->handler = element7;
 919     return XML_ROLE_CONTENT_ELEMENT_REP;
 920   case XML_TOK_NAME_PLUS:
 921     state->handler = element7;
 922     return XML_ROLE_CONTENT_ELEMENT_PLUS;
 923   }
 924   return syntaxError(state);
 925 }
 926
 927 static
 928 int element3(PROLOG_STATE *state,
 929              int tok,
 930              const char *ptr,
 931              const char *end,
 932              const ENCODING *enc)
 933 {
 934   switch (tok) {
 935   case XML_TOK_PROLOG_S:
 936     return XML_ROLE_NONE;
 937   case XML_TOK_CLOSE_PAREN:
 938   case XML_TOK_CLOSE_PAREN_ASTERISK:
 939     state->handler = declClose;
 940     return XML_ROLE_GROUP_CLOSE_REP;
 941   case XML_TOK_OR:
 942     state->handler = element4;
 943     return XML_ROLE_NONE;
 944   }
 945   return syntaxError(state);
 946 }
 947
 948 static
 949 int element4(PROLOG_STATE *state,
 950              int tok,
 951              const char *ptr,
 952              const char *end,
 953              const ENCODING *enc)
 954 {
 955   switch (tok) {
 956   case XML_TOK_PROLOG_S:
 957     return XML_ROLE_NONE;
 958   case XML_TOK_NAME:
 959   case XML_TOK_PREFIXED_NAME:
 960     state->handler = element5;
 961     return XML_ROLE_CONTENT_ELEMENT;
 962   }
 963   return syntaxError(state);
 964 }
 965
 966 static
 967 int element5(PROLOG_STATE *state,
 968              int tok,
 969              const char *ptr,
 970              const char *end,
 971              const ENCODING *enc)
 972 {
 973   switch (tok) {
 974   case XML_TOK_PROLOG_S:
 975     return XML_ROLE_NONE;
 976   case XML_TOK_CLOSE_PAREN_ASTERISK:
 977     state->handler = declClose;
 978     return XML_ROLE_GROUP_CLOSE_REP;
 979   case XML_TOK_OR:
 980     state->handler = element4;
 981     return XML_ROLE_NONE;
 982   }
 983   return syntaxError(state);
 984 }
 985
 986 static
 987 int element6(PROLOG_STATE *state,
 988              int tok,
 989              const char *ptr,
 990              const char *end,
 991              const ENCODING *enc)
 992 {
 993   switch (tok) {
 994   case XML_TOK_PROLOG_S:
 995     return XML_ROLE_NONE;
 996   case XML_TOK_OPEN_PAREN:
 997     state->level += 1;
 998     return XML_ROLE_GROUP_OPEN;
 999   case XML_TOK_NAME:
1000   case XML_TOK_PREFIXED_NAME:
1001     state->handler = element7;
1002     return XML_ROLE_CONTENT_ELEMENT;
1003   case XML_TOK_NAME_QUESTION:
1004     state->handler = element7;
1005     return XML_ROLE_CONTENT_ELEMENT_OPT;
1006   case XML_TOK_NAME_ASTERISK:
1007     state->handler = element7;
1008     return XML_ROLE_CONTENT_ELEMENT_REP;
1009   case XML_TOK_NAME_PLUS:
1010     state->handler = element7;
1011     return XML_ROLE_CONTENT_ELEMENT_PLUS;
1012   }
1013   return syntaxError(state);
1014 }
1015
1016 static
1017 int element7(PROLOG_STATE *state,
1018              int tok,
1019              const char *ptr,
1020              const char *end,
1021              const ENCODING *enc)
1022 {
1023   switch (tok) {
1024   case XML_TOK_PROLOG_S:
1025     return XML_ROLE_NONE;
1026   case XML_TOK_CLOSE_PAREN:
1027     state->level -= 1;
1028     if (state->level == 0)
1029       state->handler = declClose;
1030     return XML_ROLE_GROUP_CLOSE;
1031   case XML_TOK_CLOSE_PAREN_ASTERISK:
1032     state->level -= 1;
1033     if (state->level == 0)
1034       state->handler = declClose;
1035     return XML_ROLE_GROUP_CLOSE_REP;
1036   case XML_TOK_CLOSE_PAREN_QUESTION:
1037     state->level -= 1;
1038     if (state->level == 0)
1039       state->handler = declClose;
1040     return XML_ROLE_GROUP_CLOSE_OPT;
1041   case XML_TOK_CLOSE_PAREN_PLUS:
1042     state->level -= 1;
1043     if (state->level == 0)
1044       state->handler = declClose;
1045     return XML_ROLE_GROUP_CLOSE_PLUS;
1046   case XML_TOK_COMMA:
1047     state->handler = element6;
1048     return XML_ROLE_GROUP_SEQUENCE;
1049   case XML_TOK_OR:
1050     state->handler = element6;
1051     return XML_ROLE_GROUP_CHOICE;
1052   }
1053   return syntaxError(state);
1054 }
1055
1056 static
1057 int declClose(PROLOG_STATE *state,
1058               int tok,
1059               const char *ptr,
1060               const char *end,
1061               const ENCODING *enc)
1062 {
1063   switch (tok) {
1064   case XML_TOK_PROLOG_S:
1065     return XML_ROLE_NONE;
1066   case XML_TOK_DECL_CLOSE:
1067     state->handler = internalSubset;
1068     return XML_ROLE_NONE;
1069   }
1070   return syntaxError(state);
1071 }
1072
1073 #if 0
1074
1075 static
1076 int ignore(PROLOG_STATE *state,
1077            int tok,
1078            const char *ptr,
1079            const char *end,
1080            const ENCODING *enc)
1081 {
1082   switch (tok) {
1083   case XML_TOK_DECL_CLOSE:
1084     state->handler = internalSubset;
1085     return 0;
1086   default:
1087     return XML_ROLE_NONE;
1088   }
1089   return syntaxError(state);
1090 }
1091 #endif
1092
1093 static
1094 int error(PROLOG_STATE *state,
1095            int tok,
1096            const char *ptr,
1097            const char *end,
1098            const ENCODING *enc)
1099 {
1100   return XML_ROLE_NONE;
1101 }
1102
1103 static
1104 int syntaxError(PROLOG_STATE *state)
1105 {
1106   state->handler = error;
1107   return XML_ROLE_ERROR;
1108 }
1109
1110 void XmlPrologStateInit(PROLOG_STATE *state)
1111 {
1112   state->handler = prolog0;
1113 }