| OLD | NEW |
|---|
| (Empty) |
| 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 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2761253002:
Update expat to 2.2.0 to fix CVE vulnerability. (Closed)
