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 1780
