Lines Matching defs:enc
6 #define IS_INVALID_CHAR(enc, ptr, n) (0)
13 if (IS_INVALID_CHAR(enc, ptr, n)) { \
30 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
34 if (!IS_NAME_CHAR(enc, ptr, n)) { \
41 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
43 if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
52 ptr += MINBPC(enc); \
54 CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
55 CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
56 CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
58 #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
62 if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
69 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
71 if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
77 ptr += MINBPC(enc); \
79 CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
80 CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
81 CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
90 PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
94 if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
98 ptr += MINBPC(enc);
100 switch (BYTE_TYPE(enc, ptr)) {
103 if ((ptr += MINBPC(enc)) == end)
105 if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
106 if ((ptr += MINBPC(enc)) == end)
108 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
112 *nextTokPtr = ptr + MINBPC(enc);
117 ptr += MINBPC(enc);
128 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
133 switch (BYTE_TYPE(enc, ptr)) {
135 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
137 *nextTokPtr = ptr + MINBPC(enc);
141 ptr += MINBPC(enc);
148 switch (BYTE_TYPE(enc, ptr)) {
150 if (ptr + MINBPC(enc) == end)
153 switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
164 ptr += MINBPC(enc);
175 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
180 if (end - ptr != MINBPC(enc)*3)
182 switch (BYTE_TO_ASCII(enc, ptr)) {
191 ptr += MINBPC(enc);
192 switch (BYTE_TO_ASCII(enc, ptr)) {
201 ptr += MINBPC(enc);
202 switch (BYTE_TO_ASCII(enc, ptr)) {
220 PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
227 switch (BYTE_TYPE(enc, ptr)) {
228 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
234 switch (BYTE_TYPE(enc, ptr)) {
235 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
237 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
241 ptr += MINBPC(enc);
243 switch (BYTE_TYPE(enc, ptr)) {
246 ptr += MINBPC(enc);
249 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
250 *nextTokPtr = ptr + MINBPC(enc);
255 ptr += MINBPC(enc);
261 if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
265 ptr += MINBPC(enc);
268 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
269 *nextTokPtr = ptr + MINBPC(enc);
282 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
289 if (end - ptr < 6 * MINBPC(enc))
291 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
292 if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
302 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
307 if (MINBPC(enc) > 1) {
309 if (n & (MINBPC(enc) - 1)) {
310 n &= ~(MINBPC(enc) - 1);
316 switch (BYTE_TYPE(enc, ptr)) {
318 ptr += MINBPC(enc);
321 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
323 ptr += MINBPC(enc);
326 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
327 ptr -= MINBPC(enc);
330 *nextTokPtr = ptr + MINBPC(enc);
333 ptr += MINBPC(enc);
336 if (BYTE_TYPE(enc, ptr) == BT_LF)
337 ptr += MINBPC(enc);
341 *nextTokPtr = ptr + MINBPC(enc);
345 ptr += MINBPC(enc);
349 switch (BYTE_TYPE(enc, ptr)) {
352 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
369 ptr += MINBPC(enc);
380 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
385 switch (BYTE_TYPE(enc, ptr)) {
386 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
392 switch (BYTE_TYPE(enc, ptr)) {
393 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
395 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
396 switch (BYTE_TYPE(enc, ptr)) {
400 *nextTokPtr = ptr + MINBPC(enc);
412 ptr += MINBPC(enc);
416 *nextTokPtr = ptr + MINBPC(enc);
429 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
433 switch (BYTE_TYPE(enc, ptr)) {
441 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
442 switch (BYTE_TYPE(enc, ptr)) {
447 *nextTokPtr = ptr + MINBPC(enc);
461 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
465 if (CHAR_MATCHES(enc, ptr, ASCII_x))
466 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
467 switch (BYTE_TYPE(enc, ptr)) {
474 for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
475 switch (BYTE_TYPE(enc, ptr)) {
479 *nextTokPtr = ptr + MINBPC(enc);
493 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
498 switch (BYTE_TYPE(enc, ptr)) {
499 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
501 return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
507 switch (BYTE_TYPE(enc, ptr)) {
508 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
510 *nextTokPtr = ptr + MINBPC(enc);
523 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
530 switch (BYTE_TYPE(enc, ptr)) {
531 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
539 ptr += MINBPC(enc);
542 switch (BYTE_TYPE(enc, ptr)) {
543 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
554 ptr += MINBPC(enc);
557 t = BYTE_TYPE(enc, ptr);
578 ptr += MINBPC(enc);
581 open = BYTE_TYPE(enc, ptr);
594 ptr += MINBPC(enc);
600 t = BYTE_TYPE(enc, ptr);
607 int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
619 ptr += MINBPC(enc);
623 ptr += MINBPC(enc);
626 switch (BYTE_TYPE(enc, ptr)) {
641 ptr += MINBPC(enc);
644 switch (BYTE_TYPE(enc, ptr)) {
645 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
650 *nextTokPtr = ptr + MINBPC(enc);
654 ptr += MINBPC(enc);
657 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
661 *nextTokPtr = ptr + MINBPC(enc);
682 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
690 switch (BYTE_TYPE(enc, ptr)) {
691 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
693 if ((ptr += MINBPC(enc)) == end)
695 switch (BYTE_TYPE(enc, ptr)) {
697 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
699 return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
705 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
707 return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
717 switch (BYTE_TYPE(enc, ptr)) {
718 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
726 ptr += MINBPC(enc);
729 switch (BYTE_TYPE(enc, ptr)) {
730 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
739 ptr += MINBPC(enc);
741 switch (BYTE_TYPE(enc, ptr)) {
742 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
748 ptr += MINBPC(enc);
754 return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
760 *nextTokPtr = ptr + MINBPC(enc);
764 ptr += MINBPC(enc);
767 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
771 *nextTokPtr = ptr + MINBPC(enc);
782 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
787 if (MINBPC(enc) > 1) {
789 if (n & (MINBPC(enc) - 1)) {
790 n &= ~(MINBPC(enc) - 1);
796 switch (BYTE_TYPE(enc, ptr)) {
798 return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
800 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
802 ptr += MINBPC(enc);
805 if (BYTE_TYPE(enc, ptr) == BT_LF)
806 ptr += MINBPC(enc);
810 *nextTokPtr = ptr + MINBPC(enc);
813 ptr += MINBPC(enc);
816 if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
818 ptr += MINBPC(enc);
821 if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
822 ptr -= MINBPC(enc);
829 ptr += MINBPC(enc);
833 switch (BYTE_TYPE(enc, ptr)) {
836 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
845 if (ptr + MINBPC(enc) != end) {
846 if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
847 ptr += MINBPC(enc);
850 if (ptr + 2*MINBPC(enc) != end) {
851 if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
852 ptr += MINBPC(enc);
855 *nextTokPtr = ptr + 2*MINBPC(enc);
870 ptr += MINBPC(enc);
881 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
886 switch (BYTE_TYPE(enc, ptr)) {
887 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
896 switch (BYTE_TYPE(enc, ptr)) {
897 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
899 *nextTokPtr = ptr + MINBPC(enc);
910 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
915 switch (BYTE_TYPE(enc, ptr)) {
916 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
922 switch (BYTE_TYPE(enc, ptr)) {
923 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
937 PREFIX(scanLit)(int open, const ENCODING *enc,
942 int t = BYTE_TYPE(enc, ptr);
947 ptr += MINBPC(enc);
953 switch (BYTE_TYPE(enc, ptr)) {
961 ptr += MINBPC(enc);
969 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
975 if (MINBPC(enc) > 1) {
977 if (n & (MINBPC(enc) - 1)) {
978 n &= ~(MINBPC(enc) - 1);
984 switch (BYTE_TYPE(enc, ptr)) {
986 return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
988 return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
991 ptr += MINBPC(enc);
994 switch (BYTE_TYPE(enc, ptr)) {
996 return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
998 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1005 *nextTokPtr = ptr - MINBPC(enc);
1012 if (ptr + MINBPC(enc) == end) {
1020 ptr += MINBPC(enc);
1023 switch (BYTE_TYPE(enc, ptr)) {
1028 if (ptr + MINBPC(enc) != end)
1039 return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1041 *nextTokPtr = ptr + MINBPC(enc);
1044 *nextTokPtr = ptr + MINBPC(enc);
1047 ptr += MINBPC(enc);
1050 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1051 if (ptr + MINBPC(enc) == end)
1053 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1054 *nextTokPtr = ptr + 2*MINBPC(enc);
1061 *nextTokPtr = ptr + MINBPC(enc);
1064 ptr += MINBPC(enc);
1067 switch (BYTE_TYPE(enc, ptr)) {
1069 *nextTokPtr = ptr + MINBPC(enc);
1072 *nextTokPtr = ptr + MINBPC(enc);
1075 *nextTokPtr = ptr + MINBPC(enc);
1086 *nextTokPtr = ptr + MINBPC(enc);
1089 *nextTokPtr = ptr + MINBPC(enc);
1092 return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1097 if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1102 if (IS_NAME_CHAR(enc, ptr, n)) { \
1114 ptr += MINBPC(enc);
1123 ptr += MINBPC(enc);
1126 if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1127 ptr += MINBPC(enc);
1131 if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1132 ptr += MINBPC(enc);
1142 switch (BYTE_TYPE(enc, ptr)) {
1143 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1151 ptr += MINBPC(enc);
1157 switch (BYTE_TYPE(enc, ptr)) {
1158 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1175 *nextTokPtr = ptr + MINBPC(enc);
1182 *nextTokPtr = ptr + MINBPC(enc);
1189 *nextTokPtr = ptr + MINBPC(enc);
1200 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1208 switch (BYTE_TYPE(enc, ptr)) {
1215 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1224 *nextTokPtr = ptr + MINBPC(enc);
1231 ptr += MINBPC(enc);
1234 if (BYTE_TYPE(enc, ptr) == BT_LF)
1235 ptr += MINBPC(enc);
1243 *nextTokPtr = ptr + MINBPC(enc);
1249 ptr += MINBPC(enc);
1258 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1266 switch (BYTE_TYPE(enc, ptr)) {
1273 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1278 int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
1286 *nextTokPtr = ptr + MINBPC(enc);
1293 ptr += MINBPC(enc);
1296 if (BYTE_TYPE(enc, ptr) == BT_LF)
1297 ptr += MINBPC(enc);
1304 ptr += MINBPC(enc);
1315 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1319 if (MINBPC(enc) > 1) {
1321 if (n & (MINBPC(enc) - 1)) {
1322 n &= ~(MINBPC(enc) - 1);
1327 switch (BYTE_TYPE(enc, ptr)) {
1330 if ((ptr += MINBPC(enc)) == end)
1332 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1333 if ((ptr += MINBPC(enc)) == end)
1335 if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1337 ptr += MINBPC(enc);
1342 if ((ptr += MINBPC(enc)) == end)
1344 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1345 if ((ptr += MINBPC(enc)) == end)
1347 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1348 ptr += MINBPC(enc);
1358 ptr += MINBPC(enc);
1368 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1371 ptr += MINBPC(enc);
1372 end -= MINBPC(enc);
1373 for (; ptr != end; ptr += MINBPC(enc)) {
1374 switch (BYTE_TYPE(enc, ptr)) {
1398 if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1405 if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1408 switch (BYTE_TO_ASCII(enc, ptr)) {
1428 PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1436 for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1437 switch (BYTE_TYPE(enc, ptr)) {
1447 case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
1459 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1473 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1495 || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
1496 || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
1497 || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
1521 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
1525 ptr += 2*MINBPC(enc);
1526 if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1527 for (ptr += MINBPC(enc);
1528 !CHAR_MATCHES(enc, ptr, ASCII_SEMI);
1529 ptr += MINBPC(enc)) {
1530 int c = BYTE_TO_ASCII(enc, ptr);
1553 for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1554 int c = BYTE_TO_ASCII(enc, ptr);
1565 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1568 switch ((end - ptr)/MINBPC(enc)) {
1570 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1571 switch (BYTE_TO_ASCII(enc, ptr)) {
1580 if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
1581 ptr += MINBPC(enc);
1582 if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
1583 ptr += MINBPC(enc);
1584 if (CHAR_MATCHES(enc, ptr, ASCII_p))
1590 switch (BYTE_TO_ASCII(enc, ptr)) {
1592 ptr += MINBPC(enc);
1593 if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
1594 ptr += MINBPC(enc);
1595 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1596 ptr += MINBPC(enc);
1597 if (CHAR_MATCHES(enc, ptr, ASCII_t))
1603 ptr += MINBPC(enc);
1604 if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
1605 ptr += MINBPC(enc);
1606 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1607 ptr += MINBPC(enc);
1608 if (CHAR_MATCHES(enc, ptr, ASCII_s))
1619 PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
1622 switch (BYTE_TYPE(enc, ptr1)) {
1644 if (MINBPC(enc) > 1) {
1647 if (MINBPC(enc) > 2) {
1650 if (MINBPC(enc) > 3) {
1658 if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
1660 switch (BYTE_TYPE(enc, ptr2)) {
1683 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1686 for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1689 if (!CHAR_MATCHES(enc, ptr1, *ptr2))
1696 PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1700 switch (BYTE_TYPE(enc, ptr)) {
1714 ptr += MINBPC(enc);
1723 PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1726 switch (BYTE_TYPE(enc, ptr)) {
1730 ptr += MINBPC(enc);
1739 PREFIX(updatePosition)(const ENCODING *enc,
1745 switch (BYTE_TYPE(enc, ptr)) {
1755 ptr += MINBPC(enc);
1759 ptr += MINBPC(enc);
1760 if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
1761 ptr += MINBPC(enc);
1765 ptr += MINBPC(enc);