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