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