AppPkg/Applications/Python/Python-2.7.10/Modules/expat/xmltok_impl.c

   1 /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
   2    See the file COPYING for copying permission.
   3 */
   4
   5 /* This file is included! */
   6 #ifdef XML_TOK_IMPL_C
   7
   8 #ifndef IS_INVALID_CHAR
   9 #define IS_INVALID_CHAR(enc, ptr, n) (0)
  10 #endif
  11
  12 #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
  13     case BT_LEAD ## n: \
  14       if (end - ptr < n) \
  15         return XML_TOK_PARTIAL_CHAR; \
  16       if (IS_INVALID_CHAR(enc, ptr, n)) { \
  17         *(nextTokPtr) = (ptr); \
  18         return XML_TOK_INVALID; \
  19       } \
  20       ptr += n; \
  21       break;
  22
  23 #define INVALID_CASES(ptr, nextTokPtr) \
  24   INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
  25   INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
  26   INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
  27   case BT_NONXML: \
  28   case BT_MALFORM: \
  29   case BT_TRAIL: \
  30     *(nextTokPtr) = (ptr); \
  31     return XML_TOK_INVALID;
  32
  33 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
  34    case BT_LEAD ## n: \
  35      if (end - ptr < n) \
  36        return XML_TOK_PARTIAL_CHAR; \
  37      if (!IS_NAME_CHAR(enc, ptr, n)) { \
  38        *nextTokPtr = ptr; \
  39        return XML_TOK_INVALID; \
  40      } \
  41      ptr += n; \
  42      break;
  43
  44 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
  45   case BT_NONASCII: \
  46     if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
  47       *nextTokPtr = ptr; \
  48       return XML_TOK_INVALID; \
  49     } \
  50   case BT_NMSTRT: \
  51   case BT_HEX: \
  52   case BT_DIGIT: \
  53   case BT_NAME: \
  54   case BT_MINUS: \
  55     ptr += MINBPC(enc); \
  56     break; \
  57   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
  58   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
  59   CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
  60
  61 #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
  62    case BT_LEAD ## n: \
  63      if (end - ptr < n) \
  64        return XML_TOK_PARTIAL_CHAR; \
  65      if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
  66        *nextTokPtr = ptr; \
  67        return XML_TOK_INVALID; \
  68      } \
  69      ptr += n; \
  70      break;
  71
  72 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
  73   case BT_NONASCII: \
  74     if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
  75       *nextTokPtr = ptr; \
  76       return XML_TOK_INVALID; \
  77     } \
  78   case BT_NMSTRT: \
  79   case BT_HEX: \
  80     ptr += MINBPC(enc); \
  81     break; \
  82   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
  83   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
  84   CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
  85
  86 #ifndef PREFIX
  87 #define PREFIX(ident) ident
  88 #endif
  89
  90 /* ptr points to character following "<!-" */
  91
  92 static int PTRCALL
  93 PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
  94                     const char *end, const char **nextTokPtr)
  95 {
  96   if (ptr != end) {
  97     if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
  98       *nextTokPtr = ptr;
  99       return XML_TOK_INVALID;
 100     }
 101     ptr += MINBPC(enc);
 102     while (ptr != end) {
 103       switch (BYTE_TYPE(enc, ptr)) {
 104       INVALID_CASES(ptr, nextTokPtr)
 105       case BT_MINUS:
 106         if ((ptr += MINBPC(enc)) == end)
 107           return XML_TOK_PARTIAL;
 108         if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
 109           if ((ptr += MINBPC(enc)) == end)
 110             return XML_TOK_PARTIAL;
 111           if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 112             *nextTokPtr = ptr;
 113             return XML_TOK_INVALID;
 114           }
 115           *nextTokPtr = ptr + MINBPC(enc);
 116           return XML_TOK_COMMENT;
 117         }
 118         break;
 119       default:
 120         ptr += MINBPC(enc);
 121         break;
 122       }
 123     }
 124   }
 125   return XML_TOK_PARTIAL;
 126 }
 127
 128 /* ptr points to character following "<!" */
 129
 130 static int PTRCALL
 131 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
 132                  const char *end, const char **nextTokPtr)
 133 {
 134   if (ptr == end)
 135     return XML_TOK_PARTIAL;
 136   switch (BYTE_TYPE(enc, ptr)) {
 137   case BT_MINUS:
 138     return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 139   case BT_LSQB:
 140     *nextTokPtr = ptr + MINBPC(enc);
 141     return XML_TOK_COND_SECT_OPEN;
 142   case BT_NMSTRT:
 143   case BT_HEX:
 144     ptr += MINBPC(enc);
 145     break;
 146   default:
 147     *nextTokPtr = ptr;
 148     return XML_TOK_INVALID;
 149   }
 150   while (ptr != end) {
 151     switch (BYTE_TYPE(enc, ptr)) {
 152     case BT_PERCNT:
 153       if (ptr + MINBPC(enc) == end)
 154         return XML_TOK_PARTIAL;
 155       /* don't allow <!ENTITY% foo "whatever"> */
 156       switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
 157       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
 158         *nextTokPtr = ptr;
 159         return XML_TOK_INVALID;
 160       }
 161       /* fall through */
 162     case BT_S: case BT_CR: case BT_LF:
 163       *nextTokPtr = ptr;
 164       return XML_TOK_DECL_OPEN;
 165     case BT_NMSTRT:
 166     case BT_HEX:
 167       ptr += MINBPC(enc);
 168       break;
 169     default:
 170       *nextTokPtr = ptr;
 171       return XML_TOK_INVALID;
 172     }
 173   }
 174   return XML_TOK_PARTIAL;
 175 }
 176
 177 static int PTRCALL
 178 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
 179                       const char *end, int *tokPtr)
 180 {
 181   int upper = 0;
 182   *tokPtr = XML_TOK_PI;
 183   if (end - ptr != MINBPC(enc)*3)
 184     return 1;
 185   switch (BYTE_TO_ASCII(enc, ptr)) {
 186   case ASCII_x:
 187     break;
 188   case ASCII_X:
 189     upper = 1;
 190     break;
 191   default:
 192     return 1;
 193   }
 194   ptr += MINBPC(enc);
 195   switch (BYTE_TO_ASCII(enc, ptr)) {
 196   case ASCII_m:
 197     break;
 198   case ASCII_M:
 199     upper = 1;
 200     break;
 201   default:
 202     return 1;
 203   }
 204   ptr += MINBPC(enc);
 205   switch (BYTE_TO_ASCII(enc, ptr)) {
 206   case ASCII_l:
 207     break;
 208   case ASCII_L:
 209     upper = 1;
 210     break;
 211   default:
 212     return 1;
 213   }
 214   if (upper)
 215     return 0;
 216   *tokPtr = XML_TOK_XML_DECL;
 217   return 1;
 218 }
 219
 220 /* ptr points to character following "<?" */
 221
 222 static int PTRCALL
 223 PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
 224                const char *end, const char **nextTokPtr)
 225 {
 226   int tok;
 227   const char *target = ptr;
 228   if (ptr == end)
 229     return XML_TOK_PARTIAL;
 230   switch (BYTE_TYPE(enc, ptr)) {
 231   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 232   default:
 233     *nextTokPtr = ptr;
 234     return XML_TOK_INVALID;
 235   }
 236   while (ptr != end) {
 237     switch (BYTE_TYPE(enc, ptr)) {
 238     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 239     case BT_S: case BT_CR: case BT_LF:
 240       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
 241         *nextTokPtr = ptr;
 242         return XML_TOK_INVALID;
 243       }
 244       ptr += MINBPC(enc);
 245       while (ptr != end) {
 246         switch (BYTE_TYPE(enc, ptr)) {
 247         INVALID_CASES(ptr, nextTokPtr)
 248         case BT_QUEST:
 249           ptr += MINBPC(enc);
 250           if (ptr == end)
 251             return XML_TOK_PARTIAL;
 252           if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 253             *nextTokPtr = ptr + MINBPC(enc);
 254             return tok;
 255           }
 256           break;
 257         default:
 258           ptr += MINBPC(enc);
 259           break;
 260         }
 261       }
 262       return XML_TOK_PARTIAL;
 263     case BT_QUEST:
 264       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
 265         *nextTokPtr = ptr;
 266         return XML_TOK_INVALID;
 267       }
 268       ptr += MINBPC(enc);
 269       if (ptr == end)
 270         return XML_TOK_PARTIAL;
 271       if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 272         *nextTokPtr = ptr + MINBPC(enc);
 273         return tok;
 274       }
 275       /* fall through */
 276     default:
 277       *nextTokPtr = ptr;
 278       return XML_TOK_INVALID;
 279     }
 280   }
 281   return XML_TOK_PARTIAL;
 282 }
 283
 284 static int PTRCALL
 285 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
 286                          const char *end, const char **nextTokPtr)
 287 {
 288   static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
 289                                      ASCII_T, ASCII_A, ASCII_LSQB };
 290   int i;
 291   /* CDATA[ */
 292   if (end - ptr < 6 * MINBPC(enc))
 293     return XML_TOK_PARTIAL;
 294   for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
 295     if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
 296       *nextTokPtr = ptr;
 297       return XML_TOK_INVALID;
 298     }
 299   }
 300   *nextTokPtr = ptr;
 301   return XML_TOK_CDATA_SECT_OPEN;
 302 }
 303
 304 static int PTRCALL
 305 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
 306                         const char *end, const char **nextTokPtr)
 307 {
 308   if (ptr == end)
 309     return XML_TOK_NONE;
 310   if (MINBPC(enc) > 1) {
 311     size_t n = end - ptr;
 312     if (n & (MINBPC(enc) - 1)) {
 313       n &= ~(MINBPC(enc) - 1);
 314       if (n == 0)
 315         return XML_TOK_PARTIAL;
 316       end = ptr + n;
 317     }
 318   }
 319   switch (BYTE_TYPE(enc, ptr)) {
 320   case BT_RSQB:
 321     ptr += MINBPC(enc);
 322     if (ptr == end)
 323       return XML_TOK_PARTIAL;
 324     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
 325       break;
 326     ptr += MINBPC(enc);
 327     if (ptr == end)
 328       return XML_TOK_PARTIAL;
 329     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 330       ptr -= MINBPC(enc);
 331       break;
 332     }
 333     *nextTokPtr = ptr + MINBPC(enc);
 334     return XML_TOK_CDATA_SECT_CLOSE;
 335   case BT_CR:
 336     ptr += MINBPC(enc);
 337     if (ptr == end)
 338       return XML_TOK_PARTIAL;
 339     if (BYTE_TYPE(enc, ptr) == BT_LF)
 340       ptr += MINBPC(enc);
 341     *nextTokPtr = ptr;
 342     return XML_TOK_DATA_NEWLINE;
 343   case BT_LF:
 344     *nextTokPtr = ptr + MINBPC(enc);
 345     return XML_TOK_DATA_NEWLINE;
 346   INVALID_CASES(ptr, nextTokPtr)
 347   default:
 348     ptr += MINBPC(enc);
 349     break;
 350   }
 351   while (ptr != end) {
 352     switch (BYTE_TYPE(enc, ptr)) {
 353 #define LEAD_CASE(n) \
 354     case BT_LEAD ## n: \
 355       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
 356         *nextTokPtr = ptr; \
 357         return XML_TOK_DATA_CHARS; \
 358       } \
 359       ptr += n; \
 360       break;
 361     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 362 #undef LEAD_CASE
 363     case BT_NONXML:
 364     case BT_MALFORM:
 365     case BT_TRAIL:
 366     case BT_CR:
 367     case BT_LF:
 368     case BT_RSQB:
 369       *nextTokPtr = ptr;
 370       return XML_TOK_DATA_CHARS;
 371     default:
 372       ptr += MINBPC(enc);
 373       break;
 374     }
 375   }
 376   *nextTokPtr = ptr;
 377   return XML_TOK_DATA_CHARS;
 378 }
 379
 380 /* ptr points to character following "</" */
 381
 382 static int PTRCALL
 383 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
 384                    const char *end, const char **nextTokPtr)
 385 {
 386   if (ptr == end)
 387     return XML_TOK_PARTIAL;
 388   switch (BYTE_TYPE(enc, ptr)) {
 389   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 390   default:
 391     *nextTokPtr = ptr;
 392     return XML_TOK_INVALID;
 393   }
 394   while (ptr != end) {
 395     switch (BYTE_TYPE(enc, ptr)) {
 396     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 397     case BT_S: case BT_CR: case BT_LF:
 398       for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
 399         switch (BYTE_TYPE(enc, ptr)) {
 400         case BT_S: case BT_CR: case BT_LF:
 401           break;
 402         case BT_GT:
 403           *nextTokPtr = ptr + MINBPC(enc);
 404           return XML_TOK_END_TAG;
 405         default:
 406           *nextTokPtr = ptr;
 407           return XML_TOK_INVALID;
 408         }
 409       }
 410       return XML_TOK_PARTIAL;
 411 #ifdef XML_NS
 412     case BT_COLON:
 413       /* no need to check qname syntax here,
 414          since end-tag must match exactly */
 415       ptr += MINBPC(enc);
 416       break;
 417 #endif
 418     case BT_GT:
 419       *nextTokPtr = ptr + MINBPC(enc);
 420       return XML_TOK_END_TAG;
 421     default:
 422       *nextTokPtr = ptr;
 423       return XML_TOK_INVALID;
 424     }
 425   }
 426   return XML_TOK_PARTIAL;
 427 }
 428
 429 /* ptr points to character following "&#X" */
 430
 431 static int PTRCALL
 432 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
 433                        const char *end, const char **nextTokPtr)
 434 {
 435   if (ptr != end) {
 436     switch (BYTE_TYPE(enc, ptr)) {
 437     case BT_DIGIT:
 438     case BT_HEX:
 439       break;
 440     default:
 441       *nextTokPtr = ptr;
 442       return XML_TOK_INVALID;
 443     }
 444     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
 445       switch (BYTE_TYPE(enc, ptr)) {
 446       case BT_DIGIT:
 447       case BT_HEX:
 448         break;
 449       case BT_SEMI:
 450         *nextTokPtr = ptr + MINBPC(enc);
 451         return XML_TOK_CHAR_REF;
 452       default:
 453         *nextTokPtr = ptr;
 454         return XML_TOK_INVALID;
 455       }
 456     }
 457   }
 458   return XML_TOK_PARTIAL;
 459 }
 460
 461 /* ptr points to character following "&#" */
 462
 463 static int PTRCALL
 464 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
 465                     const char *end, const char **nextTokPtr)
 466 {
 467   if (ptr != end) {
 468     if (CHAR_MATCHES(enc, ptr, ASCII_x))
 469       return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 470     switch (BYTE_TYPE(enc, ptr)) {
 471     case BT_DIGIT:
 472       break;
 473     default:
 474       *nextTokPtr = ptr;
 475       return XML_TOK_INVALID;
 476     }
 477     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
 478       switch (BYTE_TYPE(enc, ptr)) {
 479       case BT_DIGIT:
 480         break;
 481       case BT_SEMI:
 482         *nextTokPtr = ptr + MINBPC(enc);
 483         return XML_TOK_CHAR_REF;
 484       default:
 485         *nextTokPtr = ptr;
 486         return XML_TOK_INVALID;
 487       }
 488     }
 489   }
 490   return XML_TOK_PARTIAL;
 491 }
 492
 493 /* ptr points to character following "&" */
 494
 495 static int PTRCALL
 496 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
 497                 const char **nextTokPtr)
 498 {
 499   if (ptr == end)
 500     return XML_TOK_PARTIAL;
 501   switch (BYTE_TYPE(enc, ptr)) {
 502   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 503   case BT_NUM:
 504     return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 505   default:
 506     *nextTokPtr = ptr;
 507     return XML_TOK_INVALID;
 508   }
 509   while (ptr != end) {
 510     switch (BYTE_TYPE(enc, ptr)) {
 511     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 512     case BT_SEMI:
 513       *nextTokPtr = ptr + MINBPC(enc);
 514       return XML_TOK_ENTITY_REF;
 515     default:
 516       *nextTokPtr = ptr;
 517       return XML_TOK_INVALID;
 518     }
 519   }
 520   return XML_TOK_PARTIAL;
 521 }
 522
 523 /* ptr points to character following first character of attribute name */
 524
 525 static int PTRCALL
 526 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 527                  const char **nextTokPtr)
 528 {
 529 #ifdef XML_NS
 530   int hadColon = 0;
 531 #endif
 532   while (ptr != end) {
 533     switch (BYTE_TYPE(enc, ptr)) {
 534     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 535 #ifdef XML_NS
 536     case BT_COLON:
 537       if (hadColon) {
 538         *nextTokPtr = ptr;
 539         return XML_TOK_INVALID;
 540       }
 541       hadColon = 1;
 542       ptr += MINBPC(enc);
 543       if (ptr == end)
 544         return XML_TOK_PARTIAL;
 545       switch (BYTE_TYPE(enc, ptr)) {
 546       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 547       default:
 548         *nextTokPtr = ptr;
 549         return XML_TOK_INVALID;
 550       }
 551       break;
 552 #endif
 553     case BT_S: case BT_CR: case BT_LF:
 554       for (;;) {
 555         int t;
 556
 557         ptr += MINBPC(enc);
 558         if (ptr == end)
 559           return XML_TOK_PARTIAL;
 560         t = BYTE_TYPE(enc, ptr);
 561         if (t == BT_EQUALS)
 562           break;
 563         switch (t) {
 564         case BT_S:
 565         case BT_LF:
 566         case BT_CR:
 567           break;
 568         default:
 569           *nextTokPtr = ptr;
 570           return XML_TOK_INVALID;
 571         }
 572       }
 573     /* fall through */
 574     case BT_EQUALS:
 575       {
 576         int open;
 577 #ifdef XML_NS
 578         hadColon = 0;
 579 #endif
 580         for (;;) {
 581           ptr += MINBPC(enc);
 582           if (ptr == end)
 583             return XML_TOK_PARTIAL;
 584           open = BYTE_TYPE(enc, ptr);
 585           if (open == BT_QUOT || open == BT_APOS)
 586             break;
 587           switch (open) {
 588           case BT_S:
 589           case BT_LF:
 590           case BT_CR:
 591             break;
 592           default:
 593             *nextTokPtr = ptr;
 594             return XML_TOK_INVALID;
 595           }
 596         }
 597         ptr += MINBPC(enc);
 598         /* in attribute value */
 599         for (;;) {
 600           int t;
 601           if (ptr == end)
 602             return XML_TOK_PARTIAL;
 603           t = BYTE_TYPE(enc, ptr);
 604           if (t == open)
 605             break;
 606           switch (t) {
 607           INVALID_CASES(ptr, nextTokPtr)
 608           case BT_AMP:
 609             {
 610               int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
 611               if (tok <= 0) {
 612                 if (tok == XML_TOK_INVALID)
 613                   *nextTokPtr = ptr;
 614                 return tok;
 615               }
 616               break;
 617             }
 618           case BT_LT:
 619             *nextTokPtr = ptr;
 620             return XML_TOK_INVALID;
 621           default:
 622             ptr += MINBPC(enc);
 623             break;
 624           }
 625         }
 626         ptr += MINBPC(enc);
 627         if (ptr == end)
 628           return XML_TOK_PARTIAL;
 629         switch (BYTE_TYPE(enc, ptr)) {
 630         case BT_S:
 631         case BT_CR:
 632         case BT_LF:
 633           break;
 634         case BT_SOL:
 635           goto sol;
 636         case BT_GT:
 637           goto gt;
 638         default:
 639           *nextTokPtr = ptr;
 640           return XML_TOK_INVALID;
 641         }
 642         /* ptr points to closing quote */
 643         for (;;) {
 644           ptr += MINBPC(enc);
 645           if (ptr == end)
 646             return XML_TOK_PARTIAL;
 647           switch (BYTE_TYPE(enc, ptr)) {
 648           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 649           case BT_S: case BT_CR: case BT_LF:
 650             continue;
 651           case BT_GT:
 652           gt:
 653             *nextTokPtr = ptr + MINBPC(enc);
 654             return XML_TOK_START_TAG_WITH_ATTS;
 655           case BT_SOL:
 656           sol:
 657             ptr += MINBPC(enc);
 658             if (ptr == end)
 659               return XML_TOK_PARTIAL;
 660             if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 661               *nextTokPtr = ptr;
 662               return XML_TOK_INVALID;
 663             }
 664             *nextTokPtr = ptr + MINBPC(enc);
 665             return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
 666           default:
 667             *nextTokPtr = ptr;
 668             return XML_TOK_INVALID;
 669           }
 670           break;
 671         }
 672         break;
 673       }
 674     default:
 675       *nextTokPtr = ptr;
 676       return XML_TOK_INVALID;
 677     }
 678   }
 679   return XML_TOK_PARTIAL;
 680 }
 681
 682 /* ptr points to character following "<" */
 683
 684 static int PTRCALL
 685 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 686                const char **nextTokPtr)
 687 {
 688 #ifdef XML_NS
 689   int hadColon;
 690 #endif
 691   if (ptr == end)
 692     return XML_TOK_PARTIAL;
 693   switch (BYTE_TYPE(enc, ptr)) {
 694   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 695   case BT_EXCL:
 696     if ((ptr += MINBPC(enc)) == end)
 697       return XML_TOK_PARTIAL;
 698     switch (BYTE_TYPE(enc, ptr)) {
 699     case BT_MINUS:
 700       return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 701     case BT_LSQB:
 702       return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
 703                                       end, nextTokPtr);
 704     }
 705     *nextTokPtr = ptr;
 706     return XML_TOK_INVALID;
 707   case BT_QUEST:
 708     return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 709   case BT_SOL:
 710     return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 711   default:
 712     *nextTokPtr = ptr;
 713     return XML_TOK_INVALID;
 714   }
 715 #ifdef XML_NS
 716   hadColon = 0;
 717 #endif
 718   /* we have a start-tag */
 719   while (ptr != end) {
 720     switch (BYTE_TYPE(enc, ptr)) {
 721     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 722 #ifdef XML_NS
 723     case BT_COLON:
 724       if (hadColon) {
 725         *nextTokPtr = ptr;
 726         return XML_TOK_INVALID;
 727       }
 728       hadColon = 1;
 729       ptr += MINBPC(enc);
 730       if (ptr == end)
 731         return XML_TOK_PARTIAL;
 732       switch (BYTE_TYPE(enc, ptr)) {
 733       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 734       default:
 735         *nextTokPtr = ptr;
 736         return XML_TOK_INVALID;
 737       }
 738       break;
 739 #endif
 740     case BT_S: case BT_CR: case BT_LF:
 741       {
 742         ptr += MINBPC(enc);
 743         while (ptr != end) {
 744           switch (BYTE_TYPE(enc, ptr)) {
 745           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 746           case BT_GT:
 747             goto gt;
 748           case BT_SOL:
 749             goto sol;
 750           case BT_S: case BT_CR: case BT_LF:
 751             ptr += MINBPC(enc);
 752             continue;
 753           default:
 754             *nextTokPtr = ptr;
 755             return XML_TOK_INVALID;
 756           }
 757           return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
 758         }
 759         return XML_TOK_PARTIAL;
 760       }
 761     case BT_GT:
 762     gt:
 763       *nextTokPtr = ptr + MINBPC(enc);
 764       return XML_TOK_START_TAG_NO_ATTS;
 765     case BT_SOL:
 766     sol:
 767       ptr += MINBPC(enc);
 768       if (ptr == end)
 769         return XML_TOK_PARTIAL;
 770       if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 771         *nextTokPtr = ptr;
 772         return XML_TOK_INVALID;
 773       }
 774       *nextTokPtr = ptr + MINBPC(enc);
 775       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
 776     default:
 777       *nextTokPtr = ptr;
 778       return XML_TOK_INVALID;
 779     }
 780   }
 781   return XML_TOK_PARTIAL;
 782 }
 783
 784 static int PTRCALL
 785 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
 786                    const char **nextTokPtr)
 787 {
 788   if (ptr == end)
 789     return XML_TOK_NONE;
 790   if (MINBPC(enc) > 1) {
 791     size_t n = end - ptr;
 792     if (n & (MINBPC(enc) - 1)) {
 793       n &= ~(MINBPC(enc) - 1);
 794       if (n == 0)
 795         return XML_TOK_PARTIAL;
 796       end = ptr + n;
 797     }
 798   }
 799   switch (BYTE_TYPE(enc, ptr)) {
 800   case BT_LT:
 801     return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 802   case BT_AMP:
 803     return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 804   case BT_CR:
 805     ptr += MINBPC(enc);
 806     if (ptr == end)
 807       return XML_TOK_TRAILING_CR;
 808     if (BYTE_TYPE(enc, ptr) == BT_LF)
 809       ptr += MINBPC(enc);
 810     *nextTokPtr = ptr;
 811     return XML_TOK_DATA_NEWLINE;
 812   case BT_LF:
 813     *nextTokPtr = ptr + MINBPC(enc);
 814     return XML_TOK_DATA_NEWLINE;
 815   case BT_RSQB:
 816     ptr += MINBPC(enc);
 817     if (ptr == end)
 818       return XML_TOK_TRAILING_RSQB;
 819     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
 820       break;
 821     ptr += MINBPC(enc);
 822     if (ptr == end)
 823       return XML_TOK_TRAILING_RSQB;
 824     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
 825       ptr -= MINBPC(enc);
 826       break;
 827     }
 828     *nextTokPtr = ptr;
 829     return XML_TOK_INVALID;
 830   INVALID_CASES(ptr, nextTokPtr)
 831   default:
 832     ptr += MINBPC(enc);
 833     break;
 834   }
 835   while (ptr != end) {
 836     switch (BYTE_TYPE(enc, ptr)) {
 837 #define LEAD_CASE(n) \
 838     case BT_LEAD ## n: \
 839       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
 840         *nextTokPtr = ptr; \
 841         return XML_TOK_DATA_CHARS; \
 842       } \
 843       ptr += n; \
 844       break;
 845     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 846 #undef LEAD_CASE
 847     case BT_RSQB:
 848       if (ptr + MINBPC(enc) != end) {
 849          if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
 850            ptr += MINBPC(enc);
 851            break;
 852          }
 853          if (ptr + 2*MINBPC(enc) != end) {
 854            if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
 855              ptr += MINBPC(enc);
 856              break;
 857            }
 858            *nextTokPtr = ptr + 2*MINBPC(enc);
 859            return XML_TOK_INVALID;
 860          }
 861       }
 862       /* fall through */
 863     case BT_AMP:
 864     case BT_LT:
 865     case BT_NONXML:
 866     case BT_MALFORM:
 867     case BT_TRAIL:
 868     case BT_CR:
 869     case BT_LF:
 870       *nextTokPtr = ptr;
 871       return XML_TOK_DATA_CHARS;
 872     default:
 873       ptr += MINBPC(enc);
 874       break;
 875     }
 876   }
 877   *nextTokPtr = ptr;
 878   return XML_TOK_DATA_CHARS;
 879 }
 880
 881 /* ptr points to character following "%" */
 882
 883 static int PTRCALL
 884 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
 885                     const char **nextTokPtr)
 886 {
 887   if (ptr == end)
 888     return XML_TOK_PARTIAL;
 889   switch (BYTE_TYPE(enc, ptr)) {
 890   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 891   case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
 892     *nextTokPtr = ptr;
 893     return XML_TOK_PERCENT;
 894   default:
 895     *nextTokPtr = ptr;
 896     return XML_TOK_INVALID;
 897   }
 898   while (ptr != end) {
 899     switch (BYTE_TYPE(enc, ptr)) {
 900     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 901     case BT_SEMI:
 902       *nextTokPtr = ptr + MINBPC(enc);
 903       return XML_TOK_PARAM_ENTITY_REF;
 904     default:
 905       *nextTokPtr = ptr;
 906       return XML_TOK_INVALID;
 907     }
 908   }
 909   return XML_TOK_PARTIAL;
 910 }
 911
 912 static int PTRCALL
 913 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
 914                       const char **nextTokPtr)
 915 {
 916   if (ptr == end)
 917     return XML_TOK_PARTIAL;
 918   switch (BYTE_TYPE(enc, ptr)) {
 919   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
 920   default:
 921     *nextTokPtr = ptr;
 922     return XML_TOK_INVALID;
 923   }
 924   while (ptr != end) {
 925     switch (BYTE_TYPE(enc, ptr)) {
 926     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
 927     case BT_CR: case BT_LF: case BT_S:
 928     case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
 929       *nextTokPtr = ptr;
 930       return XML_TOK_POUND_NAME;
 931     default:
 932       *nextTokPtr = ptr;
 933       return XML_TOK_INVALID;
 934     }
 935   }
 936   return -XML_TOK_POUND_NAME;
 937 }
 938
 939 static int PTRCALL
 940 PREFIX(scanLit)(int open, const ENCODING *enc,
 941                 const char *ptr, const char *end,
 942                 const char **nextTokPtr)
 943 {
 944   while (ptr != end) {
 945     int t = BYTE_TYPE(enc, ptr);
 946     switch (t) {
 947     INVALID_CASES(ptr, nextTokPtr)
 948     case BT_QUOT:
 949     case BT_APOS:
 950       ptr += MINBPC(enc);
 951       if (t != open)
 952         break;
 953       if (ptr == end)
 954         return -XML_TOK_LITERAL;
 955       *nextTokPtr = ptr;
 956       switch (BYTE_TYPE(enc, ptr)) {
 957       case BT_S: case BT_CR: case BT_LF:
 958       case BT_GT: case BT_PERCNT: case BT_LSQB:
 959         return XML_TOK_LITERAL;
 960       default:
 961         return XML_TOK_INVALID;
 962       }
 963     default:
 964       ptr += MINBPC(enc);
 965       break;
 966     }
 967   }
 968   return XML_TOK_PARTIAL;
 969 }
 970
 971 static int PTRCALL
 972 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
 973                   const char **nextTokPtr)
 974 {
 975   int tok;
 976   if (ptr == end)
 977     return XML_TOK_NONE;
 978   if (MINBPC(enc) > 1) {
 979     size_t n = end - ptr;
 980     if (n & (MINBPC(enc) - 1)) {
 981       n &= ~(MINBPC(enc) - 1);
 982       if (n == 0)
 983         return XML_TOK_PARTIAL;
 984       end = ptr + n;
 985     }
 986   }
 987   switch (BYTE_TYPE(enc, ptr)) {
 988   case BT_QUOT:
 989     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
 990   case BT_APOS:
 991     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
 992   case BT_LT:
 993     {
 994       ptr += MINBPC(enc);
 995       if (ptr == end)
 996         return XML_TOK_PARTIAL;
 997       switch (BYTE_TYPE(enc, ptr)) {
 998       case BT_EXCL:
 999         return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1000       case BT_QUEST:
1001         return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1002       case BT_NMSTRT:
1003       case BT_HEX:
1004       case BT_NONASCII:
1005       case BT_LEAD2:
1006       case BT_LEAD3:
1007       case BT_LEAD4:
1008         *nextTokPtr = ptr - MINBPC(enc);
1009         return XML_TOK_INSTANCE_START;
1010       }
1011       *nextTokPtr = ptr;
1012       return XML_TOK_INVALID;
1013     }
1014   case BT_CR:
1015     if (ptr + MINBPC(enc) == end) {
1016       *nextTokPtr = end;
1017       /* indicate that this might be part of a CR/LF pair */
1018       return -XML_TOK_PROLOG_S;
1019     }
1020     /* fall through */
1021   case BT_S: case BT_LF:
1022     for (;;) {
1023       ptr += MINBPC(enc);
1024       if (ptr == end)
1025         break;
1026       switch (BYTE_TYPE(enc, ptr)) {
1027       case BT_S: case BT_LF:
1028         break;
1029       case BT_CR:
1030         /* don't split CR/LF pair */
1031         if (ptr + MINBPC(enc) != end)
1032           break;
1033         /* fall through */
1034       default:
1035         *nextTokPtr = ptr;
1036         return XML_TOK_PROLOG_S;
1037       }
1038     }
1039     *nextTokPtr = ptr;
1040     return XML_TOK_PROLOG_S;
1041   case BT_PERCNT:
1042     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1043   case BT_COMMA:
1044     *nextTokPtr = ptr + MINBPC(enc);
1045     return XML_TOK_COMMA;
1046   case BT_LSQB:
1047     *nextTokPtr = ptr + MINBPC(enc);
1048     return XML_TOK_OPEN_BRACKET;
1049   case BT_RSQB:
1050     ptr += MINBPC(enc);
1051     if (ptr == end)
1052       return -XML_TOK_CLOSE_BRACKET;
1053     if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1054       if (ptr + MINBPC(enc) == end)
1055         return XML_TOK_PARTIAL;
1056       if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1057         *nextTokPtr = ptr + 2*MINBPC(enc);
1058         return XML_TOK_COND_SECT_CLOSE;
1059       }
1060     }
1061     *nextTokPtr = ptr;
1062     return XML_TOK_CLOSE_BRACKET;
1063   case BT_LPAR:
1064     *nextTokPtr = ptr + MINBPC(enc);
1065     return XML_TOK_OPEN_PAREN;
1066   case BT_RPAR:
1067     ptr += MINBPC(enc);
1068     if (ptr == end)
1069       return -XML_TOK_CLOSE_PAREN;
1070     switch (BYTE_TYPE(enc, ptr)) {
1071     case BT_AST:
1072       *nextTokPtr = ptr + MINBPC(enc);
1073       return XML_TOK_CLOSE_PAREN_ASTERISK;
1074     case BT_QUEST:
1075       *nextTokPtr = ptr + MINBPC(enc);
1076       return XML_TOK_CLOSE_PAREN_QUESTION;
1077     case BT_PLUS:
1078       *nextTokPtr = ptr + MINBPC(enc);
1079       return XML_TOK_CLOSE_PAREN_PLUS;
1080     case BT_CR: case BT_LF: case BT_S:
1081     case BT_GT: case BT_COMMA: case BT_VERBAR:
1082     case BT_RPAR:
1083       *nextTokPtr = ptr;
1084       return XML_TOK_CLOSE_PAREN;
1085     }
1086     *nextTokPtr = ptr;
1087     return XML_TOK_INVALID;
1088   case BT_VERBAR:
1089     *nextTokPtr = ptr + MINBPC(enc);
1090     return XML_TOK_OR;
1091   case BT_GT:
1092     *nextTokPtr = ptr + MINBPC(enc);
1093     return XML_TOK_DECL_CLOSE;
1094   case BT_NUM:
1095     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1096 #define LEAD_CASE(n) \
1097   case BT_LEAD ## n: \
1098     if (end - ptr < n) \
1099       return XML_TOK_PARTIAL_CHAR; \
1100     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1101       ptr += n; \
1102       tok = XML_TOK_NAME; \
1103       break; \
1104     } \
1105     if (IS_NAME_CHAR(enc, ptr, n)) { \
1106       ptr += n; \
1107       tok = XML_TOK_NMTOKEN; \
1108       break; \
1109     } \
1110     *nextTokPtr = ptr; \
1111     return XML_TOK_INVALID;
1112     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1113 #undef LEAD_CASE
1114   case BT_NMSTRT:
1115   case BT_HEX:
1116     tok = XML_TOK_NAME;
1117     ptr += MINBPC(enc);
1118     break;
1119   case BT_DIGIT:
1120   case BT_NAME:
1121   case BT_MINUS:
1122 #ifdef XML_NS
1123   case BT_COLON:
1124 #endif
1125     tok = XML_TOK_NMTOKEN;
1126     ptr += MINBPC(enc);
1127     break;
1128   case BT_NONASCII:
1129     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1130       ptr += MINBPC(enc);
1131       tok = XML_TOK_NAME;
1132       break;
1133     }
1134     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1135       ptr += MINBPC(enc);
1136       tok = XML_TOK_NMTOKEN;
1137       break;
1138     }
1139     /* fall through */
1140   default:
1141     *nextTokPtr = ptr;
1142     return XML_TOK_INVALID;
1143   }
1144   while (ptr != end) {
1145     switch (BYTE_TYPE(enc, ptr)) {
1146     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1147     case BT_GT: case BT_RPAR: case BT_COMMA:
1148     case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
1149     case BT_S: case BT_CR: case BT_LF:
1150       *nextTokPtr = ptr;
1151       return tok;
1152 #ifdef XML_NS
1153     case BT_COLON:
1154       ptr += MINBPC(enc);
1155       switch (tok) {
1156       case XML_TOK_NAME:
1157         if (ptr == end)
1158           return XML_TOK_PARTIAL;
1159         tok = XML_TOK_PREFIXED_NAME;
1160         switch (BYTE_TYPE(enc, ptr)) {
1161         CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1162         default:
1163           tok = XML_TOK_NMTOKEN;
1164           break;
1165         }
1166         break;
1167       case XML_TOK_PREFIXED_NAME:
1168         tok = XML_TOK_NMTOKEN;
1169         break;
1170       }
1171       break;
1172 #endif
1173     case BT_PLUS:
1174       if (tok == XML_TOK_NMTOKEN)  {
1175         *nextTokPtr = ptr;
1176         return XML_TOK_INVALID;
1177       }
1178       *nextTokPtr = ptr + MINBPC(enc);
1179       return XML_TOK_NAME_PLUS;
1180     case BT_AST:
1181       if (tok == XML_TOK_NMTOKEN)  {
1182         *nextTokPtr = ptr;
1183         return XML_TOK_INVALID;
1184       }
1185       *nextTokPtr = ptr + MINBPC(enc);
1186       return XML_TOK_NAME_ASTERISK;
1187     case BT_QUEST:
1188       if (tok == XML_TOK_NMTOKEN)  {
1189         *nextTokPtr = ptr;
1190         return XML_TOK_INVALID;
1191       }
1192       *nextTokPtr = ptr + MINBPC(enc);
1193       return XML_TOK_NAME_QUESTION;
1194     default:
1195       *nextTokPtr = ptr;
1196       return XML_TOK_INVALID;
1197     }
1198   }
1199   return -tok;
1200 }
1201
1202 static int PTRCALL
1203 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1204                           const char *end, const char **nextTokPtr)
1205 {
1206   const char *start;
1207   if (ptr == end)
1208     return XML_TOK_NONE;
1209   start = ptr;
1210   while (ptr != end) {
1211     switch (BYTE_TYPE(enc, ptr)) {
1212 #define LEAD_CASE(n) \
1213     case BT_LEAD ## n: ptr += n; break;
1214     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1215 #undef LEAD_CASE
1216     case BT_AMP:
1217       if (ptr == start)
1218         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1219       *nextTokPtr = ptr;
1220       return XML_TOK_DATA_CHARS;
1221     case BT_LT:
1222       /* this is for inside entity references */
1223       *nextTokPtr = ptr;
1224       return XML_TOK_INVALID;
1225     case BT_LF:
1226       if (ptr == start) {
1227         *nextTokPtr = ptr + MINBPC(enc);
1228         return XML_TOK_DATA_NEWLINE;
1229       }
1230       *nextTokPtr = ptr;
1231       return XML_TOK_DATA_CHARS;
1232     case BT_CR:
1233       if (ptr == start) {
1234         ptr += MINBPC(enc);
1235         if (ptr == end)
1236           return XML_TOK_TRAILING_CR;
1237         if (BYTE_TYPE(enc, ptr) == BT_LF)
1238           ptr += MINBPC(enc);
1239         *nextTokPtr = ptr;
1240         return XML_TOK_DATA_NEWLINE;
1241       }
1242       *nextTokPtr = ptr;
1243       return XML_TOK_DATA_CHARS;
1244     case BT_S:
1245       if (ptr == start) {
1246         *nextTokPtr = ptr + MINBPC(enc);
1247         return XML_TOK_ATTRIBUTE_VALUE_S;
1248       }
1249       *nextTokPtr = ptr;
1250       return XML_TOK_DATA_CHARS;
1251     default:
1252       ptr += MINBPC(enc);
1253       break;
1254     }
1255   }
1256   *nextTokPtr = ptr;
1257   return XML_TOK_DATA_CHARS;
1258 }
1259
1260 static int PTRCALL
1261 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1262                        const char *end, const char **nextTokPtr)
1263 {
1264   const char *start;
1265   if (ptr == end)
1266     return XML_TOK_NONE;
1267   start = ptr;
1268   while (ptr != end) {
1269     switch (BYTE_TYPE(enc, ptr)) {
1270 #define LEAD_CASE(n) \
1271     case BT_LEAD ## n: ptr += n; break;
1272     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1273 #undef LEAD_CASE
1274     case BT_AMP:
1275       if (ptr == start)
1276         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1277       *nextTokPtr = ptr;
1278       return XML_TOK_DATA_CHARS;
1279     case BT_PERCNT:
1280       if (ptr == start) {
1281         int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
1282                                        end, nextTokPtr);
1283         return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
1284       }
1285       *nextTokPtr = ptr;
1286       return XML_TOK_DATA_CHARS;
1287     case BT_LF:
1288       if (ptr == start) {
1289         *nextTokPtr = ptr + MINBPC(enc);
1290         return XML_TOK_DATA_NEWLINE;
1291       }
1292       *nextTokPtr = ptr;
1293       return XML_TOK_DATA_CHARS;
1294     case BT_CR:
1295       if (ptr == start) {
1296         ptr += MINBPC(enc);
1297         if (ptr == end)
1298           return XML_TOK_TRAILING_CR;
1299         if (BYTE_TYPE(enc, ptr) == BT_LF)
1300           ptr += MINBPC(enc);
1301         *nextTokPtr = ptr;
1302         return XML_TOK_DATA_NEWLINE;
1303       }
1304       *nextTokPtr = ptr;
1305       return XML_TOK_DATA_CHARS;
1306     default:
1307       ptr += MINBPC(enc);
1308       break;
1309     }
1310   }
1311   *nextTokPtr = ptr;
1312   return XML_TOK_DATA_CHARS;
1313 }
1314
1315 #ifdef XML_DTD
1316
1317 static int PTRCALL
1318 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1319                          const char *end, const char **nextTokPtr)
1320 {
1321   int level = 0;
1322   if (MINBPC(enc) > 1) {
1323     size_t n = end - ptr;
1324     if (n & (MINBPC(enc) - 1)) {
1325       n &= ~(MINBPC(enc) - 1);
1326       end = ptr + n;
1327     }
1328   }
1329   while (ptr != end) {
1330     switch (BYTE_TYPE(enc, ptr)) {
1331     INVALID_CASES(ptr, nextTokPtr)
1332     case BT_LT:
1333       if ((ptr += MINBPC(enc)) == end)
1334         return XML_TOK_PARTIAL;
1335       if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1336         if ((ptr += MINBPC(enc)) == end)
1337           return XML_TOK_PARTIAL;
1338         if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1339           ++level;
1340           ptr += MINBPC(enc);
1341         }
1342       }
1343       break;
1344     case BT_RSQB:
1345       if ((ptr += MINBPC(enc)) == end)
1346         return XML_TOK_PARTIAL;
1347       if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1348         if ((ptr += MINBPC(enc)) == end)
1349           return XML_TOK_PARTIAL;
1350         if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1351           ptr += MINBPC(enc);
1352           if (level == 0) {
1353             *nextTokPtr = ptr;
1354             return XML_TOK_IGNORE_SECT;
1355           }
1356           --level;
1357         }
1358       }
1359       break;
1360     default:
1361       ptr += MINBPC(enc);
1362       break;
1363     }
1364   }
1365   return XML_TOK_PARTIAL;
1366 }
1367
1368 #endif /* XML_DTD */
1369
1370 static int PTRCALL
1371 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1372                    const char **badPtr)
1373 {
1374   ptr += MINBPC(enc);
1375   end -= MINBPC(enc);
1376   for (; ptr != end; ptr += MINBPC(enc)) {
1377     switch (BYTE_TYPE(enc, ptr)) {
1378     case BT_DIGIT:
1379     case BT_HEX:
1380     case BT_MINUS:
1381     case BT_APOS:
1382     case BT_LPAR:
1383     case BT_RPAR:
1384     case BT_PLUS:
1385     case BT_COMMA:
1386     case BT_SOL:
1387     case BT_EQUALS:
1388     case BT_QUEST:
1389     case BT_CR:
1390     case BT_LF:
1391     case BT_SEMI:
1392     case BT_EXCL:
1393     case BT_AST:
1394     case BT_PERCNT:
1395     case BT_NUM:
1396 #ifdef XML_NS
1397     case BT_COLON:
1398 #endif
1399       break;
1400     case BT_S:
1401       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1402         *badPtr = ptr;
1403         return 0;
1404       }
1405       break;
1406     case BT_NAME:
1407     case BT_NMSTRT:
1408       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1409         break;
1410     default:
1411       switch (BYTE_TO_ASCII(enc, ptr)) {
1412       case 0x24: /* $ */
1413       case 0x40: /* @ */
1414         break;
1415       default:
1416         *badPtr = ptr;
1417         return 0;
1418       }
1419       break;
1420     }
1421   }
1422   return 1;
1423 }
1424
1425 /* This must only be called for a well-formed start-tag or empty
1426    element tag.  Returns the number of attributes.  Pointers to the
1427    first attsMax attributes are stored in atts.
1428 */
1429
1430 static int PTRCALL
1431 PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1432                 int attsMax, ATTRIBUTE *atts)
1433 {
1434   enum { other, inName, inValue } state = inName;
1435   int nAtts = 0;
1436   int open = 0; /* defined when state == inValue;
1437                    initialization just to shut up compilers */
1438
1439   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1440     switch (BYTE_TYPE(enc, ptr)) {
1441 #define START_NAME \
1442       if (state == other) { \
1443         if (nAtts < attsMax) { \
1444           atts[nAtts].name = ptr; \
1445           atts[nAtts].normalized = 1; \
1446         } \
1447         state = inName; \
1448       }
1449 #define LEAD_CASE(n) \
1450     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
1451     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1452 #undef LEAD_CASE
1453     case BT_NONASCII:
1454     case BT_NMSTRT:
1455     case BT_HEX:
1456       START_NAME
1457       break;
1458 #undef START_NAME
1459     case BT_QUOT:
1460       if (state != inValue) {
1461         if (nAtts < attsMax)
1462           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1463         state = inValue;
1464         open = BT_QUOT;
1465       }
1466       else if (open == BT_QUOT) {
1467         state = other;
1468         if (nAtts < attsMax)
1469           atts[nAtts].valueEnd = ptr;
1470         nAtts++;
1471       }
1472       break;
1473     case BT_APOS:
1474       if (state != inValue) {
1475         if (nAtts < attsMax)
1476           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1477         state = inValue;
1478         open = BT_APOS;
1479       }
1480       else if (open == BT_APOS) {
1481         state = other;
1482         if (nAtts < attsMax)
1483           atts[nAtts].valueEnd = ptr;
1484         nAtts++;
1485       }
1486       break;
1487     case BT_AMP:
1488       if (nAtts < attsMax)
1489         atts[nAtts].normalized = 0;
1490       break;
1491     case BT_S:
1492       if (state == inName)
1493         state = other;
1494       else if (state == inValue
1495                && nAtts < attsMax
1496                && atts[nAtts].normalized
1497                && (ptr == atts[nAtts].valuePtr
1498                    || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
1499                    || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
1500                    || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
1501         atts[nAtts].normalized = 0;
1502       break;
1503     case BT_CR: case BT_LF:
1504       /* This case ensures that the first attribute name is counted
1505          Apart from that we could just change state on the quote. */
1506       if (state == inName)
1507         state = other;
1508       else if (state == inValue && nAtts < attsMax)
1509         atts[nAtts].normalized = 0;
1510       break;
1511     case BT_GT:
1512     case BT_SOL:
1513       if (state != inValue)
1514         return nAtts;
1515       break;
1516     default:
1517       break;
1518     }
1519   }
1520   /* not reached */
1521 }
1522
1523 static int PTRFASTCALL
1524 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
1525 {
1526   int result = 0;
1527   /* skip &# */
1528   ptr += 2*MINBPC(enc);
1529   if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1530     for (ptr += MINBPC(enc);
1531          !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
1532          ptr += MINBPC(enc)) {
1533       int c = BYTE_TO_ASCII(enc, ptr);
1534       switch (c) {
1535       case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
1536       case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
1537         result <<= 4;
1538         result |= (c - ASCII_0);
1539         break;
1540       case ASCII_A: case ASCII_B: case ASCII_C:
1541       case ASCII_D: case ASCII_E: case ASCII_F:
1542         result <<= 4;
1543         result += 10 + (c - ASCII_A);
1544         break;
1545       case ASCII_a: case ASCII_b: case ASCII_c:
1546       case ASCII_d: case ASCII_e: case ASCII_f:
1547         result <<= 4;
1548         result += 10 + (c - ASCII_a);
1549         break;
1550       }
1551       if (result >= 0x110000)
1552         return -1;
1553     }
1554   }
1555   else {
1556     for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1557       int c = BYTE_TO_ASCII(enc, ptr);
1558       result *= 10;
1559       result += (c - ASCII_0);
1560       if (result >= 0x110000)
1561         return -1;
1562     }
1563   }
1564   return checkCharRefNumber(result);
1565 }
1566
1567 static int PTRCALL
1568 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1569                              const char *end)
1570 {
1571   switch ((end - ptr)/MINBPC(enc)) {
1572   case 2:
1573     if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1574       switch (BYTE_TO_ASCII(enc, ptr)) {
1575       case ASCII_l:
1576         return ASCII_LT;
1577       case ASCII_g:
1578         return ASCII_GT;
1579       }
1580     }
1581     break;
1582   case 3:
1583     if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
1584       ptr += MINBPC(enc);
1585       if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
1586         ptr += MINBPC(enc);
1587         if (CHAR_MATCHES(enc, ptr, ASCII_p))
1588           return ASCII_AMP;
1589       }
1590     }
1591     break;
1592   case 4:
1593     switch (BYTE_TO_ASCII(enc, ptr)) {
1594     case ASCII_q:
1595       ptr += MINBPC(enc);
1596       if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
1597         ptr += MINBPC(enc);
1598         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1599           ptr += MINBPC(enc);
1600           if (CHAR_MATCHES(enc, ptr, ASCII_t))
1601             return ASCII_QUOT;
1602         }
1603       }
1604       break;
1605     case ASCII_a:
1606       ptr += MINBPC(enc);
1607       if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
1608         ptr += MINBPC(enc);
1609         if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1610           ptr += MINBPC(enc);
1611           if (CHAR_MATCHES(enc, ptr, ASCII_s))
1612             return ASCII_APOS;
1613         }
1614       }
1615       break;
1616     }
1617   }
1618   return 0;
1619 }
1620
1621 static int PTRCALL
1622 PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
1623 {
1624   for (;;) {
1625     switch (BYTE_TYPE(enc, ptr1)) {
1626 #define LEAD_CASE(n) \
1627     case BT_LEAD ## n: \
1628       if (*ptr1++ != *ptr2++) \
1629         return 0;
1630     LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
1631 #undef LEAD_CASE
1632       /* fall through */
1633       if (*ptr1++ != *ptr2++)
1634         return 0;
1635       break;
1636     case BT_NONASCII:
1637     case BT_NMSTRT:
1638 #ifdef XML_NS
1639     case BT_COLON:
1640 #endif
1641     case BT_HEX:
1642     case BT_DIGIT:
1643     case BT_NAME:
1644     case BT_MINUS:
1645       if (*ptr2++ != *ptr1++)
1646         return 0;
1647       if (MINBPC(enc) > 1) {
1648         if (*ptr2++ != *ptr1++)
1649           return 0;
1650         if (MINBPC(enc) > 2) {
1651           if (*ptr2++ != *ptr1++)
1652             return 0;
1653           if (MINBPC(enc) > 3) {
1654             if (*ptr2++ != *ptr1++)
1655               return 0;
1656           }
1657         }
1658       }
1659       break;
1660     default:
1661       if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
1662         return 1;
1663       switch (BYTE_TYPE(enc, ptr2)) {
1664       case BT_LEAD2:
1665       case BT_LEAD3:
1666       case BT_LEAD4:
1667       case BT_NONASCII:
1668       case BT_NMSTRT:
1669 #ifdef XML_NS
1670       case BT_COLON:
1671 #endif
1672       case BT_HEX:
1673       case BT_DIGIT:
1674       case BT_NAME:
1675       case BT_MINUS:
1676         return 0;
1677       default:
1678         return 1;
1679       }
1680     }
1681   }
1682   /* not reached */
1683 }
1684
1685 static int PTRCALL
1686 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1687                          const char *end1, const char *ptr2)
1688 {
1689   for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1690     if (ptr1 == end1)
1691       return 0;
1692     if (!CHAR_MATCHES(enc, ptr1, *ptr2))
1693       return 0;
1694   }
1695   return ptr1 == end1;
1696 }
1697
1698 static int PTRFASTCALL
1699 PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1700 {
1701   const char *start = ptr;
1702   for (;;) {
1703     switch (BYTE_TYPE(enc, ptr)) {
1704 #define LEAD_CASE(n) \
1705     case BT_LEAD ## n: ptr += n; break;
1706     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1707 #undef LEAD_CASE
1708     case BT_NONASCII:
1709     case BT_NMSTRT:
1710 #ifdef XML_NS
1711     case BT_COLON:
1712 #endif
1713     case BT_HEX:
1714     case BT_DIGIT:
1715     case BT_NAME:
1716     case BT_MINUS:
1717       ptr += MINBPC(enc);
1718       break;
1719     default:
1720       return (int)(ptr - start);
1721     }
1722   }
1723 }
1724
1725 static const char * PTRFASTCALL
1726 PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1727 {
1728   for (;;) {
1729     switch (BYTE_TYPE(enc, ptr)) {
1730     case BT_LF:
1731     case BT_CR:
1732     case BT_S:
1733       ptr += MINBPC(enc);
1734       break;
1735     default:
1736       return ptr;
1737     }
1738   }
1739 }
1740
1741 static void PTRCALL
1742 PREFIX(updatePosition)(const ENCODING *enc,
1743                        const char *ptr,
1744                        const char *end,
1745                        POSITION *pos)
1746 {
1747   while (ptr < end) {
1748     switch (BYTE_TYPE(enc, ptr)) {
1749 #define LEAD_CASE(n) \
1750     case BT_LEAD ## n: \
1751       ptr += n; \
1752       break;
1753     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
1754 #undef LEAD_CASE
1755     case BT_LF:
1756       pos->columnNumber = (XML_Size)-1;
1757       pos->lineNumber++;
1758       ptr += MINBPC(enc);
1759       break;
1760     case BT_CR:
1761       pos->lineNumber++;
1762       ptr += MINBPC(enc);
1763       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
1764         ptr += MINBPC(enc);
1765       pos->columnNumber = (XML_Size)-1;
1766       break;
1767     default:
1768       ptr += MINBPC(enc);
1769       break;
1770     }
1771     pos->columnNumber++;
1772   }
1773 }
1774
1775 #undef DO_LEAD_CASE
1776 #undef MULTIBYTE_CASES
1777 #undef INVALID_CASES
1778 #undef CHECK_NAME_CASE
1779 #undef CHECK_NAME_CASES
1780 #undef CHECK_NMSTRT_CASE
1781 #undef CHECK_NMSTRT_CASES
1782
1783 #endif /* XML_TOK_IMPL_C */