expat/lib/xmltok_impl.c

9 #define IS_INVALID_CHAR(enc, ptr, n) (0)
12 #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
14       if (end - ptr < n) \
16       if (IS_INVALID_CHAR(enc, ptr, n)) { \
17         *(nextTokPtr) = (ptr); \
20       ptr += n; \
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) \
30     *(nextTokPtr) = (ptr); \
33 #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
35      if (end - ptr < n) \
37      if (!IS_NAME_CHAR(enc, ptr, n)) { \
38        *nextTokPtr = ptr; \
41      ptr += n; \
44 #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
46     if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
47       *nextTokPtr = 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) \
63      if (end - ptr < n) \
65      if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
66        *nextTokPtr = ptr; \
69      ptr += n; \
72 #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
74     if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
75       *nextTokPtr = 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)
90 /* ptr points to character following "<!-" */
93 PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
96   if (ptr != end) {
97     if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
98       *nextTokPtr = ptr;
101     ptr += MINBPC(enc);
102     while (ptr != end) {
103       switch (BYTE_TYPE(enc, ptr)) {
104       INVALID_CASES(ptr, nextTokPtr)
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)) {
112             *nextTokPtr = ptr;
115           *nextTokPtr = ptr + MINBPC(enc);
120         ptr += MINBPC(enc);
128 /* ptr points to character following "<!" */
131 PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
134   if (ptr == end)
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);
147     *nextTokPtr = ptr;
150   while (ptr != end) {
151     switch (BYTE_TYPE(enc, ptr)) {
153       if (ptr + MINBPC(enc) == end)
156       switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
158         *nextTokPtr = ptr;
163       *nextTokPtr = ptr;
167       ptr += MINBPC(enc);
170       *nextTokPtr = ptr;
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)) {
220 /* ptr points to character following "<?" */
223 PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
227   const char *target = ptr;
228   if (ptr == end)
230   switch (BYTE_TYPE(enc, ptr)) {
231   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
233     *nextTokPtr = ptr;
236   while (ptr != end) {
237     switch (BYTE_TYPE(enc, ptr)) {
238     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
240       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
241         *nextTokPtr = ptr;
244       ptr += MINBPC(enc);
245       while (ptr != end) {
246         switch (BYTE_TYPE(enc, ptr)) {
247         INVALID_CASES(ptr, nextTokPtr)
249           ptr += MINBPC(enc);
250           if (ptr == end)
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)) {
265         *nextTokPtr = ptr;
268       ptr += MINBPC(enc);
269       if (ptr == end)
271       if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
272         *nextTokPtr = ptr + MINBPC(enc);
277       *nextTokPtr = ptr;
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])) {
296       *nextTokPtr = ptr;
300   *nextTokPtr = ptr;
305 PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
308   if (ptr == end)
311     size_t n = end - ptr;
316       end = ptr + n;
319   switch (BYTE_TYPE(enc, ptr)) {
321     ptr += MINBPC(enc);
322     if (ptr == end)
324     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
326     ptr += MINBPC(enc);
327     if (ptr == end)
329     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
330       ptr -= MINBPC(enc);
333     *nextTokPtr = ptr + MINBPC(enc);
336     ptr += MINBPC(enc);
337     if (ptr == end)
339     if (BYTE_TYPE(enc, ptr) == BT_LF)
340       ptr += MINBPC(enc);
341     *nextTokPtr = ptr;
344     *nextTokPtr = ptr + MINBPC(enc);
346   INVALID_CASES(ptr, nextTokPtr)
348     ptr += MINBPC(enc);
351   while (ptr != end) {
352     switch (BYTE_TYPE(enc, ptr)) {
355       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
356         *nextTokPtr = ptr; \
359       ptr += n; \
369       *nextTokPtr = ptr;
372       ptr += MINBPC(enc);
376   *nextTokPtr = ptr;
380 /* ptr points to character following "</" */
383 PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
386   if (ptr == end)
388   switch (BYTE_TYPE(enc, ptr)) {
389   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
391     *nextTokPtr = ptr;
394   while (ptr != end) {
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);
406           *nextTokPtr = ptr;
415       ptr += MINBPC(enc);
419       *nextTokPtr = ptr + MINBPC(enc);
422       *nextTokPtr = ptr;
429 /* ptr points to character following "&#X" */
432 PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
435   if (ptr != end) {
436     switch (BYTE_TYPE(enc, ptr)) {
441       *nextTokPtr = ptr;
444     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
445       switch (BYTE_TYPE(enc, ptr)) {
450         *nextTokPtr = ptr + MINBPC(enc);
453         *nextTokPtr = ptr;
461 /* ptr points to character following "&#" */
464 PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
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)) {
474       *nextTokPtr = ptr;
477     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
478       switch (BYTE_TYPE(enc, ptr)) {
482         *nextTokPtr = ptr + MINBPC(enc);
485         *nextTokPtr = ptr;
493 /* ptr points to character following "&" */
496 PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
499   if (ptr == 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);
506     *nextTokPtr = ptr;
509   while (ptr != end) {
510     switch (BYTE_TYPE(enc, ptr)) {
511     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
513       *nextTokPtr = ptr + MINBPC(enc);
516       *nextTokPtr = ptr;
523 /* ptr points to character following first character of attribute name */
526 PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
532   while (ptr != end) {
533     switch (BYTE_TYPE(enc, ptr)) {
534     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
538         *nextTokPtr = ptr;
542       ptr += MINBPC(enc);
543       if (ptr == end)
545       switch (BYTE_TYPE(enc, ptr)) {
546       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
548         *nextTokPtr = ptr;
557         ptr += MINBPC(enc);
558         if (ptr == end)
560         t = BYTE_TYPE(enc, ptr);
569           *nextTokPtr = ptr;
581           ptr += MINBPC(enc);
582           if (ptr == end)
584           open = BYTE_TYPE(enc, ptr);
593             *nextTokPtr = ptr;
597         ptr += MINBPC(enc);
601           if (ptr == end)
603           t = BYTE_TYPE(enc, ptr);
607           INVALID_CASES(ptr, nextTokPtr)
610               int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
613                   *nextTokPtr = ptr;
619             *nextTokPtr = ptr;
622             ptr += MINBPC(enc);
626         ptr += MINBPC(enc);
627         if (ptr == end)
629         switch (BYTE_TYPE(enc, ptr)) {
639           *nextTokPtr = ptr;
642         /* ptr points to closing quote */
644           ptr += MINBPC(enc);
645           if (ptr == end)
647           switch (BYTE_TYPE(enc, ptr)) {
648           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
653             *nextTokPtr = ptr + MINBPC(enc);
657             ptr += MINBPC(enc);
658             if (ptr == end)
660             if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
661               *nextTokPtr = ptr;
664             *nextTokPtr = ptr + MINBPC(enc);
667             *nextTokPtr = ptr;
675       *nextTokPtr = ptr;
682 /* ptr points to character following "<" */
685 PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
691   if (ptr == 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),
705     *nextTokPtr = ptr;
708     return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
710     return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
712     *nextTokPtr = ptr;
719   while (ptr != end) {
720     switch (BYTE_TYPE(enc, ptr)) {
721     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
725         *nextTokPtr = ptr;
729       ptr += MINBPC(enc);
730       if (ptr == end)
732       switch (BYTE_TYPE(enc, ptr)) {
733       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
735         *nextTokPtr = ptr;
742         ptr += MINBPC(enc);
743         while (ptr != end) {
744           switch (BYTE_TYPE(enc, ptr)) {
745           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
751             ptr += MINBPC(enc);
754             *nextTokPtr = ptr;
757           return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
763       *nextTokPtr = ptr + MINBPC(enc);
767       ptr += MINBPC(enc);
768       if (ptr == end)
770       if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
771         *nextTokPtr = ptr;
774       *nextTokPtr = ptr + MINBPC(enc);
777       *nextTokPtr = ptr;
785 PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
788   if (ptr == end)
791     size_t n = end - ptr;
796       end = ptr + n;
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);
806     if (ptr == end)
808     if (BYTE_TYPE(enc, ptr) == BT_LF)
809       ptr += MINBPC(enc);
810     *nextTokPtr = ptr;
813     *nextTokPtr = ptr + MINBPC(enc);
816     ptr += MINBPC(enc);
817     if (ptr == end)
819     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
821     ptr += MINBPC(enc);
822     if (ptr == end)
824     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
825       ptr -= MINBPC(enc);
828     *nextTokPtr = ptr;
830   INVALID_CASES(ptr, nextTokPtr)
832     ptr += MINBPC(enc);
835   while (ptr != end) {
836     switch (BYTE_TYPE(enc, ptr)) {
839       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
840         *nextTokPtr = ptr; \
843       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);
870       *nextTokPtr = ptr;
873       ptr += MINBPC(enc);
877   *nextTokPtr = ptr;
881 /* ptr points to character following "%" */
884 PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
887   if (ptr == end)
889   switch (BYTE_TYPE(enc, ptr)) {
890   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
892     *nextTokPtr = ptr;
895     *nextTokPtr = ptr;
898   while (ptr != end) {
899     switch (BYTE_TYPE(enc, ptr)) {
900     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
902       *nextTokPtr = ptr + MINBPC(enc);
905       *nextTokPtr = ptr;
913 PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
916   if (ptr == end)
918   switch (BYTE_TYPE(enc, ptr)) {
919   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
921     *nextTokPtr = ptr;
924   while (ptr != end) {
925     switch (BYTE_TYPE(enc, ptr)) {
926     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
929       *nextTokPtr = ptr;
932       *nextTokPtr = ptr;
941                 const char *ptr, const char *end,
944   while (ptr != end) {
945     int t = BYTE_TYPE(enc, ptr);
947     INVALID_CASES(ptr, nextTokPtr)
950       ptr += MINBPC(enc);
953       if (ptr == end)
955       *nextTokPtr = ptr;
956       switch (BYTE_TYPE(enc, ptr)) {
964       ptr += MINBPC(enc);
972 PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
976   if (ptr == end)
979     size_t n = end - ptr;
984       end = ptr + n;
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);
995       if (ptr == end)
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);
1011       *nextTokPtr = ptr;
1015     if (ptr + MINBPC(enc) == end) {
1023       ptr += MINBPC(enc);
1024       if (ptr == end)
1026       switch (BYTE_TYPE(enc, ptr)) {
1031         if (ptr + MINBPC(enc) != end)
1035         *nextTokPtr = ptr;
1039     *nextTokPtr = ptr;
1042     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1044     *nextTokPtr = ptr + MINBPC(enc);
1047     *nextTokPtr = ptr + MINBPC(enc);
1050     ptr += MINBPC(enc);
1051     if (ptr == end)
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);
1061     *nextTokPtr = ptr;
1064     *nextTokPtr = ptr + MINBPC(enc);
1067     ptr += MINBPC(enc);
1068     if (ptr == end)
1070     switch (BYTE_TYPE(enc, ptr)) {
1072       *nextTokPtr = ptr + MINBPC(enc);
1075       *nextTokPtr = ptr + MINBPC(enc);
1078       *nextTokPtr = ptr + MINBPC(enc);
1083       *nextTokPtr = ptr;
1086     *nextTokPtr = ptr;
1089     *nextTokPtr = ptr + MINBPC(enc);
1092     *nextTokPtr = ptr + MINBPC(enc);
1095     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1098     if (end - ptr < n) \
1100     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
1101       ptr += n; \
1105     if (IS_NAME_CHAR(enc, ptr, n)) { \
1106       ptr += n; \
1110     *nextTokPtr = ptr; \
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);
1141     *nextTokPtr = ptr;
1144   while (ptr != end) {
1145     switch (BYTE_TYPE(enc, ptr)) {
1146     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1150       *nextTokPtr = ptr;
1154       ptr += MINBPC(enc);
1157         if (ptr == end)
1160         switch (BYTE_TYPE(enc, ptr)) {
1161         CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
1175         *nextTokPtr = ptr;
1178       *nextTokPtr = ptr + MINBPC(enc);
1182         *nextTokPtr = ptr;
1185       *nextTokPtr = ptr + MINBPC(enc);
1189         *nextTokPtr = ptr;
1192       *nextTokPtr = ptr + MINBPC(enc);
1195       *nextTokPtr = ptr;
1203 PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
1207   if (ptr == end)
1209   start = ptr;
1210   while (ptr != end) {
1211     switch (BYTE_TYPE(enc, ptr)) {
1213     case BT_LEAD ## n: ptr += n; break;
1217       if (ptr == start)
1218         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1219       *nextTokPtr = ptr;
1223       *nextTokPtr = ptr;
1226       if (ptr == start) {
1227         *nextTokPtr = ptr + MINBPC(enc);
1230       *nextTokPtr = ptr;
1233       if (ptr == start) {
1234         ptr += MINBPC(enc);
1235         if (ptr == end)
1237         if (BYTE_TYPE(enc, ptr) == BT_LF)
1238           ptr += MINBPC(enc);
1239         *nextTokPtr = ptr;
1242       *nextTokPtr = ptr;
1245       if (ptr == start) {
1246         *nextTokPtr = ptr + MINBPC(enc);
1249       *nextTokPtr = ptr;
1252       ptr += MINBPC(enc);
1256   *nextTokPtr = ptr;
1261 PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
1265   if (ptr == end)
1267   start = ptr;
1268   while (ptr != end) {
1269     switch (BYTE_TYPE(enc, ptr)) {
1271     case BT_LEAD ## n: ptr += n; break;
1275       if (ptr == start)
1276         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
1277       *nextTokPtr = ptr;
1280       if (ptr == start) {
1281         int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
1285       *nextTokPtr = ptr;
1288       if (ptr == start) {
1289         *nextTokPtr = ptr + MINBPC(enc);
1292       *nextTokPtr = ptr;
1295       if (ptr == start) {
1296         ptr += MINBPC(enc);
1297         if (ptr == end)
1299         if (BYTE_TYPE(enc, ptr) == BT_LF)
1300           ptr += MINBPC(enc);
1301         *nextTokPtr = ptr;
1304       *nextTokPtr = ptr;
1307       ptr += MINBPC(enc);
1311   *nextTokPtr = ptr;
1318 PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
1323     size_t n = end - ptr;
1326       end = ptr + n;
1329   while (ptr != end) {
1330     switch (BYTE_TYPE(enc, ptr)) {
1331     INVALID_CASES(ptr, nextTokPtr)
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);
1353             *nextTokPtr = ptr;
1361       ptr += MINBPC(enc);
1371 PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
1374   ptr += MINBPC(enc);
1376   for (; ptr != end; ptr += MINBPC(enc)) {
1377     switch (BYTE_TYPE(enc, ptr)) {
1401       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
1402         *badPtr = ptr;
1408       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
1411       switch (BYTE_TO_ASCII(enc, ptr)) {
1416         *badPtr = ptr;
1431 PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
1439   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
1440     switch (BYTE_TYPE(enc, ptr)) {
1444           atts[nAtts].name = ptr; \
1450     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
1462           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1469           atts[nAtts].valueEnd = ptr;
1476           atts[nAtts].valuePtr = ptr + MINBPC(enc);
1483           atts[nAtts].valueEnd = ptr;
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))
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))
1699 PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
1701   const char *start = ptr;
1703     switch (BYTE_TYPE(enc, ptr)) {
1705     case BT_LEAD ## n: ptr += n; break;
1717       ptr += MINBPC(enc);
1720       return (int)(ptr - start);
1726 PREFIX(skipS)(const ENCODING *enc, const char *ptr)
1729     switch (BYTE_TYPE(enc, ptr)) {
1733       ptr += MINBPC(enc);
1736       return ptr;
1743                        const char *ptr,
1747   while (ptr < end) {
1748     switch (BYTE_TYPE(enc, ptr)) {
1751       ptr += n; \
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);