Lines Matching refs:enc
9 #define IS_INVALID_CHAR(enc, ptr, n) (0)
16 if (IS_INVALID_CHAR(enc, ptr, n)) { \
33 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
37 if (!IS_NAME_CHAR(enc, ptr, n)) { \
44 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
46 if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
55 ptr += MINBPC(enc); \
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)
61 #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
65 if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
72 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
74 if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
80 ptr += MINBPC(enc); \
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)
93 PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
97 if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
101 ptr += MINBPC(enc);
103 switch (BYTE_TYPE(enc, ptr)) {
106 if ((ptr += MINBPC(enc)) == end)
108 if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
109 if ((ptr += MINBPC(enc)) == end)
111 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
115 *nextTokPtr = ptr + MINBPC(enc);
120 ptr += MINBPC(enc);
131 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
136 switch (BYTE_TYPE(enc, ptr)) {
138 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
140 *nextTokPtr = ptr + MINBPC(enc);
144 ptr += MINBPC(enc);
151 switch (BYTE_TYPE(enc, ptr)) {
153 if (ptr + MINBPC(enc) == end)
156 switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
167 ptr += MINBPC(enc);
178 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
183 if (end - ptr != MINBPC(enc)*3)
185 switch (BYTE_TO_ASCII(enc, ptr)) {
194 ptr += MINBPC(enc);
195 switch (BYTE_TO_ASCII(enc, ptr)) {
204 ptr += MINBPC(enc);
205 switch (BYTE_TO_ASCII(enc, ptr)) {
223 PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
230 switch (BYTE_TYPE(enc, ptr)) {
231 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
237 switch (BYTE_TYPE(enc, ptr)) {
238 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
240 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
244 ptr += MINBPC(enc);
246 switch (BYTE_TYPE(enc, ptr)) {
249 ptr += MINBPC(enc);
252 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
253 *nextTokPtr = ptr + MINBPC(enc);
258 ptr += MINBPC(enc);
264 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
268 ptr += MINBPC(enc);
271 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
272 *nextTokPtr = ptr + MINBPC(enc);
285 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
292 if (end - ptr < 6 * MINBPC(enc))
294 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
295 if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
305 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
310 if (MINBPC(enc) > 1) {
312 if (n & (MINBPC(enc) - 1)) {
313 n &= ~(MINBPC(enc) - 1);
319 switch (BYTE_TYPE(enc, ptr)) {
321 ptr += MINBPC(enc);
324 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
326 ptr += MINBPC(enc);
329 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
330 ptr -= MINBPC(enc);
333 *nextTokPtr = ptr + MINBPC(enc);
336 ptr += MINBPC(enc);
339 if (BYTE_TYPE(enc, ptr) == BT_LF)
340 ptr += MINBPC(enc);
344 *nextTokPtr = ptr + MINBPC(enc);
348 ptr += MINBPC(enc);
352 switch (BYTE_TYPE(enc, ptr)) {
355 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
372 ptr += MINBPC(enc);
383 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
388 switch (BYTE_TYPE(enc, ptr)) {
389 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
395 switch (BYTE_TYPE(enc, ptr)) {
396 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
398 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
399 switch (BYTE_TYPE(enc, ptr)) {
403 *nextTokPtr = ptr + MINBPC(enc);
415 ptr += MINBPC(enc);
419 *nextTokPtr = ptr + MINBPC(enc);
432 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
436 switch (BYTE_TYPE(enc, ptr)) {
444 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
445 switch (BYTE_TYPE(enc, ptr)) {
450 *nextTokPtr = ptr + MINBPC(enc);
464 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
468 if (CHAR_MATCHES(enc, ptr, ASCII_x))
469 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
470 switch (BYTE_TYPE(enc, ptr)) {
477 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
478 switch (BYTE_TYPE(enc, ptr)) {
482 *nextTokPtr = ptr + MINBPC(enc);
496 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
501 switch (BYTE_TYPE(enc, ptr)) {
502 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
504 return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
510 switch (BYTE_TYPE(enc, ptr)) {
511 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
513 *nextTokPtr = ptr + MINBPC(enc);
526 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
533 switch (BYTE_TYPE(enc, ptr)) {
534 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
542 ptr += MINBPC(enc);
545 switch (BYTE_TYPE(enc, ptr)) {
546 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
557 ptr += MINBPC(enc);
560 t = BYTE_TYPE(enc, ptr);
581 ptr += MINBPC(enc);
584 open = BYTE_TYPE(enc, ptr);
597 ptr += MINBPC(enc);
603 t = BYTE_TYPE(enc, ptr);
610 int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
622 ptr += MINBPC(enc);
626 ptr += MINBPC(enc);
629 switch (BYTE_TYPE(enc, ptr)) {
644 ptr += MINBPC(enc);
647 switch (BYTE_TYPE(enc, ptr)) {
648 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
653 *nextTokPtr = ptr + MINBPC(enc);
657 ptr += MINBPC(enc);
660 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
664 *nextTokPtr = ptr + MINBPC(enc);
685 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
693 switch (BYTE_TYPE(enc, ptr)) {
694 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
696 if ((ptr += MINBPC(enc)) == end)
698 switch (BYTE_TYPE(enc, ptr)) {
700 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
702 return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
708 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
710 return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
720 switch (BYTE_TYPE(enc, ptr)) {
721 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
729 ptr += MINBPC(enc);
732 switch (BYTE_TYPE(enc, ptr)) {
733 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
742 ptr += MINBPC(enc);
744 switch (BYTE_TYPE(enc, ptr)) {
745 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
751 ptr += MINBPC(enc);
757 return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
763 *nextTokPtr = ptr + MINBPC(enc);
767 ptr += MINBPC(enc);
770 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
774 *nextTokPtr = ptr + MINBPC(enc);
785 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
790 if (MINBPC(enc) > 1) {
792 if (n & (MINBPC(enc) - 1)) {
793 n &= ~(MINBPC(enc) - 1);
799 switch (BYTE_TYPE(enc, ptr)) {
801 return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
803 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
805 ptr += MINBPC(enc);
808 if (BYTE_TYPE(enc, ptr) == BT_LF)
809 ptr += MINBPC(enc);
813 *nextTokPtr = ptr + MINBPC(enc);
816 ptr += MINBPC(enc);
819 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
821 ptr += MINBPC(enc);
824 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
825 ptr -= MINBPC(enc);
832 ptr += MINBPC(enc);
836 switch (BYTE_TYPE(enc, ptr)) {
839 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
848 if (ptr + MINBPC(enc) != end) {
849 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
850 ptr += MINBPC(enc);
853 if (ptr + 2*MINBPC(enc) != end) {
854 if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
855 ptr += MINBPC(enc);
858 *nextTokPtr = ptr + 2*MINBPC(enc);
873 ptr += MINBPC(enc);
884 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
889 switch (BYTE_TYPE(enc, ptr)) {
890 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
899 switch (BYTE_TYPE(enc, ptr)) {
900 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
902 *nextTokPtr = ptr + MINBPC(enc);
913 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
918 switch (BYTE_TYPE(enc, ptr)) {
919 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
925 switch (BYTE_TYPE(enc, ptr)) {
926 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
940 PREFIX(scanLit)(int open, const ENCODING *enc,
945 int t = BYTE_TYPE(enc, ptr);
950 ptr += MINBPC(enc);
956 switch (BYTE_TYPE(enc, ptr)) {
964 ptr += MINBPC(enc);
972 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
978 if (MINBPC(enc) > 1) {
980 if (n & (MINBPC(enc) - 1)) {
981 n &= ~(MINBPC(enc) - 1);
987 switch (BYTE_TYPE(enc, ptr)) {
989 return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
991 return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
994 ptr += MINBPC(enc);
997 switch (BYTE_TYPE(enc, ptr)) {
999 return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1001 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1008 *nextTokPtr = ptr - MINBPC(enc);
1015 if (ptr + MINBPC(enc) == end) {
1023 ptr += MINBPC(enc);
1026 switch (BYTE_TYPE(enc, ptr)) {
1031 if (ptr + MINBPC(enc) != end)
1042 return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1044 *nextTokPtr = ptr + MINBPC(enc);
1047 *nextTokPtr = ptr + MINBPC(enc);
1050 ptr += MINBPC(enc);
1053 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1054 if (ptr + MINBPC(enc) == end)
1056 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1057 *nextTokPtr = ptr + 2*MINBPC(enc);
1064 *nextTokPtr = ptr + MINBPC(enc);
1067 ptr += MINBPC(enc);
1070 switch (BYTE_TYPE(enc, ptr)) {
1072 *nextTokPtr = ptr + MINBPC(enc);
1075 *nextTokPtr = ptr + MINBPC(enc);
1078 *nextTokPtr = ptr + MINBPC(enc);
1089 *nextTokPtr = ptr + MINBPC(enc);
1092 *nextTokPtr = ptr + MINBPC(enc);
1095 return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1100 if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1105 if (IS_NAME_CHAR(enc, ptr, n)) { \
1117 ptr += MINBPC(enc);
1126 ptr += MINBPC(enc);
1129 if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1130 ptr += MINBPC(enc);
1134 if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1135 ptr += MINBPC(enc);
1145 switch (BYTE_TYPE(enc, ptr)) {
1146 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1154 ptr += MINBPC(enc);
1160 switch (BYTE_TYPE(enc, ptr)) {
1161 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1178 *nextTokPtr = ptr + MINBPC(enc);
1185 *nextTokPtr = ptr + MINBPC(enc);
1192 *nextTokPtr = ptr + MINBPC(enc);
1203 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1211 switch (BYTE_TYPE(enc, ptr)) {
1218 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1227 *nextTokPtr = ptr + MINBPC(enc);
1234 ptr += MINBPC(enc);
1237 if (BYTE_TYPE(enc, ptr) == BT_LF)
1238 ptr += MINBPC(enc);
1246 *nextTokPtr = ptr + MINBPC(enc);
1252 ptr += MINBPC(enc);
1261 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1269 switch (BYTE_TYPE(enc, ptr)) {
1276 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1281 int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
1289 *nextTokPtr = ptr + MINBPC(enc);
1296 ptr += MINBPC(enc);
1299 if (BYTE_TYPE(enc, ptr) == BT_LF)
1300 ptr += MINBPC(enc);
1307 ptr += MINBPC(enc);
1318 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1322 if (MINBPC(enc) > 1) {
1324 if (n & (MINBPC(enc) - 1)) {
1325 n &= ~(MINBPC(enc) - 1);
1330 switch (BYTE_TYPE(enc, ptr)) {
1333 if ((ptr += MINBPC(enc)) == end)
1335 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1336 if ((ptr += MINBPC(enc)) == end)
1338 if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1340 ptr += MINBPC(enc);
1345 if ((ptr += MINBPC(enc)) == end)
1347 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1348 if ((ptr += MINBPC(enc)) == end)
1350 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1351 ptr += MINBPC(enc);
1361 ptr += MINBPC(enc);
1371 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1374 ptr += MINBPC(enc);
1375 end -= MINBPC(enc);
1376 for (; ptr != end; ptr += MINBPC(enc)) {
1377 switch (BYTE_TYPE(enc, ptr)) {
1401 if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1408 if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1411 switch (BYTE_TO_ASCII(enc, ptr)) {
1431 PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1439 for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1440 switch (BYTE_TYPE(enc, ptr)) {
1450 case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
1462 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1476 atts[nAtts].valuePtr = ptr + MINBPC(enc);
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))
1524 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
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);
1556 for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1557 int c = BYTE_TO_ASCII(enc, ptr);
1568 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1571 switch ((end - ptr)/MINBPC(enc)) {
1573 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1574 switch (BYTE_TO_ASCII(enc, ptr)) {
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))
1593 switch (BYTE_TO_ASCII(enc, ptr)) {
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))
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))
1622 PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
1625 switch (BYTE_TYPE(enc, ptr1)) {
1647 if (MINBPC(enc) > 1) {
1650 if (MINBPC(enc) > 2) {
1653 if (MINBPC(enc) > 3) {
1661 if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
1663 switch (BYTE_TYPE(enc, ptr2)) {
1686 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1689 for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1692 if (!CHAR_MATCHES(enc, ptr1, *ptr2))
1699 PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1703 switch (BYTE_TYPE(enc, ptr)) {
1717 ptr += MINBPC(enc);
1726 PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1729 switch (BYTE_TYPE(enc, ptr)) {
1733 ptr += MINBPC(enc);
1742 PREFIX(updatePosition)(const ENCODING *enc,
1748 switch (BYTE_TYPE(enc, ptr)) {
1758 ptr += MINBPC(enc);
1762 ptr += MINBPC(enc);
1763 if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
1764 ptr += MINBPC(enc);
1768 ptr += MINBPC(enc);