Annotation of embedaddon/expat/lib/xmltok_impl.c, revision 1.1
1.1 ! misho 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_PERCENT;
! 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 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to xmltok_impl.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / expat / lib