Lines Matching refs:ptr
36 # define IS_INVALID_CHAR(enc, ptr, n) (0)
39 # define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
41 if (end - ptr < n) \
43 if (IS_INVALID_CHAR(enc, ptr, n)) { \
44 *(nextTokPtr) = (ptr); \
47 ptr += n; \
50 # define INVALID_CASES(ptr, nextTokPtr) \
51 INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
52 INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
53 INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
57 *(nextTokPtr) = (ptr); \
60 # define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
62 if (end - ptr < n) \
64 if (! IS_NAME_CHAR(enc, ptr, n)) { \
65 *nextTokPtr = ptr; \
68 ptr += n; \
71 # define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
73 if (! IS_NAME_CHAR_MINBPC(enc, ptr)) { \
74 *nextTokPtr = ptr; \
83 ptr += MINBPC(enc); \
85 CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
86 CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
87 CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
89 # define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
91 if (end - ptr < n) \
93 if (! IS_NMSTRT_CHAR(enc, ptr, n)) { \
94 *nextTokPtr = ptr; \
97 ptr += n; \
100 # define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
102 if (! IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
103 *nextTokPtr = ptr; \
109 ptr += MINBPC(enc); \
111 CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
112 CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
113 CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
119 # define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
121 # define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
123 # define REQUIRE_CHARS(enc, ptr, end, count) \
125 if (! HAS_CHARS(enc, ptr, end, count)) { \
130 # define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
132 /* ptr points to character following "<!-" */
135 PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
137 if (HAS_CHAR(enc, ptr, end)) {
138 if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
139 *nextTokPtr = ptr;
142 ptr += MINBPC(enc);
143 while (HAS_CHAR(enc, ptr, end)) {
144 switch (BYTE_TYPE(enc, ptr)) {
145 INVALID_CASES(ptr, nextTokPtr)
147 ptr += MINBPC(enc);
148 REQUIRE_CHAR(enc, ptr, end);
149 if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
150 ptr += MINBPC(enc);
151 REQUIRE_CHAR(enc, ptr, end);
152 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
153 *nextTokPtr = ptr;
156 *nextTokPtr = ptr + MINBPC(enc);
161 ptr += MINBPC(enc);
169 /* ptr points to character following "<!" */
172 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
174 REQUIRE_CHAR(enc, ptr, end);
175 switch (BYTE_TYPE(enc, ptr)) {
177 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
179 *nextTokPtr = ptr + MINBPC(enc);
183 ptr += MINBPC(enc);
186 *nextTokPtr = ptr;
189 while (HAS_CHAR(enc, ptr, end)) {
190 switch (BYTE_TYPE(enc, ptr)) {
192 REQUIRE_CHARS(enc, ptr, end, 2);
194 switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
199 *nextTokPtr = ptr;
206 *nextTokPtr = ptr;
210 ptr += MINBPC(enc);
213 *nextTokPtr = ptr;
221 PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
226 if (end - ptr != MINBPC(enc) * 3)
228 switch (BYTE_TO_ASCII(enc, ptr)) {
237 ptr += MINBPC(enc);
238 switch (BYTE_TO_ASCII(enc, ptr)) {
247 ptr += MINBPC(enc);
248 switch (BYTE_TO_ASCII(enc, ptr)) {
263 /* ptr points to character following "<?" */
266 PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
269 const char *target = ptr;
270 REQUIRE_CHAR(enc, ptr, end);
271 switch (BYTE_TYPE(enc, ptr)) {
272 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
274 *nextTokPtr = ptr;
277 while (HAS_CHAR(enc, ptr, end)) {
278 switch (BYTE_TYPE(enc, ptr)) {
279 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
283 if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
284 *nextTokPtr = ptr;
287 ptr += MINBPC(enc);
288 while (HAS_CHAR(enc, ptr, end)) {
289 switch (BYTE_TYPE(enc, ptr)) {
290 INVALID_CASES(ptr, nextTokPtr)
292 ptr += MINBPC(enc);
293 REQUIRE_CHAR(enc, ptr, end);
294 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
295 *nextTokPtr = ptr + MINBPC(enc);
300 ptr += MINBPC(enc);
306 if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
307 *nextTokPtr = ptr;
310 ptr += MINBPC(enc);
311 REQUIRE_CHAR(enc, ptr, end);
312 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
313 *nextTokPtr = ptr + MINBPC(enc);
318 *nextTokPtr = ptr;
326 PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
333 REQUIRE_CHARS(enc, ptr, end, 6);
334 for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
335 if (! CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
336 *nextTokPtr = ptr;
340 *nextTokPtr = ptr;
345 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
347 if (ptr >= end)
350 size_t n = end - ptr;
355 end = ptr + n;
358 switch (BYTE_TYPE(enc, ptr)) {
360 ptr += MINBPC(enc);
361 REQUIRE_CHAR(enc, ptr, end);
362 if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
364 ptr += MINBPC(enc);
365 REQUIRE_CHAR(enc, ptr, end);
366 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
367 ptr -= MINBPC(enc);
370 *nextTokPtr = ptr + MINBPC(enc);
373 ptr += MINBPC(enc);
374 REQUIRE_CHAR(enc, ptr, end);
375 if (BYTE_TYPE(enc, ptr) == BT_LF)
376 ptr += MINBPC(enc);
377 *nextTokPtr = ptr;
380 *nextTokPtr = ptr + MINBPC(enc);
382 INVALID_CASES(ptr, nextTokPtr)
384 ptr += MINBPC(enc);
387 while (HAS_CHAR(enc, ptr, end)) {
388 switch (BYTE_TYPE(enc, ptr)) {
391 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
392 *nextTokPtr = ptr; \
395 ptr += n; \
407 *nextTokPtr = ptr;
410 ptr += MINBPC(enc);
414 *nextTokPtr = ptr;
418 /* ptr points to character following "</" */
421 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
423 REQUIRE_CHAR(enc, ptr, end);
424 switch (BYTE_TYPE(enc, ptr)) {
425 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
427 *nextTokPtr = ptr;
430 while (HAS_CHAR(enc, ptr, end)) {
431 switch (BYTE_TYPE(enc, ptr)) {
432 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
436 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
437 switch (BYTE_TYPE(enc, ptr)) {
443 *nextTokPtr = ptr + MINBPC(enc);
446 *nextTokPtr = ptr;
455 ptr += MINBPC(enc);
459 *nextTokPtr = ptr + MINBPC(enc);
462 *nextTokPtr = ptr;
469 /* ptr points to character following "&#X" */
472 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
474 if (HAS_CHAR(enc, ptr, end)) {
475 switch (BYTE_TYPE(enc, ptr)) {
480 *nextTokPtr = ptr;
483 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
484 switch (BYTE_TYPE(enc, ptr)) {
489 *nextTokPtr = ptr + MINBPC(enc);
492 *nextTokPtr = ptr;
500 /* ptr points to character following "&#" */
503 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
505 if (HAS_CHAR(enc, ptr, end)) {
506 if (CHAR_MATCHES(enc, ptr, ASCII_x))
507 return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
508 switch (BYTE_TYPE(enc, ptr)) {
512 *nextTokPtr = ptr;
515 for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
516 switch (BYTE_TYPE(enc, ptr)) {
520 *nextTokPtr = ptr + MINBPC(enc);
523 *nextTokPtr = ptr;
531 /* ptr points to character following "&" */
534 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
536 REQUIRE_CHAR(enc, ptr, end);
537 switch (BYTE_TYPE(enc, ptr)) {
538 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
540 return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
542 *nextTokPtr = ptr;
545 while (HAS_CHAR(enc, ptr, end)) {
546 switch (BYTE_TYPE(enc, ptr)) {
547 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
549 *nextTokPtr = ptr + MINBPC(enc);
552 *nextTokPtr = ptr;
559 /* ptr points to character following first character of attribute name */
562 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
567 while (HAS_CHAR(enc, ptr, end)) {
568 switch (BYTE_TYPE(enc, ptr)) {
569 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
573 *nextTokPtr = ptr;
577 ptr += MINBPC(enc);
578 REQUIRE_CHAR(enc, ptr, end);
579 switch (BYTE_TYPE(enc, ptr)) {
580 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
582 *nextTokPtr = ptr;
593 ptr += MINBPC(enc);
594 REQUIRE_CHAR(enc, ptr, end);
595 t = BYTE_TYPE(enc, ptr);
604 *nextTokPtr = ptr;
615 ptr += MINBPC(enc);
616 REQUIRE_CHAR(enc, ptr, end);
617 open = BYTE_TYPE(enc, ptr);
626 *nextTokPtr = ptr;
630 ptr += MINBPC(enc);
634 REQUIRE_CHAR(enc, ptr, end);
635 t = BYTE_TYPE(enc, ptr);
639 INVALID_CASES(ptr, nextTokPtr)
641 int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
644 *nextTokPtr = ptr;
650 *nextTokPtr = ptr;
653 ptr += MINBPC(enc);
657 ptr += MINBPC(enc);
658 REQUIRE_CHAR(enc, ptr, end);
659 switch (BYTE_TYPE(enc, ptr)) {
669 *nextTokPtr = ptr;
672 /* ptr points to closing quote */
674 ptr += MINBPC(enc);
675 REQUIRE_CHAR(enc, ptr, end);
676 switch (BYTE_TYPE(enc, ptr)) {
677 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
684 *nextTokPtr = ptr + MINBPC(enc);
688 ptr += MINBPC(enc);
689 REQUIRE_CHAR(enc, ptr, end);
690 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
691 *nextTokPtr = ptr;
694 *nextTokPtr = ptr + MINBPC(enc);
697 *nextTokPtr = ptr;
705 *nextTokPtr = ptr;
712 /* ptr points to character following "<" */
715 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
720 REQUIRE_CHAR(enc, ptr, end);
721 switch (BYTE_TYPE(enc, ptr)) {
722 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
724 ptr += MINBPC(enc);
725 REQUIRE_CHAR(enc, ptr, end);
726 switch (BYTE_TYPE(enc, ptr)) {
728 return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
730 return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
732 *nextTokPtr = ptr;
735 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
737 return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
739 *nextTokPtr = ptr;
746 while (HAS_CHAR(enc, ptr, end)) {
747 switch (BYTE_TYPE(enc, ptr)) {
748 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
752 *nextTokPtr = ptr;
756 ptr += MINBPC(enc);
757 REQUIRE_CHAR(enc, ptr, end);
758 switch (BYTE_TYPE(enc, ptr)) {
759 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
761 *nextTokPtr = ptr;
769 ptr += MINBPC(enc);
770 while (HAS_CHAR(enc, ptr, end)) {
771 switch (BYTE_TYPE(enc, ptr)) {
772 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
780 ptr += MINBPC(enc);
783 *nextTokPtr = ptr;
786 return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
792 *nextTokPtr = ptr + MINBPC(enc);
796 ptr += MINBPC(enc);
797 REQUIRE_CHAR(enc, ptr, end);
798 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
799 *nextTokPtr = ptr;
802 *nextTokPtr = ptr + MINBPC(enc);
805 *nextTokPtr = ptr;
813 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
815 if (ptr >= end)
818 size_t n = end - ptr;
823 end = ptr + n;
826 switch (BYTE_TYPE(enc, ptr)) {
828 return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
830 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
832 ptr += MINBPC(enc);
833 if (! HAS_CHAR(enc, ptr, end))
835 if (BYTE_TYPE(enc, ptr) == BT_LF)
836 ptr += MINBPC(enc);
837 *nextTokPtr = ptr;
840 *nextTokPtr = ptr + MINBPC(enc);
843 ptr += MINBPC(enc);
844 if (! HAS_CHAR(enc, ptr, end))
846 if (! CHAR_MATCHES(enc, ptr, ASCII_RSQB))
848 ptr += MINBPC(enc);
849 if (! HAS_CHAR(enc, ptr, end))
851 if (! CHAR_MATCHES(enc, ptr, ASCII_GT)) {
852 ptr -= MINBPC(enc);
855 *nextTokPtr = ptr;
857 INVALID_CASES(ptr, nextTokPtr)
859 ptr += MINBPC(enc);
862 while (HAS_CHAR(enc, ptr, end)) {
863 switch (BYTE_TYPE(enc, ptr)) {
866 if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
867 *nextTokPtr = ptr; \
870 ptr += n; \
877 if (HAS_CHARS(enc, ptr, end, 2)) {
878 if (! CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
879 ptr += MINBPC(enc);
882 if (HAS_CHARS(enc, ptr, end, 3)) {
883 if (! CHAR_MATCHES(enc, ptr + 2 * MINBPC(enc), ASCII_GT)) {
884 ptr += MINBPC(enc);
887 *nextTokPtr = ptr + 2 * MINBPC(enc);
899 *nextTokPtr = ptr;
902 ptr += MINBPC(enc);
906 *nextTokPtr = ptr;
910 /* ptr points to character following "%" */
913 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
915 REQUIRE_CHAR(enc, ptr, end);
916 switch (BYTE_TYPE(enc, ptr)) {
917 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
922 *nextTokPtr = ptr;
925 *nextTokPtr = ptr;
928 while (HAS_CHAR(enc, ptr, end)) {
929 switch (BYTE_TYPE(enc, ptr)) {
930 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
932 *nextTokPtr = ptr + MINBPC(enc);
935 *nextTokPtr = ptr;
943 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
945 REQUIRE_CHAR(enc, ptr, end);
946 switch (BYTE_TYPE(enc, ptr)) {
947 CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
949 *nextTokPtr = ptr;
952 while (HAS_CHAR(enc, ptr, end)) {
953 switch (BYTE_TYPE(enc, ptr)) {
954 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
962 *nextTokPtr = ptr;
965 *nextTokPtr = ptr;
973 PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
975 while (HAS_CHAR(enc, ptr, end)) {
976 int t = BYTE_TYPE(enc, ptr);
978 INVALID_CASES(ptr, nextTokPtr)
981 ptr += MINBPC(enc);
984 if (! HAS_CHAR(enc, ptr, end))
986 *nextTokPtr = ptr;
987 switch (BYTE_TYPE(enc, ptr)) {
999 ptr += MINBPC(enc);
1007 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
1010 if (ptr >= end)
1013 size_t n = end - ptr;
1018 end = ptr + n;
1021 switch (BYTE_TYPE(enc, ptr)) {
1023 return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
1025 return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
1027 ptr += MINBPC(enc);
1028 REQUIRE_CHAR(enc, ptr, end);
1029 switch (BYTE_TYPE(enc, ptr)) {
1031 return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1033 return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1040 *nextTokPtr = ptr - MINBPC(enc);
1043 *nextTokPtr = ptr;
1047 if (ptr + MINBPC(enc) == end) {
1056 ptr += MINBPC(enc);
1057 if (! HAS_CHAR(enc, ptr, end))
1059 switch (BYTE_TYPE(enc, ptr)) {
1065 if (ptr + MINBPC(enc) != end)
1069 *nextTokPtr = ptr;
1073 *nextTokPtr = ptr;
1076 return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1078 *nextTokPtr = ptr + MINBPC(enc);
1081 *nextTokPtr = ptr + MINBPC(enc);
1084 ptr += MINBPC(enc);
1085 if (! HAS_CHAR(enc, ptr, end))
1087 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1088 REQUIRE_CHARS(enc, ptr, end, 2);
1089 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
1090 *nextTokPtr = ptr + 2 * MINBPC(enc);
1094 *nextTokPtr = ptr;
1097 *nextTokPtr = ptr + MINBPC(enc);
1100 ptr += MINBPC(enc);
1101 if (! HAS_CHAR(enc, ptr, end))
1103 switch (BYTE_TYPE(enc, ptr)) {
1105 *nextTokPtr = ptr + MINBPC(enc);
1108 *nextTokPtr = ptr + MINBPC(enc);
1111 *nextTokPtr = ptr + MINBPC(enc);
1120 *nextTokPtr = ptr;
1123 *nextTokPtr = ptr;
1126 *nextTokPtr = ptr + MINBPC(enc);
1129 *nextTokPtr = ptr + MINBPC(enc);
1132 return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1135 if (end - ptr < n) \
1137 if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1138 ptr += n; \
1142 if (IS_NAME_CHAR(enc, ptr, n)) { \
1143 ptr += n; \
1147 *nextTokPtr = ptr; \
1156 ptr += MINBPC(enc);
1165 ptr += MINBPC(enc);
1168 if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
1169 ptr += MINBPC(enc);
1173 if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
1174 ptr += MINBPC(enc);
1180 *nextTokPtr = ptr;
1183 while (HAS_CHAR(enc, ptr, end)) {
1184 switch (BYTE_TYPE(enc, ptr)) {
1185 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1195 *nextTokPtr = ptr;
1199 ptr += MINBPC(enc);
1202 REQUIRE_CHAR(enc, ptr, end);
1204 switch (BYTE_TYPE(enc, ptr)) {
1205 CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1219 *nextTokPtr = ptr;
1222 *nextTokPtr = ptr + MINBPC(enc);
1226 *nextTokPtr = ptr;
1229 *nextTokPtr = ptr + MINBPC(enc);
1233 *nextTokPtr = ptr;
1236 *nextTokPtr = ptr + MINBPC(enc);
1239 *nextTokPtr = ptr;
1247 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
1250 if (ptr >= end)
1252 else if (! HAS_CHAR(enc, ptr, end)) {
1260 start = ptr;
1261 while (HAS_CHAR(enc, ptr, end)) {
1262 switch (BYTE_TYPE(enc, ptr)) {
1265 ptr += n; \
1272 if (ptr == start)
1273 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1274 *nextTokPtr = ptr;
1278 *nextTokPtr = ptr;
1281 if (ptr == start) {
1282 *nextTokPtr = ptr + MINBPC(enc);
1285 *nextTokPtr = ptr;
1288 if (ptr == start) {
1289 ptr += MINBPC(enc);
1290 if (! HAS_CHAR(enc, ptr, end))
1292 if (BYTE_TYPE(enc, ptr) == BT_LF)
1293 ptr += MINBPC(enc);
1294 *nextTokPtr = ptr;
1297 *nextTokPtr = ptr;
1300 if (ptr == start) {
1301 *nextTokPtr = ptr + MINBPC(enc);
1304 *nextTokPtr = ptr;
1307 ptr += MINBPC(enc);
1311 *nextTokPtr = ptr;
1316 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
1319 if (ptr >= end)
1321 else if (! HAS_CHAR(enc, ptr, end)) {
1329 start = ptr;
1330 while (HAS_CHAR(enc, ptr, end)) {
1331 switch (BYTE_TYPE(enc, ptr)) {
1334 ptr += n; \
1341 if (ptr == start)
1342 return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1343 *nextTokPtr = ptr;
1346 if (ptr == start) {
1347 int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1350 *nextTokPtr = ptr;
1353 if (ptr == start) {
1354 *nextTokPtr = ptr + MINBPC(enc);
1357 *nextTokPtr = ptr;
1360 if (ptr == start) {
1361 ptr += MINBPC(enc);
1362 if (! HAS_CHAR(enc, ptr, end))
1364 if (BYTE_TYPE(enc, ptr) == BT_LF)
1365 ptr += MINBPC(enc);
1366 *nextTokPtr = ptr;
1369 *nextTokPtr = ptr;
1372 ptr += MINBPC(enc);
1376 *nextTokPtr = ptr;
1383 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
1387 size_t n = end - ptr;
1390 end = ptr + n;
1393 while (HAS_CHAR(enc, ptr, end)) {
1394 switch (BYTE_TYPE(enc, ptr)) {
1395 INVALID_CASES(ptr, nextTokPtr)
1397 ptr += MINBPC(enc);
1398 REQUIRE_CHAR(enc, ptr, end);
1399 if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
1400 ptr += MINBPC(enc);
1401 REQUIRE_CHAR(enc, ptr, end);
1402 if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
1404 ptr += MINBPC(enc);
1409 ptr += MINBPC(enc);
1410 REQUIRE_CHAR(enc, ptr, end);
1411 if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
1412 ptr += MINBPC(enc);
1413 REQUIRE_CHAR(enc, ptr, end);
1414 if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
1415 ptr += MINBPC(enc);
1417 *nextTokPtr = ptr;
1425 ptr += MINBPC(enc);
1435 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1437 ptr += MINBPC(enc);
1439 for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
1440 switch (BYTE_TYPE(enc, ptr)) {
1464 if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1465 *badPtr = ptr;
1471 if (! (BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1475 switch (BYTE_TO_ASCII(enc, ptr)) {
1480 *badPtr = ptr;
1495 PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
1502 for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1503 switch (BYTE_TYPE(enc, ptr)) {
1507 atts[nAtts].name = ptr; \
1514 START_NAME ptr += (n - MINBPC(enc)); \
1529 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1535 atts[nAtts].valueEnd = ptr;
1542 atts[nAtts].valuePtr = ptr + MINBPC(enc);
1548 atts[nAtts].valueEnd = ptr;
1560 && (ptr == atts[nAtts].valuePtr
1561 || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
1562 || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
1563 || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
1588 PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
1592 ptr += 2 * MINBPC(enc);
1593 if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
1594 for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
1595 ptr += MINBPC(enc)) {
1596 int c = BYTE_TO_ASCII(enc, ptr);
1634 for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
1635 int c = BYTE_TO_ASCII(enc, ptr);
1646 PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
1649 switch ((end - ptr) / MINBPC(enc)) {
1651 if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
1652 switch (BYTE_TO_ASCII(enc, ptr)) {
1661 if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
1662 ptr += MINBPC(enc);
1663 if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
1664 ptr += MINBPC(enc);
1665 if (CHAR_MATCHES(enc, ptr, ASCII_p))
1671 switch (BYTE_TO_ASCII(enc, ptr)) {
1673 ptr += MINBPC(enc);
1674 if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
1675 ptr += MINBPC(enc);
1676 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1677 ptr += MINBPC(enc);
1678 if (CHAR_MATCHES(enc, ptr, ASCII_t))
1684 ptr += MINBPC(enc);
1685 if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
1686 ptr += MINBPC(enc);
1687 if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
1688 ptr += MINBPC(enc);
1689 if (CHAR_MATCHES(enc, ptr, ASCII_s))
1719 PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
1720 const char *start = ptr;
1722 switch (BYTE_TYPE(enc, ptr)) {
1725 ptr += n; \
1740 ptr += MINBPC(enc);
1743 return (int)(ptr - start);
1749 PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
1751 switch (BYTE_TYPE(enc, ptr)) {
1755 ptr += MINBPC(enc);
1758 return ptr;
1764 PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
1766 while (HAS_CHAR(enc, ptr, end)) {
1767 switch (BYTE_TYPE(enc, ptr)) {
1770 ptr += n; \
1779 ptr += MINBPC(enc);
1783 ptr += MINBPC(enc);
1784 if (HAS_CHAR(enc, ptr, end) && BYTE_TYPE(enc, ptr) == BT_LF)
1785 ptr += MINBPC(enc);
1789 ptr += MINBPC(enc);