Lines Matching refs:enc
45 # define IS_INVALID_CHAR(enc, ptr, n) (0)
52 if (IS_INVALID_CHAR(enc, ptr, n)) { \
69 # define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
73 if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NAME_CHAR(enc, ptr, n)) { \
80 # define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
82 if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \
92 ptr += MINBPC(enc); \
94 CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
95 CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
96 CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
98 # define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
102 if (IS_INVALID_CHAR(enc, ptr, n) || ! IS_NMSTRT_CHAR(enc, ptr, n)) { \
109 # define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
111 if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
118 ptr += MINBPC(enc); \
120 CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
121 CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
122 CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
128 # define HAS_CHARS(enc, ptr, end, count) \
129 ((end) - (ptr) >= ((count)*MINBPC(enc)))
131 # define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
133 # define REQUIRE_CHARS(enc, ptr, end, count) \
135 if (! HAS_CHARS(enc, ptr, end, count)) { \
140 # define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
145 PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
147 if (HAS_CHAR(enc, ptr, end)) {
148 if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
152 ptr += MINBPC(enc);
153 while (HAS_CHAR(enc, ptr, end)) {
154 switch (BYTE_TYPE(enc, ptr)) {
157 ptr += MINBPC(enc);
158 REQUIRE_CHAR(enc, ptr, end);
159 if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
160 ptr += MINBPC(enc);
161 REQUIRE_CHAR(enc, ptr, end);
162 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
166 *nextTokPtr = ptr + MINBPC(enc);
171 ptr += MINBPC(enc);
182 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
184 REQUIRE_CHAR(enc, ptr, end);
185 switch (BYTE_TYPE(enc, ptr)) {
187 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
189 *nextTokPtr = ptr + MINBPC(enc);
193 ptr += MINBPC(enc);
199 while (HAS_CHAR(enc, ptr, end)) {
200 switch (BYTE_TYPE(enc, ptr)) {
202 REQUIRE_CHARS(enc, ptr, end, 2);
204 switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
220 ptr += MINBPC(enc);
231 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
234 UNUSED_P(enc);
236 if (end - ptr != MINBPC(enc) * 3)
238 switch (BYTE_TO_ASCII(enc, ptr)) {
247 ptr += MINBPC(enc);
248 switch (BYTE_TO_ASCII(enc, ptr)) {
257 ptr += MINBPC(enc);
258 switch (BYTE_TO_ASCII(enc, ptr)) {
276 PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
280 REQUIRE_CHAR(enc, ptr, end);
281 switch (BYTE_TYPE(enc, ptr)) {
282 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
287 while (HAS_CHAR(enc, ptr, end)) {
288 switch (BYTE_TYPE(enc, ptr)) {
289 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
293 if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
297 ptr += MINBPC(enc);
298 while (HAS_CHAR(enc, ptr, end)) {
299 switch (BYTE_TYPE(enc, ptr)) {
302 ptr += MINBPC(enc);
303 REQUIRE_CHAR(enc, ptr, end);
304 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
305 *nextTokPtr = ptr + MINBPC(enc);
310 ptr += MINBPC(enc);
316 if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
320 ptr += MINBPC(enc);
321 REQUIRE_CHAR(enc, ptr, end);
322 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
323 *nextTokPtr = ptr + MINBPC(enc);
336 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
341 UNUSED_P(enc);
343 REQUIRE_CHARS(enc, ptr, end, 6);
344 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
345 if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
355 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
359 if (MINBPC(enc) > 1) {
361 if (n & (MINBPC(enc) - 1)) {
362 n &= ~(MINBPC(enc) - 1);
368 switch (BYTE_TYPE(enc, ptr)) {
370 ptr += MINBPC(enc);
371 REQUIRE_CHAR(enc, ptr, end);
372 if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
374 ptr += MINBPC(enc);
375 REQUIRE_CHAR(enc, ptr, end);
376 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
377 ptr -= MINBPC(enc);
380 *nextTokPtr = ptr + MINBPC(enc);
383 ptr += MINBPC(enc);
384 REQUIRE_CHAR(enc, ptr, end);
385 if (BYTE_TYPE(enc, ptr) == BT_LF)
386 ptr += MINBPC(enc);
390 *nextTokPtr = ptr + MINBPC(enc);
394 ptr += MINBPC(enc);
397 while (HAS_CHAR(enc, ptr, end)) {
398 switch (BYTE_TYPE(enc, ptr)) {
401 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
420 ptr += MINBPC(enc);
431 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
433 REQUIRE_CHAR(enc, ptr, end);
434 switch (BYTE_TYPE(enc, ptr)) {
435 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
440 while (HAS_CHAR(enc, ptr, end)) {
441 switch (BYTE_TYPE(enc, ptr)) {
442 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
446 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
447 switch (BYTE_TYPE(enc, ptr)) {
453 *nextTokPtr = ptr + MINBPC(enc);
465 ptr += MINBPC(enc);
469 *nextTokPtr = ptr + MINBPC(enc);
482 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
484 if (HAS_CHAR(enc, ptr, end)) {
485 switch (BYTE_TYPE(enc, ptr)) {
493 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
494 switch (BYTE_TYPE(enc, ptr)) {
499 *nextTokPtr = ptr + MINBPC(enc);
513 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
515 if (HAS_CHAR(enc, ptr, end)) {
516 if (CHAR_MATCHES(enc, ptr, ASCII_x))
517 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
518 switch (BYTE_TYPE(enc, ptr)) {
525 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
526 switch (BYTE_TYPE(enc, ptr)) {
530 *nextTokPtr = ptr + MINBPC(enc);
544 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
546 REQUIRE_CHAR(enc, ptr, end);
547 switch (BYTE_TYPE(enc, ptr)) {
548 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
550 return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
555 while (HAS_CHAR(enc, ptr, end)) {
556 switch (BYTE_TYPE(enc, ptr)) {
557 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
559 *nextTokPtr = ptr + MINBPC(enc);
572 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
577 while (HAS_CHAR(enc, ptr, end)) {
578 switch (BYTE_TYPE(enc, ptr)) {
579 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
587 ptr += MINBPC(enc);
588 REQUIRE_CHAR(enc, ptr, end);
589 switch (BYTE_TYPE(enc, ptr)) {
590 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
603 ptr += MINBPC(enc);
604 REQUIRE_CHAR(enc, ptr, end);
605 t = BYTE_TYPE(enc, ptr);
625 ptr += MINBPC(enc);
626 REQUIRE_CHAR(enc, ptr, end);
627 open = BYTE_TYPE(enc, ptr);
640 ptr += MINBPC(enc);
644 REQUIRE_CHAR(enc, ptr, end);
645 t = BYTE_TYPE(enc, ptr);
651 int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
663 ptr += MINBPC(enc);
667 ptr += MINBPC(enc);
668 REQUIRE_CHAR(enc, ptr, end);
669 switch (BYTE_TYPE(enc, ptr)) {
684 ptr += MINBPC(enc);
685 REQUIRE_CHAR(enc, ptr, end);
686 switch (BYTE_TYPE(enc, ptr)) {
687 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
694 *nextTokPtr = ptr + MINBPC(enc);
698 ptr += MINBPC(enc);
699 REQUIRE_CHAR(enc, ptr, end);
700 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
704 *nextTokPtr = ptr + MINBPC(enc);
725 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
730 REQUIRE_CHAR(enc, ptr, end);
731 switch (BYTE_TYPE(enc, ptr)) {
732 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
734 ptr += MINBPC(enc);
735 REQUIRE_CHAR(enc, ptr, end);
736 switch (BYTE_TYPE(enc, ptr)) {
738 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
740 return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
745 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
747 return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
756 while (HAS_CHAR(enc, ptr, end)) {
757 switch (BYTE_TYPE(enc, ptr)) {
758 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
766 ptr += MINBPC(enc);
767 REQUIRE_CHAR(enc, ptr, end);
768 switch (BYTE_TYPE(enc, ptr)) {
769 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
779 ptr += MINBPC(enc);
780 while (HAS_CHAR(enc, ptr, end)) {
781 switch (BYTE_TYPE(enc, ptr)) {
782 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
790 ptr += MINBPC(enc);
796 return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
802 *nextTokPtr = ptr + MINBPC(enc);
806 ptr += MINBPC(enc);
807 REQUIRE_CHAR(enc, ptr, end);
808 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
812 *nextTokPtr = ptr + MINBPC(enc);
823 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
827 if (MINBPC(enc) > 1) {
829 if (n & (MINBPC(enc) - 1)) {
830 n &= ~(MINBPC(enc) - 1);
836 switch (BYTE_TYPE(enc, ptr)) {
838 return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
840 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
842 ptr += MINBPC(enc);
843 if (! HAS_CHAR(enc, ptr, end))
845 if (BYTE_TYPE(enc, ptr) == BT_LF)
846 ptr += MINBPC(enc);
850 *nextTokPtr = ptr + MINBPC(enc);
853 ptr += MINBPC(enc);
854 if (! HAS_CHAR(enc, ptr, end))
856 if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
858 ptr += MINBPC(enc);
859 if (! HAS_CHAR(enc, ptr, end))
861 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
862 ptr -= MINBPC(enc);
869 ptr += MINBPC(enc);
872 while (HAS_CHAR(enc, ptr, end)) {
873 switch (BYTE_TYPE(enc, ptr)) {
876 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
887 if (HAS_CHARS(enc, ptr, end, 2)) {
888 if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
889 ptr += MINBPC(enc);
892 if (HAS_CHARS(enc, ptr, end, 3)) {
893 if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
894 ptr += MINBPC(enc);
897 *nextTokPtr = ptr + 2 * MINBPC(enc);
912 ptr += MINBPC(enc);
923 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
925 REQUIRE_CHAR(enc, ptr, end);
926 switch (BYTE_TYPE(enc, ptr)) {
927 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
938 while (HAS_CHAR(enc, ptr, end)) {
939 switch (BYTE_TYPE(enc, ptr)) {
940 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
942 *nextTokPtr = ptr + MINBPC(enc);
953 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
955 REQUIRE_CHAR(enc, ptr, end);
956 switch (BYTE_TYPE(enc, ptr)) {
957 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
962 while (HAS_CHAR(enc, ptr, end)) {
963 switch (BYTE_TYPE(enc, ptr)) {
964 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
983 PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
985 while (HAS_CHAR(enc, ptr, end)) {
986 int t = BYTE_TYPE(enc, ptr);
991 ptr += MINBPC(enc);
994 if (! HAS_CHAR(enc, ptr, end))
997 switch (BYTE_TYPE(enc, ptr)) {
1009 ptr += MINBPC(enc);
1017 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
1022 if (MINBPC(enc) > 1) {
1024 if (n & (MINBPC(enc) - 1)) {
1025 n &= ~(MINBPC(enc) - 1);
1031 switch (BYTE_TYPE(enc, ptr)) {
1033 return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
1035 return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
1037 ptr += MINBPC(enc);
1038 REQUIRE_CHAR(enc, ptr, end);
1039 switch (BYTE_TYPE(enc, ptr)) {
1041 return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1043 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1050 *nextTokPtr = ptr - MINBPC(enc);
1057 if (ptr + MINBPC(enc) == end) {
1066 ptr += MINBPC(enc);
1067 if (! HAS_CHAR(enc, ptr, end))
1069 switch (BYTE_TYPE(enc, ptr)) {
1075 if (ptr + MINBPC(enc) != end)
1086 return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1088 *nextTokPtr = ptr + MINBPC(enc);
1091 *nextTokPtr = ptr + MINBPC(enc);
1094 ptr += MINBPC(enc);
1095 if (! HAS_CHAR(enc, ptr, end))
1097 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1098 REQUIRE_CHARS(enc, ptr, end, 2);
1099 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1100 *nextTokPtr = ptr + 2 * MINBPC(enc);
1107 *nextTokPtr = ptr + MINBPC(enc);
1110 ptr += MINBPC(enc);
1111 if (! HAS_CHAR(enc, ptr, end))
1113 switch (BYTE_TYPE(enc, ptr)) {
1115 *nextTokPtr = ptr + MINBPC(enc);
1118 *nextTokPtr = ptr + MINBPC(enc);
1121 *nextTokPtr = ptr + MINBPC(enc);
1136 *nextTokPtr = ptr + MINBPC(enc);
1139 *nextTokPtr = ptr + MINBPC(enc);
1142 return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1147 if (IS_INVALID_CHAR(enc, ptr, n)) { \
1151 if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1156 if (IS_NAME_CHAR(enc, ptr, n)) { \
1170 ptr += MINBPC(enc);
1179 ptr += MINBPC(enc);
1182 if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1183 ptr += MINBPC(enc);
1187 if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1188 ptr += MINBPC(enc);
1197 while (HAS_CHAR(enc, ptr, end)) {
1198 switch (BYTE_TYPE(enc, ptr)) {
1199 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1213 ptr += MINBPC(enc);
1216 REQUIRE_CHAR(enc, ptr, end);
1218 switch (BYTE_TYPE(enc, ptr)) {
1219 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1236 *nextTokPtr = ptr + MINBPC(enc);
1243 *nextTokPtr = ptr + MINBPC(enc);
1250 *nextTokPtr = ptr + MINBPC(enc);
1261 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
1266 else if (! HAS_CHAR(enc, ptr, end)) {
1275 while (HAS_CHAR(enc, ptr, end)) {
1276 switch (BYTE_TYPE(enc, ptr)) {
1287 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1296 *nextTokPtr = ptr + MINBPC(enc);
1303 ptr += MINBPC(enc);
1304 if (! HAS_CHAR(enc, ptr, end))
1306 if (BYTE_TYPE(enc, ptr) == BT_LF)
1307 ptr += MINBPC(enc);
1315 *nextTokPtr = ptr + MINBPC(enc);
1321 ptr += MINBPC(enc);
1330 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
1335 else if (! HAS_CHAR(enc, ptr, end)) {
1344 while (HAS_CHAR(enc, ptr, end)) {
1345 switch (BYTE_TYPE(enc, ptr)) {
1356 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1361 int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1368 *nextTokPtr = ptr + MINBPC(enc);
1375 ptr += MINBPC(enc);
1376 if (! HAS_CHAR(enc, ptr, end))
1378 if (BYTE_TYPE(enc, ptr) == BT_LF)
1379 ptr += MINBPC(enc);
1386 ptr += MINBPC(enc);
1397 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
1400 if (MINBPC(enc) > 1) {
1402 if (n & (MINBPC(enc) - 1)) {
1403 n &= ~(MINBPC(enc) - 1);
1407 while (HAS_CHAR(enc, ptr, end)) {
1408 switch (BYTE_TYPE(enc, ptr)) {
1411 ptr += MINBPC(enc);
1412 REQUIRE_CHAR(enc, ptr, end);
1413 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1414 ptr += MINBPC(enc);
1415 REQUIRE_CHAR(enc, ptr, end);
1416 if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1418 ptr += MINBPC(enc);
1423 ptr += MINBPC(enc);
1424 REQUIRE_CHAR(enc, ptr, end);
1425 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1426 ptr += MINBPC(enc);
1427 REQUIRE_CHAR(enc, ptr, end);
1428 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1429 ptr += MINBPC(enc);
1439 ptr += MINBPC(enc);
1449 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1451 ptr += MINBPC(enc);
1452 end -= MINBPC(enc);
1453 for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
1454 switch (BYTE_TYPE(enc, ptr)) {
1478 if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1485 if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1489 switch (BYTE_TO_ASCII(enc, ptr)) {
1509 PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
1516 for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1517 switch (BYTE_TYPE(enc, ptr)) {
1528 START_NAME ptr += (n - MINBPC(enc)); \
1543 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1556 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1575 || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
1576 || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
1577 || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
1602 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
1605 UNUSED_P(enc);
1606 ptr += 2 * MINBPC(enc);
1607 if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1608 for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
1609 ptr += MINBPC(enc)) {
1610 int c = BYTE_TO_ASCII(enc, ptr);
1648 for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1649 int c = BYTE_TO_ASCII(enc, ptr);
1660 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1662 UNUSED_P(enc);
1663 switch ((end - ptr) / MINBPC(enc)) {
1665 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1666 switch (BYTE_TO_ASCII(enc, ptr)) {
1675 if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
1676 ptr += MINBPC(enc);
1677 if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
1678 ptr += MINBPC(enc);
1679 if (CHAR_MATCHES(enc, ptr, ASCII_p))
1685 switch (BYTE_TO_ASCII(enc, ptr)) {
1687 ptr += MINBPC(enc);
1688 if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
1689 ptr += MINBPC(enc);
1690 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1691 ptr += MINBPC(enc);
1692 if (CHAR_MATCHES(enc, ptr, ASCII_t))
1698 ptr += MINBPC(enc);
1699 if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
1700 ptr += MINBPC(enc);
1701 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1702 ptr += MINBPC(enc);
1703 if (CHAR_MATCHES(enc, ptr, ASCII_s))
1714 PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
1716 UNUSED_P(enc);
1717 for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
1718 if (end1 - ptr1 < MINBPC(enc)) {
1726 if (! CHAR_MATCHES(enc, ptr1, *ptr2))
1733 PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
1736 switch (BYTE_TYPE(enc, ptr)) {
1754 ptr += MINBPC(enc);
1763 PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
1765 switch (BYTE_TYPE(enc, ptr)) {
1769 ptr += MINBPC(enc);
1778 PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
1780 while (HAS_CHAR(enc, ptr, end)) {
1781 switch (BYTE_TYPE(enc, ptr)) {
1794 ptr += MINBPC(enc);
1798 ptr += MINBPC(enc);
1799 if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
1800 ptr += MINBPC(enc);
1804 ptr += MINBPC(enc);