Annotation of embedaddon/expat/lib/xmltok_impl.c, revision 1.1.1.1.2.1

1.1       misho       1: /* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
                      2:    See the file COPYING for copying permission.
                      3: */
                      4: 
                      5: /* This file is included! */
                      6: #ifdef XML_TOK_IMPL_C
                      7: 
                      8: #ifndef IS_INVALID_CHAR
                      9: #define IS_INVALID_CHAR(enc, ptr, n) (0)
                     10: #endif
                     11: 
                     12: #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
                     13:     case BT_LEAD ## n: \
                     14:       if (end - ptr < n) \
                     15:         return XML_TOK_PARTIAL_CHAR; \
                     16:       if (IS_INVALID_CHAR(enc, ptr, n)) { \
                     17:         *(nextTokPtr) = (ptr); \
                     18:         return XML_TOK_INVALID; \
                     19:       } \
                     20:       ptr += n; \
                     21:       break;
                     22: 
                     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) \
                     27:   case BT_NONXML: \
                     28:   case BT_MALFORM: \
                     29:   case BT_TRAIL: \
                     30:     *(nextTokPtr) = (ptr); \
                     31:     return XML_TOK_INVALID;
                     32: 
                     33: #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
                     34:    case BT_LEAD ## n: \
                     35:      if (end - ptr < n) \
                     36:        return XML_TOK_PARTIAL_CHAR; \
                     37:      if (!IS_NAME_CHAR(enc, ptr, n)) { \
                     38:        *nextTokPtr = ptr; \
                     39:        return XML_TOK_INVALID; \
                     40:      } \
                     41:      ptr += n; \
                     42:      break;
                     43: 
                     44: #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
                     45:   case BT_NONASCII: \
                     46:     if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
                     47:       *nextTokPtr = ptr; \
                     48:       return XML_TOK_INVALID; \
                     49:     } \
                     50:   case BT_NMSTRT: \
                     51:   case BT_HEX: \
                     52:   case BT_DIGIT: \
                     53:   case BT_NAME: \
                     54:   case BT_MINUS: \
                     55:     ptr += MINBPC(enc); \
                     56:     break; \
                     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)
                     60: 
                     61: #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
                     62:    case BT_LEAD ## n: \
                     63:      if (end - ptr < n) \
                     64:        return XML_TOK_PARTIAL_CHAR; \
                     65:      if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
                     66:        *nextTokPtr = ptr; \
                     67:        return XML_TOK_INVALID; \
                     68:      } \
                     69:      ptr += n; \
                     70:      break;
                     71: 
                     72: #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
                     73:   case BT_NONASCII: \
                     74:     if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
                     75:       *nextTokPtr = ptr; \
                     76:       return XML_TOK_INVALID; \
                     77:     } \
                     78:   case BT_NMSTRT: \
                     79:   case BT_HEX: \
                     80:     ptr += MINBPC(enc); \
                     81:     break; \
                     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)
                     85: 
                     86: #ifndef PREFIX
                     87: #define PREFIX(ident) ident
                     88: #endif
                     89: 
                     90: /* ptr points to character following "<!-" */
                     91: 
                     92: static int PTRCALL
                     93: PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
                     94:                     const char *end, const char **nextTokPtr)
                     95: {
                     96:   if (ptr != end) {
                     97:     if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
                     98:       *nextTokPtr = ptr;
                     99:       return XML_TOK_INVALID;
                    100:     }
                    101:     ptr += MINBPC(enc);
                    102:     while (ptr != end) {
                    103:       switch (BYTE_TYPE(enc, ptr)) {
                    104:       INVALID_CASES(ptr, nextTokPtr)
                    105:       case BT_MINUS:
                    106:         if ((ptr += MINBPC(enc)) == end)
                    107:           return XML_TOK_PARTIAL;
                    108:         if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
                    109:           if ((ptr += MINBPC(enc)) == end)
                    110:             return XML_TOK_PARTIAL;
                    111:           if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    112:             *nextTokPtr = ptr;
                    113:             return XML_TOK_INVALID;
                    114:           }
                    115:           *nextTokPtr = ptr + MINBPC(enc);
                    116:           return XML_TOK_COMMENT;
                    117:         }
                    118:         break;
                    119:       default:
                    120:         ptr += MINBPC(enc);
                    121:         break;
                    122:       }
                    123:     }
                    124:   }
                    125:   return XML_TOK_PARTIAL;
                    126: }
                    127: 
                    128: /* ptr points to character following "<!" */
                    129: 
                    130: static int PTRCALL
                    131: PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
                    132:                  const char *end, const char **nextTokPtr)
                    133: {
                    134:   if (ptr == end)
                    135:     return XML_TOK_PARTIAL;
                    136:   switch (BYTE_TYPE(enc, ptr)) {
                    137:   case BT_MINUS:
                    138:     return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    139:   case BT_LSQB:
                    140:     *nextTokPtr = ptr + MINBPC(enc);
                    141:     return XML_TOK_COND_SECT_OPEN;
                    142:   case BT_NMSTRT:
                    143:   case BT_HEX:
                    144:     ptr += MINBPC(enc);
                    145:     break;
                    146:   default:
                    147:     *nextTokPtr = ptr;
                    148:     return XML_TOK_INVALID;
                    149:   }
                    150:   while (ptr != end) {
                    151:     switch (BYTE_TYPE(enc, ptr)) {
                    152:     case BT_PERCNT:
                    153:       if (ptr + MINBPC(enc) == end)
                    154:         return XML_TOK_PARTIAL;
                    155:       /* don't allow <!ENTITY% foo "whatever"> */
                    156:       switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
                    157:       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
                    158:         *nextTokPtr = ptr;
                    159:         return XML_TOK_INVALID;
                    160:       }
                    161:       /* fall through */
                    162:     case BT_S: case BT_CR: case BT_LF:
                    163:       *nextTokPtr = ptr;
                    164:       return XML_TOK_DECL_OPEN;
                    165:     case BT_NMSTRT:
                    166:     case BT_HEX:
                    167:       ptr += MINBPC(enc);
                    168:       break;
                    169:     default:
                    170:       *nextTokPtr = ptr;
                    171:       return XML_TOK_INVALID;
                    172:     }
                    173:   }
                    174:   return XML_TOK_PARTIAL;
                    175: }
                    176: 
                    177: static int PTRCALL
                    178: PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
                    179:                       const char *end, int *tokPtr)
                    180: {
                    181:   int upper = 0;
                    182:   *tokPtr = XML_TOK_PI;
                    183:   if (end - ptr != MINBPC(enc)*3)
                    184:     return 1;
                    185:   switch (BYTE_TO_ASCII(enc, ptr)) {
                    186:   case ASCII_x:
                    187:     break;
                    188:   case ASCII_X:
                    189:     upper = 1;
                    190:     break;
                    191:   default:
                    192:     return 1;
                    193:   }
                    194:   ptr += MINBPC(enc);
                    195:   switch (BYTE_TO_ASCII(enc, ptr)) {
                    196:   case ASCII_m:
                    197:     break;
                    198:   case ASCII_M:
                    199:     upper = 1;
                    200:     break;
                    201:   default:
                    202:     return 1;
                    203:   }
                    204:   ptr += MINBPC(enc);
                    205:   switch (BYTE_TO_ASCII(enc, ptr)) {
                    206:   case ASCII_l:
                    207:     break;
                    208:   case ASCII_L:
                    209:     upper = 1;
                    210:     break;
                    211:   default:
                    212:     return 1;
                    213:   }
                    214:   if (upper)
                    215:     return 0;
                    216:   *tokPtr = XML_TOK_XML_DECL;
                    217:   return 1;
                    218: }
                    219: 
                    220: /* ptr points to character following "<?" */
                    221: 
                    222: static int PTRCALL
                    223: PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
                    224:                const char *end, const char **nextTokPtr)
                    225: {
                    226:   int tok;
                    227:   const char *target = ptr;
                    228:   if (ptr == end)
                    229:     return XML_TOK_PARTIAL;
                    230:   switch (BYTE_TYPE(enc, ptr)) {
                    231:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    232:   default:
                    233:     *nextTokPtr = ptr;
                    234:     return XML_TOK_INVALID;
                    235:   }
                    236:   while (ptr != end) {
                    237:     switch (BYTE_TYPE(enc, ptr)) {
                    238:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    239:     case BT_S: case BT_CR: case BT_LF:
                    240:       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
                    241:         *nextTokPtr = ptr;
                    242:         return XML_TOK_INVALID;
                    243:       }
                    244:       ptr += MINBPC(enc);
                    245:       while (ptr != end) {
                    246:         switch (BYTE_TYPE(enc, ptr)) {
                    247:         INVALID_CASES(ptr, nextTokPtr)
                    248:         case BT_QUEST:
                    249:           ptr += MINBPC(enc);
                    250:           if (ptr == end)
                    251:             return XML_TOK_PARTIAL;
                    252:           if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    253:             *nextTokPtr = ptr + MINBPC(enc);
                    254:             return tok;
                    255:           }
                    256:           break;
                    257:         default:
                    258:           ptr += MINBPC(enc);
                    259:           break;
                    260:         }
                    261:       }
                    262:       return XML_TOK_PARTIAL;
                    263:     case BT_QUEST:
                    264:       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
                    265:         *nextTokPtr = ptr;
                    266:         return XML_TOK_INVALID;
                    267:       }
                    268:       ptr += MINBPC(enc);
                    269:       if (ptr == end)
                    270:         return XML_TOK_PARTIAL;
                    271:       if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    272:         *nextTokPtr = ptr + MINBPC(enc);
                    273:         return tok;
                    274:       }
                    275:       /* fall through */
                    276:     default:
                    277:       *nextTokPtr = ptr;
                    278:       return XML_TOK_INVALID;
                    279:     }
                    280:   }
                    281:   return XML_TOK_PARTIAL;
                    282: }
                    283: 
                    284: static int PTRCALL
                    285: PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
                    286:                          const char *end, const char **nextTokPtr)
                    287: {
                    288:   static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
                    289:                                      ASCII_T, ASCII_A, ASCII_LSQB };
                    290:   int i;
                    291:   /* CDATA[ */
                    292:   if (end - ptr < 6 * MINBPC(enc))
                    293:     return XML_TOK_PARTIAL;
                    294:   for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
                    295:     if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
                    296:       *nextTokPtr = ptr;
                    297:       return XML_TOK_INVALID;
                    298:     }
                    299:   }
                    300:   *nextTokPtr = ptr;
                    301:   return XML_TOK_CDATA_SECT_OPEN;
                    302: }
                    303: 
                    304: static int PTRCALL
                    305: PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
                    306:                         const char *end, const char **nextTokPtr)
                    307: {
                    308:   if (ptr == end)
                    309:     return XML_TOK_NONE;
                    310:   if (MINBPC(enc) > 1) {
                    311:     size_t n = end - ptr;
                    312:     if (n & (MINBPC(enc) - 1)) {
                    313:       n &= ~(MINBPC(enc) - 1);
                    314:       if (n == 0)
                    315:         return XML_TOK_PARTIAL;
                    316:       end = ptr + n;
                    317:     }
                    318:   }
                    319:   switch (BYTE_TYPE(enc, ptr)) {
                    320:   case BT_RSQB:
                    321:     ptr += MINBPC(enc);
                    322:     if (ptr == end)
                    323:       return XML_TOK_PARTIAL;
                    324:     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
                    325:       break;
                    326:     ptr += MINBPC(enc);
                    327:     if (ptr == end)
                    328:       return XML_TOK_PARTIAL;
                    329:     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    330:       ptr -= MINBPC(enc);
                    331:       break;
                    332:     }
                    333:     *nextTokPtr = ptr + MINBPC(enc);
                    334:     return XML_TOK_CDATA_SECT_CLOSE;
                    335:   case BT_CR:
                    336:     ptr += MINBPC(enc);
                    337:     if (ptr == end)
                    338:       return XML_TOK_PARTIAL;
                    339:     if (BYTE_TYPE(enc, ptr) == BT_LF)
                    340:       ptr += MINBPC(enc);
                    341:     *nextTokPtr = ptr;
                    342:     return XML_TOK_DATA_NEWLINE;
                    343:   case BT_LF:
                    344:     *nextTokPtr = ptr + MINBPC(enc);
                    345:     return XML_TOK_DATA_NEWLINE;
                    346:   INVALID_CASES(ptr, nextTokPtr)
                    347:   default:
                    348:     ptr += MINBPC(enc);
                    349:     break;
                    350:   }
                    351:   while (ptr != end) {
                    352:     switch (BYTE_TYPE(enc, ptr)) {
                    353: #define LEAD_CASE(n) \
                    354:     case BT_LEAD ## n: \
                    355:       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
                    356:         *nextTokPtr = ptr; \
                    357:         return XML_TOK_DATA_CHARS; \
                    358:       } \
                    359:       ptr += n; \
                    360:       break;
                    361:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                    362: #undef LEAD_CASE
                    363:     case BT_NONXML:
                    364:     case BT_MALFORM:
                    365:     case BT_TRAIL:
                    366:     case BT_CR:
                    367:     case BT_LF:
                    368:     case BT_RSQB:
                    369:       *nextTokPtr = ptr;
                    370:       return XML_TOK_DATA_CHARS;
                    371:     default:
                    372:       ptr += MINBPC(enc);
                    373:       break;
                    374:     }
                    375:   }
                    376:   *nextTokPtr = ptr;
                    377:   return XML_TOK_DATA_CHARS;
                    378: }
                    379: 
                    380: /* ptr points to character following "</" */
                    381: 
                    382: static int PTRCALL
                    383: PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
                    384:                    const char *end, const char **nextTokPtr)
                    385: {
                    386:   if (ptr == end)
                    387:     return XML_TOK_PARTIAL;
                    388:   switch (BYTE_TYPE(enc, ptr)) {
                    389:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    390:   default:
                    391:     *nextTokPtr = ptr;
                    392:     return XML_TOK_INVALID;
                    393:   }
                    394:   while (ptr != end) {
                    395:     switch (BYTE_TYPE(enc, ptr)) {
                    396:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    397:     case BT_S: case BT_CR: case BT_LF:
                    398:       for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
                    399:         switch (BYTE_TYPE(enc, ptr)) {
                    400:         case BT_S: case BT_CR: case BT_LF:
                    401:           break;
                    402:         case BT_GT:
                    403:           *nextTokPtr = ptr + MINBPC(enc);
                    404:           return XML_TOK_END_TAG;
                    405:         default:
                    406:           *nextTokPtr = ptr;
                    407:           return XML_TOK_INVALID;
                    408:         }
                    409:       }
                    410:       return XML_TOK_PARTIAL;
                    411: #ifdef XML_NS
                    412:     case BT_COLON:
                    413:       /* no need to check qname syntax here,
                    414:          since end-tag must match exactly */
                    415:       ptr += MINBPC(enc);
                    416:       break;
                    417: #endif
                    418:     case BT_GT:
                    419:       *nextTokPtr = ptr + MINBPC(enc);
                    420:       return XML_TOK_END_TAG;
                    421:     default:
                    422:       *nextTokPtr = ptr;
                    423:       return XML_TOK_INVALID;
                    424:     }
                    425:   }
                    426:   return XML_TOK_PARTIAL;
                    427: }
                    428: 
                    429: /* ptr points to character following "&#X" */
                    430: 
                    431: static int PTRCALL
                    432: PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
                    433:                        const char *end, const char **nextTokPtr)
                    434: {
                    435:   if (ptr != end) {
                    436:     switch (BYTE_TYPE(enc, ptr)) {
                    437:     case BT_DIGIT:
                    438:     case BT_HEX:
                    439:       break;
                    440:     default:
                    441:       *nextTokPtr = ptr;
                    442:       return XML_TOK_INVALID;
                    443:     }
                    444:     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
                    445:       switch (BYTE_TYPE(enc, ptr)) {
                    446:       case BT_DIGIT:
                    447:       case BT_HEX:
                    448:         break;
                    449:       case BT_SEMI:
                    450:         *nextTokPtr = ptr + MINBPC(enc);
                    451:         return XML_TOK_CHAR_REF;
                    452:       default:
                    453:         *nextTokPtr = ptr;
                    454:         return XML_TOK_INVALID;
                    455:       }
                    456:     }
                    457:   }
                    458:   return XML_TOK_PARTIAL;
                    459: }
                    460: 
                    461: /* ptr points to character following "&#" */
                    462: 
                    463: static int PTRCALL
                    464: PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
                    465:                     const char *end, const char **nextTokPtr)
                    466: {
                    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)) {
                    471:     case BT_DIGIT:
                    472:       break;
                    473:     default:
                    474:       *nextTokPtr = ptr;
                    475:       return XML_TOK_INVALID;
                    476:     }
                    477:     for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
                    478:       switch (BYTE_TYPE(enc, ptr)) {
                    479:       case BT_DIGIT:
                    480:         break;
                    481:       case BT_SEMI:
                    482:         *nextTokPtr = ptr + MINBPC(enc);
                    483:         return XML_TOK_CHAR_REF;
                    484:       default:
                    485:         *nextTokPtr = ptr;
                    486:         return XML_TOK_INVALID;
                    487:       }
                    488:     }
                    489:   }
                    490:   return XML_TOK_PARTIAL;
                    491: }
                    492: 
                    493: /* ptr points to character following "&" */
                    494: 
                    495: static int PTRCALL
                    496: PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
                    497:                 const char **nextTokPtr)
                    498: {
                    499:   if (ptr == end)
                    500:     return XML_TOK_PARTIAL;
                    501:   switch (BYTE_TYPE(enc, ptr)) {
                    502:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    503:   case BT_NUM:
                    504:     return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    505:   default:
                    506:     *nextTokPtr = ptr;
                    507:     return XML_TOK_INVALID;
                    508:   }
                    509:   while (ptr != end) {
                    510:     switch (BYTE_TYPE(enc, ptr)) {
                    511:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    512:     case BT_SEMI:
                    513:       *nextTokPtr = ptr + MINBPC(enc);
                    514:       return XML_TOK_ENTITY_REF;
                    515:     default:
                    516:       *nextTokPtr = ptr;
                    517:       return XML_TOK_INVALID;
                    518:     }
                    519:   }
                    520:   return XML_TOK_PARTIAL;
                    521: }
                    522: 
                    523: /* ptr points to character following first character of attribute name */
                    524: 
                    525: static int PTRCALL
                    526: PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
                    527:                  const char **nextTokPtr)
                    528: {
                    529: #ifdef XML_NS
                    530:   int hadColon = 0;
                    531: #endif
                    532:   while (ptr != end) {
                    533:     switch (BYTE_TYPE(enc, ptr)) {
                    534:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    535: #ifdef XML_NS
                    536:     case BT_COLON:
                    537:       if (hadColon) {
                    538:         *nextTokPtr = ptr;
                    539:         return XML_TOK_INVALID;
                    540:       }
                    541:       hadColon = 1;
                    542:       ptr += MINBPC(enc);
                    543:       if (ptr == end)
                    544:         return XML_TOK_PARTIAL;
                    545:       switch (BYTE_TYPE(enc, ptr)) {
                    546:       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    547:       default:
                    548:         *nextTokPtr = ptr;
                    549:         return XML_TOK_INVALID;
                    550:       }
                    551:       break;
                    552: #endif
                    553:     case BT_S: case BT_CR: case BT_LF:
                    554:       for (;;) {
                    555:         int t;
                    556: 
                    557:         ptr += MINBPC(enc);
                    558:         if (ptr == end)
                    559:           return XML_TOK_PARTIAL;
                    560:         t = BYTE_TYPE(enc, ptr);
                    561:         if (t == BT_EQUALS)
                    562:           break;
                    563:         switch (t) {
                    564:         case BT_S:
                    565:         case BT_LF:
                    566:         case BT_CR:
                    567:           break;
                    568:         default:
                    569:           *nextTokPtr = ptr;
                    570:           return XML_TOK_INVALID;
                    571:         }
                    572:       }
                    573:     /* fall through */
                    574:     case BT_EQUALS:
                    575:       {
                    576:         int open;
                    577: #ifdef XML_NS
                    578:         hadColon = 0;
                    579: #endif
                    580:         for (;;) {
                    581:           ptr += MINBPC(enc);
                    582:           if (ptr == end)
                    583:             return XML_TOK_PARTIAL;
                    584:           open = BYTE_TYPE(enc, ptr);
                    585:           if (open == BT_QUOT || open == BT_APOS)
                    586:             break;
                    587:           switch (open) {
                    588:           case BT_S:
                    589:           case BT_LF:
                    590:           case BT_CR:
                    591:             break;
                    592:           default:
                    593:             *nextTokPtr = ptr;
                    594:             return XML_TOK_INVALID;
                    595:           }
                    596:         }
                    597:         ptr += MINBPC(enc);
                    598:         /* in attribute value */
                    599:         for (;;) {
                    600:           int t;
                    601:           if (ptr == end)
                    602:             return XML_TOK_PARTIAL;
                    603:           t = BYTE_TYPE(enc, ptr);
                    604:           if (t == open)
                    605:             break;
                    606:           switch (t) {
                    607:           INVALID_CASES(ptr, nextTokPtr)
                    608:           case BT_AMP:
                    609:             {
                    610:               int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
                    611:               if (tok <= 0) {
                    612:                 if (tok == XML_TOK_INVALID)
                    613:                   *nextTokPtr = ptr;
                    614:                 return tok;
                    615:               }
                    616:               break;
                    617:             }
                    618:           case BT_LT:
                    619:             *nextTokPtr = ptr;
                    620:             return XML_TOK_INVALID;
                    621:           default:
                    622:             ptr += MINBPC(enc);
                    623:             break;
                    624:           }
                    625:         }
                    626:         ptr += MINBPC(enc);
                    627:         if (ptr == end)
                    628:           return XML_TOK_PARTIAL;
                    629:         switch (BYTE_TYPE(enc, ptr)) {
                    630:         case BT_S:
                    631:         case BT_CR:
                    632:         case BT_LF:
                    633:           break;
                    634:         case BT_SOL:
                    635:           goto sol;
                    636:         case BT_GT:
                    637:           goto gt;
                    638:         default:
                    639:           *nextTokPtr = ptr;
                    640:           return XML_TOK_INVALID;
                    641:         }
                    642:         /* ptr points to closing quote */
                    643:         for (;;) {
                    644:           ptr += MINBPC(enc);
                    645:           if (ptr == end)
                    646:             return XML_TOK_PARTIAL;
                    647:           switch (BYTE_TYPE(enc, ptr)) {
                    648:           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    649:           case BT_S: case BT_CR: case BT_LF:
                    650:             continue;
                    651:           case BT_GT:
                    652:           gt:
                    653:             *nextTokPtr = ptr + MINBPC(enc);
                    654:             return XML_TOK_START_TAG_WITH_ATTS;
                    655:           case BT_SOL:
                    656:           sol:
                    657:             ptr += MINBPC(enc);
                    658:             if (ptr == end)
                    659:               return XML_TOK_PARTIAL;
                    660:             if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    661:               *nextTokPtr = ptr;
                    662:               return XML_TOK_INVALID;
                    663:             }
                    664:             *nextTokPtr = ptr + MINBPC(enc);
                    665:             return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
                    666:           default:
                    667:             *nextTokPtr = ptr;
                    668:             return XML_TOK_INVALID;
                    669:           }
                    670:           break;
                    671:         }
                    672:         break;
                    673:       }
                    674:     default:
                    675:       *nextTokPtr = ptr;
                    676:       return XML_TOK_INVALID;
                    677:     }
                    678:   }
                    679:   return XML_TOK_PARTIAL;
                    680: }
                    681: 
                    682: /* ptr points to character following "<" */
                    683: 
                    684: static int PTRCALL
                    685: PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
                    686:                const char **nextTokPtr)
                    687: {
                    688: #ifdef XML_NS
                    689:   int hadColon;
                    690: #endif
                    691:   if (ptr == end)
                    692:     return XML_TOK_PARTIAL;
                    693:   switch (BYTE_TYPE(enc, ptr)) {
                    694:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    695:   case BT_EXCL:
                    696:     if ((ptr += MINBPC(enc)) == end)
                    697:       return XML_TOK_PARTIAL;
                    698:     switch (BYTE_TYPE(enc, ptr)) {
                    699:     case BT_MINUS:
                    700:       return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    701:     case BT_LSQB:
                    702:       return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
                    703:                                       end, nextTokPtr);
                    704:     }
                    705:     *nextTokPtr = ptr;
                    706:     return XML_TOK_INVALID;
                    707:   case BT_QUEST:
                    708:     return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    709:   case BT_SOL:
                    710:     return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    711:   default:
                    712:     *nextTokPtr = ptr;
                    713:     return XML_TOK_INVALID;
                    714:   }
                    715: #ifdef XML_NS
                    716:   hadColon = 0;
                    717: #endif
                    718:   /* we have a start-tag */
                    719:   while (ptr != end) {
                    720:     switch (BYTE_TYPE(enc, ptr)) {
                    721:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    722: #ifdef XML_NS
                    723:     case BT_COLON:
                    724:       if (hadColon) {
                    725:         *nextTokPtr = ptr;
                    726:         return XML_TOK_INVALID;
                    727:       }
                    728:       hadColon = 1;
                    729:       ptr += MINBPC(enc);
                    730:       if (ptr == end)
                    731:         return XML_TOK_PARTIAL;
                    732:       switch (BYTE_TYPE(enc, ptr)) {
                    733:       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    734:       default:
                    735:         *nextTokPtr = ptr;
                    736:         return XML_TOK_INVALID;
                    737:       }
                    738:       break;
                    739: #endif
                    740:     case BT_S: case BT_CR: case BT_LF:
                    741:       {
                    742:         ptr += MINBPC(enc);
                    743:         while (ptr != end) {
                    744:           switch (BYTE_TYPE(enc, ptr)) {
                    745:           CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    746:           case BT_GT:
                    747:             goto gt;
                    748:           case BT_SOL:
                    749:             goto sol;
                    750:           case BT_S: case BT_CR: case BT_LF:
                    751:             ptr += MINBPC(enc);
                    752:             continue;
                    753:           default:
                    754:             *nextTokPtr = ptr;
                    755:             return XML_TOK_INVALID;
                    756:           }
                    757:           return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
                    758:         }
                    759:         return XML_TOK_PARTIAL;
                    760:       }
                    761:     case BT_GT:
                    762:     gt:
                    763:       *nextTokPtr = ptr + MINBPC(enc);
                    764:       return XML_TOK_START_TAG_NO_ATTS;
                    765:     case BT_SOL:
                    766:     sol:
                    767:       ptr += MINBPC(enc);
                    768:       if (ptr == end)
                    769:         return XML_TOK_PARTIAL;
                    770:       if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    771:         *nextTokPtr = ptr;
                    772:         return XML_TOK_INVALID;
                    773:       }
                    774:       *nextTokPtr = ptr + MINBPC(enc);
                    775:       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
                    776:     default:
                    777:       *nextTokPtr = ptr;
                    778:       return XML_TOK_INVALID;
                    779:     }
                    780:   }
                    781:   return XML_TOK_PARTIAL;
                    782: }
                    783: 
                    784: static int PTRCALL
                    785: PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
                    786:                    const char **nextTokPtr)
                    787: {
                    788:   if (ptr == end)
                    789:     return XML_TOK_NONE;
                    790:   if (MINBPC(enc) > 1) {
                    791:     size_t n = end - ptr;
                    792:     if (n & (MINBPC(enc) - 1)) {
                    793:       n &= ~(MINBPC(enc) - 1);
                    794:       if (n == 0)
                    795:         return XML_TOK_PARTIAL;
                    796:       end = ptr + n;
                    797:     }
                    798:   }
                    799:   switch (BYTE_TYPE(enc, ptr)) {
                    800:   case BT_LT:
                    801:     return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    802:   case BT_AMP:
                    803:     return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                    804:   case BT_CR:
                    805:     ptr += MINBPC(enc);
                    806:     if (ptr == end)
                    807:       return XML_TOK_TRAILING_CR;
                    808:     if (BYTE_TYPE(enc, ptr) == BT_LF)
                    809:       ptr += MINBPC(enc);
                    810:     *nextTokPtr = ptr;
                    811:     return XML_TOK_DATA_NEWLINE;
                    812:   case BT_LF:
                    813:     *nextTokPtr = ptr + MINBPC(enc);
                    814:     return XML_TOK_DATA_NEWLINE;
                    815:   case BT_RSQB:
                    816:     ptr += MINBPC(enc);
                    817:     if (ptr == end)
                    818:       return XML_TOK_TRAILING_RSQB;
                    819:     if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
                    820:       break;
                    821:     ptr += MINBPC(enc);
                    822:     if (ptr == end)
                    823:       return XML_TOK_TRAILING_RSQB;
                    824:     if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                    825:       ptr -= MINBPC(enc);
                    826:       break;
                    827:     }
                    828:     *nextTokPtr = ptr;
                    829:     return XML_TOK_INVALID;
                    830:   INVALID_CASES(ptr, nextTokPtr)
                    831:   default:
                    832:     ptr += MINBPC(enc);
                    833:     break;
                    834:   }
                    835:   while (ptr != end) {
                    836:     switch (BYTE_TYPE(enc, ptr)) {
                    837: #define LEAD_CASE(n) \
                    838:     case BT_LEAD ## n: \
                    839:       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
                    840:         *nextTokPtr = ptr; \
                    841:         return XML_TOK_DATA_CHARS; \
                    842:       } \
                    843:       ptr += n; \
                    844:       break;
                    845:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                    846: #undef LEAD_CASE
                    847:     case BT_RSQB:
                    848:       if (ptr + MINBPC(enc) != end) {
                    849:          if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
                    850:            ptr += MINBPC(enc);
                    851:            break;
                    852:          }
                    853:          if (ptr + 2*MINBPC(enc) != end) {
                    854:            if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
                    855:              ptr += MINBPC(enc);
                    856:              break;
                    857:            }
                    858:            *nextTokPtr = ptr + 2*MINBPC(enc);
                    859:            return XML_TOK_INVALID;
                    860:          }
                    861:       }
                    862:       /* fall through */
                    863:     case BT_AMP:
                    864:     case BT_LT:
                    865:     case BT_NONXML:
                    866:     case BT_MALFORM:
                    867:     case BT_TRAIL:
                    868:     case BT_CR:
                    869:     case BT_LF:
                    870:       *nextTokPtr = ptr;
                    871:       return XML_TOK_DATA_CHARS;
                    872:     default:
                    873:       ptr += MINBPC(enc);
                    874:       break;
                    875:     }
                    876:   }
                    877:   *nextTokPtr = ptr;
                    878:   return XML_TOK_DATA_CHARS;
                    879: }
                    880: 
                    881: /* ptr points to character following "%" */
                    882: 
                    883: static int PTRCALL
                    884: PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
                    885:                     const char **nextTokPtr)
                    886: {
                    887:   if (ptr == end)
                    888:     return -XML_TOK_PERCENT;
                    889:   switch (BYTE_TYPE(enc, ptr)) {
                    890:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    891:   case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
                    892:     *nextTokPtr = ptr;
                    893:     return XML_TOK_PERCENT;
                    894:   default:
                    895:     *nextTokPtr = ptr;
                    896:     return XML_TOK_INVALID;
                    897:   }
                    898:   while (ptr != end) {
                    899:     switch (BYTE_TYPE(enc, ptr)) {
                    900:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    901:     case BT_SEMI:
                    902:       *nextTokPtr = ptr + MINBPC(enc);
                    903:       return XML_TOK_PARAM_ENTITY_REF;
                    904:     default:
                    905:       *nextTokPtr = ptr;
                    906:       return XML_TOK_INVALID;
                    907:     }
                    908:   }
                    909:   return XML_TOK_PARTIAL;
                    910: }
                    911: 
                    912: static int PTRCALL
                    913: PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
                    914:                       const char **nextTokPtr)
                    915: {
                    916:   if (ptr == end)
                    917:     return XML_TOK_PARTIAL;
                    918:   switch (BYTE_TYPE(enc, ptr)) {
                    919:   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
                    920:   default:
                    921:     *nextTokPtr = ptr;
                    922:     return XML_TOK_INVALID;
                    923:   }
                    924:   while (ptr != end) {
                    925:     switch (BYTE_TYPE(enc, ptr)) {
                    926:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                    927:     case BT_CR: case BT_LF: case BT_S:
                    928:     case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
                    929:       *nextTokPtr = ptr;
                    930:       return XML_TOK_POUND_NAME;
                    931:     default:
                    932:       *nextTokPtr = ptr;
                    933:       return XML_TOK_INVALID;
                    934:     }
                    935:   }
                    936:   return -XML_TOK_POUND_NAME;
                    937: }
                    938: 
                    939: static int PTRCALL
                    940: PREFIX(scanLit)(int open, const ENCODING *enc,
                    941:                 const char *ptr, const char *end,
                    942:                 const char **nextTokPtr)
                    943: {
                    944:   while (ptr != end) {
                    945:     int t = BYTE_TYPE(enc, ptr);
                    946:     switch (t) {
                    947:     INVALID_CASES(ptr, nextTokPtr)
                    948:     case BT_QUOT:
                    949:     case BT_APOS:
                    950:       ptr += MINBPC(enc);
                    951:       if (t != open)
                    952:         break;
                    953:       if (ptr == end)
                    954:         return -XML_TOK_LITERAL;
                    955:       *nextTokPtr = ptr;
                    956:       switch (BYTE_TYPE(enc, ptr)) {
                    957:       case BT_S: case BT_CR: case BT_LF:
                    958:       case BT_GT: case BT_PERCNT: case BT_LSQB:
                    959:         return XML_TOK_LITERAL;
                    960:       default:
                    961:         return XML_TOK_INVALID;
                    962:       }
                    963:     default:
                    964:       ptr += MINBPC(enc);
                    965:       break;
                    966:     }
                    967:   }
                    968:   return XML_TOK_PARTIAL;
                    969: }
                    970: 
                    971: static int PTRCALL
                    972: PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
                    973:                   const char **nextTokPtr)
                    974: {
                    975:   int tok;
                    976:   if (ptr == end)
                    977:     return XML_TOK_NONE;
                    978:   if (MINBPC(enc) > 1) {
                    979:     size_t n = end - ptr;
                    980:     if (n & (MINBPC(enc) - 1)) {
                    981:       n &= ~(MINBPC(enc) - 1);
                    982:       if (n == 0)
                    983:         return XML_TOK_PARTIAL;
                    984:       end = ptr + n;
                    985:     }
                    986:   }
                    987:   switch (BYTE_TYPE(enc, ptr)) {
                    988:   case BT_QUOT:
                    989:     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
                    990:   case BT_APOS:
                    991:     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
                    992:   case BT_LT:
                    993:     {
                    994:       ptr += MINBPC(enc);
                    995:       if (ptr == end)
                    996:         return XML_TOK_PARTIAL;
                    997:       switch (BYTE_TYPE(enc, ptr)) {
                    998:       case BT_EXCL:
                    999:         return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1000:       case BT_QUEST:
                   1001:         return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1002:       case BT_NMSTRT:
                   1003:       case BT_HEX:
                   1004:       case BT_NONASCII:
                   1005:       case BT_LEAD2:
                   1006:       case BT_LEAD3:
                   1007:       case BT_LEAD4:
                   1008:         *nextTokPtr = ptr - MINBPC(enc);
                   1009:         return XML_TOK_INSTANCE_START;
                   1010:       }
                   1011:       *nextTokPtr = ptr;
                   1012:       return XML_TOK_INVALID;
                   1013:     }
                   1014:   case BT_CR:
                   1015:     if (ptr + MINBPC(enc) == end) {
                   1016:       *nextTokPtr = end;
                   1017:       /* indicate that this might be part of a CR/LF pair */
                   1018:       return -XML_TOK_PROLOG_S;
                   1019:     }
                   1020:     /* fall through */
                   1021:   case BT_S: case BT_LF:
                   1022:     for (;;) {
                   1023:       ptr += MINBPC(enc);
                   1024:       if (ptr == end)
                   1025:         break;
                   1026:       switch (BYTE_TYPE(enc, ptr)) {
                   1027:       case BT_S: case BT_LF:
                   1028:         break;
                   1029:       case BT_CR:
                   1030:         /* don't split CR/LF pair */
                   1031:         if (ptr + MINBPC(enc) != end)
                   1032:           break;
                   1033:         /* fall through */
                   1034:       default:
                   1035:         *nextTokPtr = ptr;
                   1036:         return XML_TOK_PROLOG_S;
                   1037:       }
                   1038:     }
                   1039:     *nextTokPtr = ptr;
                   1040:     return XML_TOK_PROLOG_S;
                   1041:   case BT_PERCNT:
                   1042:     return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1043:   case BT_COMMA:
                   1044:     *nextTokPtr = ptr + MINBPC(enc);
                   1045:     return XML_TOK_COMMA;
                   1046:   case BT_LSQB:
                   1047:     *nextTokPtr = ptr + MINBPC(enc);
                   1048:     return XML_TOK_OPEN_BRACKET;
                   1049:   case BT_RSQB:
                   1050:     ptr += MINBPC(enc);
                   1051:     if (ptr == end)
                   1052:       return -XML_TOK_CLOSE_BRACKET;
                   1053:     if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
                   1054:       if (ptr + MINBPC(enc) == end)
                   1055:         return XML_TOK_PARTIAL;
                   1056:       if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
                   1057:         *nextTokPtr = ptr + 2*MINBPC(enc);
                   1058:         return XML_TOK_COND_SECT_CLOSE;
                   1059:       }
                   1060:     }
                   1061:     *nextTokPtr = ptr;
                   1062:     return XML_TOK_CLOSE_BRACKET;
                   1063:   case BT_LPAR:
                   1064:     *nextTokPtr = ptr + MINBPC(enc);
                   1065:     return XML_TOK_OPEN_PAREN;
                   1066:   case BT_RPAR:
                   1067:     ptr += MINBPC(enc);
                   1068:     if (ptr == end)
                   1069:       return -XML_TOK_CLOSE_PAREN;
                   1070:     switch (BYTE_TYPE(enc, ptr)) {
                   1071:     case BT_AST:
                   1072:       *nextTokPtr = ptr + MINBPC(enc);
                   1073:       return XML_TOK_CLOSE_PAREN_ASTERISK;
                   1074:     case BT_QUEST:
                   1075:       *nextTokPtr = ptr + MINBPC(enc);
                   1076:       return XML_TOK_CLOSE_PAREN_QUESTION;
                   1077:     case BT_PLUS:
                   1078:       *nextTokPtr = ptr + MINBPC(enc);
                   1079:       return XML_TOK_CLOSE_PAREN_PLUS;
                   1080:     case BT_CR: case BT_LF: case BT_S:
                   1081:     case BT_GT: case BT_COMMA: case BT_VERBAR:
                   1082:     case BT_RPAR:
                   1083:       *nextTokPtr = ptr;
                   1084:       return XML_TOK_CLOSE_PAREN;
                   1085:     }
                   1086:     *nextTokPtr = ptr;
                   1087:     return XML_TOK_INVALID;
                   1088:   case BT_VERBAR:
                   1089:     *nextTokPtr = ptr + MINBPC(enc);
                   1090:     return XML_TOK_OR;
                   1091:   case BT_GT:
                   1092:     *nextTokPtr = ptr + MINBPC(enc);
                   1093:     return XML_TOK_DECL_CLOSE;
                   1094:   case BT_NUM:
                   1095:     return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1096: #define LEAD_CASE(n) \
                   1097:   case BT_LEAD ## n: \
                   1098:     if (end - ptr < n) \
                   1099:       return XML_TOK_PARTIAL_CHAR; \
                   1100:     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
                   1101:       ptr += n; \
                   1102:       tok = XML_TOK_NAME; \
                   1103:       break; \
                   1104:     } \
                   1105:     if (IS_NAME_CHAR(enc, ptr, n)) { \
                   1106:       ptr += n; \
                   1107:       tok = XML_TOK_NMTOKEN; \
                   1108:       break; \
                   1109:     } \
                   1110:     *nextTokPtr = ptr; \
                   1111:     return XML_TOK_INVALID;
                   1112:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1113: #undef LEAD_CASE
                   1114:   case BT_NMSTRT:
                   1115:   case BT_HEX:
                   1116:     tok = XML_TOK_NAME;
                   1117:     ptr += MINBPC(enc);
                   1118:     break;
                   1119:   case BT_DIGIT:
                   1120:   case BT_NAME:
                   1121:   case BT_MINUS:
                   1122: #ifdef XML_NS
                   1123:   case BT_COLON:
                   1124: #endif
                   1125:     tok = XML_TOK_NMTOKEN;
                   1126:     ptr += MINBPC(enc);
                   1127:     break;
                   1128:   case BT_NONASCII:
                   1129:     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
                   1130:       ptr += MINBPC(enc);
                   1131:       tok = XML_TOK_NAME;
                   1132:       break;
                   1133:     }
                   1134:     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
                   1135:       ptr += MINBPC(enc);
                   1136:       tok = XML_TOK_NMTOKEN;
                   1137:       break;
                   1138:     }
                   1139:     /* fall through */
                   1140:   default:
                   1141:     *nextTokPtr = ptr;
                   1142:     return XML_TOK_INVALID;
                   1143:   }
                   1144:   while (ptr != end) {
                   1145:     switch (BYTE_TYPE(enc, ptr)) {
                   1146:     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                   1147:     case BT_GT: case BT_RPAR: case BT_COMMA:
                   1148:     case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
                   1149:     case BT_S: case BT_CR: case BT_LF:
                   1150:       *nextTokPtr = ptr;
                   1151:       return tok;
                   1152: #ifdef XML_NS
                   1153:     case BT_COLON:
                   1154:       ptr += MINBPC(enc);
                   1155:       switch (tok) {
                   1156:       case XML_TOK_NAME:
                   1157:         if (ptr == end)
                   1158:           return XML_TOK_PARTIAL;
                   1159:         tok = XML_TOK_PREFIXED_NAME;
                   1160:         switch (BYTE_TYPE(enc, ptr)) {
                   1161:         CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
                   1162:         default:
                   1163:           tok = XML_TOK_NMTOKEN;
                   1164:           break;
                   1165:         }
                   1166:         break;
                   1167:       case XML_TOK_PREFIXED_NAME:
                   1168:         tok = XML_TOK_NMTOKEN;
                   1169:         break;
                   1170:       }
                   1171:       break;
                   1172: #endif
                   1173:     case BT_PLUS:
                   1174:       if (tok == XML_TOK_NMTOKEN)  {
                   1175:         *nextTokPtr = ptr;
                   1176:         return XML_TOK_INVALID;
                   1177:       }
                   1178:       *nextTokPtr = ptr + MINBPC(enc);
                   1179:       return XML_TOK_NAME_PLUS;
                   1180:     case BT_AST:
                   1181:       if (tok == XML_TOK_NMTOKEN)  {
                   1182:         *nextTokPtr = ptr;
                   1183:         return XML_TOK_INVALID;
                   1184:       }
                   1185:       *nextTokPtr = ptr + MINBPC(enc);
                   1186:       return XML_TOK_NAME_ASTERISK;
                   1187:     case BT_QUEST:
                   1188:       if (tok == XML_TOK_NMTOKEN)  {
                   1189:         *nextTokPtr = ptr;
                   1190:         return XML_TOK_INVALID;
                   1191:       }
                   1192:       *nextTokPtr = ptr + MINBPC(enc);
                   1193:       return XML_TOK_NAME_QUESTION;
                   1194:     default:
                   1195:       *nextTokPtr = ptr;
                   1196:       return XML_TOK_INVALID;
                   1197:     }
                   1198:   }
                   1199:   return -tok;
                   1200: }
                   1201: 
                   1202: static int PTRCALL
                   1203: PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
                   1204:                           const char *end, const char **nextTokPtr)
                   1205: {
                   1206:   const char *start;
                   1207:   if (ptr == end)
                   1208:     return XML_TOK_NONE;
                   1209:   start = ptr;
                   1210:   while (ptr != end) {
                   1211:     switch (BYTE_TYPE(enc, ptr)) {
                   1212: #define LEAD_CASE(n) \
                   1213:     case BT_LEAD ## n: ptr += n; break;
                   1214:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1215: #undef LEAD_CASE
                   1216:     case BT_AMP:
                   1217:       if (ptr == start)
                   1218:         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1219:       *nextTokPtr = ptr;
                   1220:       return XML_TOK_DATA_CHARS;
                   1221:     case BT_LT:
                   1222:       /* this is for inside entity references */
                   1223:       *nextTokPtr = ptr;
                   1224:       return XML_TOK_INVALID;
                   1225:     case BT_LF:
                   1226:       if (ptr == start) {
                   1227:         *nextTokPtr = ptr + MINBPC(enc);
                   1228:         return XML_TOK_DATA_NEWLINE;
                   1229:       }
                   1230:       *nextTokPtr = ptr;
                   1231:       return XML_TOK_DATA_CHARS;
                   1232:     case BT_CR:
                   1233:       if (ptr == start) {
                   1234:         ptr += MINBPC(enc);
                   1235:         if (ptr == end)
                   1236:           return XML_TOK_TRAILING_CR;
                   1237:         if (BYTE_TYPE(enc, ptr) == BT_LF)
                   1238:           ptr += MINBPC(enc);
                   1239:         *nextTokPtr = ptr;
                   1240:         return XML_TOK_DATA_NEWLINE;
                   1241:       }
                   1242:       *nextTokPtr = ptr;
                   1243:       return XML_TOK_DATA_CHARS;
                   1244:     case BT_S:
                   1245:       if (ptr == start) {
                   1246:         *nextTokPtr = ptr + MINBPC(enc);
                   1247:         return XML_TOK_ATTRIBUTE_VALUE_S;
                   1248:       }
                   1249:       *nextTokPtr = ptr;
                   1250:       return XML_TOK_DATA_CHARS;
                   1251:     default:
                   1252:       ptr += MINBPC(enc);
                   1253:       break;
                   1254:     }
                   1255:   }
                   1256:   *nextTokPtr = ptr;
                   1257:   return XML_TOK_DATA_CHARS;
                   1258: }
                   1259: 
                   1260: static int PTRCALL
                   1261: PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
                   1262:                        const char *end, const char **nextTokPtr)
                   1263: {
                   1264:   const char *start;
                   1265:   if (ptr == end)
                   1266:     return XML_TOK_NONE;
                   1267:   start = ptr;
                   1268:   while (ptr != end) {
                   1269:     switch (BYTE_TYPE(enc, ptr)) {
                   1270: #define LEAD_CASE(n) \
                   1271:     case BT_LEAD ## n: ptr += n; break;
                   1272:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1273: #undef LEAD_CASE
                   1274:     case BT_AMP:
                   1275:       if (ptr == start)
                   1276:         return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
                   1277:       *nextTokPtr = ptr;
                   1278:       return XML_TOK_DATA_CHARS;
                   1279:     case BT_PERCNT:
                   1280:       if (ptr == start) {
                   1281:         int tok =  PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
                   1282:                                        end, nextTokPtr);
                   1283:         return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
                   1284:       }
                   1285:       *nextTokPtr = ptr;
                   1286:       return XML_TOK_DATA_CHARS;
                   1287:     case BT_LF:
                   1288:       if (ptr == start) {
                   1289:         *nextTokPtr = ptr + MINBPC(enc);
                   1290:         return XML_TOK_DATA_NEWLINE;
                   1291:       }
                   1292:       *nextTokPtr = ptr;
                   1293:       return XML_TOK_DATA_CHARS;
                   1294:     case BT_CR:
                   1295:       if (ptr == start) {
                   1296:         ptr += MINBPC(enc);
                   1297:         if (ptr == end)
                   1298:           return XML_TOK_TRAILING_CR;
                   1299:         if (BYTE_TYPE(enc, ptr) == BT_LF)
                   1300:           ptr += MINBPC(enc);
                   1301:         *nextTokPtr = ptr;
                   1302:         return XML_TOK_DATA_NEWLINE;
                   1303:       }
                   1304:       *nextTokPtr = ptr;
                   1305:       return XML_TOK_DATA_CHARS;
                   1306:     default:
                   1307:       ptr += MINBPC(enc);
                   1308:       break;
                   1309:     }
                   1310:   }
                   1311:   *nextTokPtr = ptr;
                   1312:   return XML_TOK_DATA_CHARS;
                   1313: }
                   1314: 
                   1315: #ifdef XML_DTD
                   1316: 
                   1317: static int PTRCALL
                   1318: PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
                   1319:                          const char *end, const char **nextTokPtr)
                   1320: {
                   1321:   int level = 0;
                   1322:   if (MINBPC(enc) > 1) {
                   1323:     size_t n = end - ptr;
                   1324:     if (n & (MINBPC(enc) - 1)) {
                   1325:       n &= ~(MINBPC(enc) - 1);
                   1326:       end = ptr + n;
                   1327:     }
                   1328:   }
                   1329:   while (ptr != end) {
                   1330:     switch (BYTE_TYPE(enc, ptr)) {
                   1331:     INVALID_CASES(ptr, nextTokPtr)
                   1332:     case BT_LT:
                   1333:       if ((ptr += MINBPC(enc)) == end)
                   1334:         return XML_TOK_PARTIAL;
                   1335:       if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
                   1336:         if ((ptr += MINBPC(enc)) == end)
                   1337:           return XML_TOK_PARTIAL;
                   1338:         if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
                   1339:           ++level;
                   1340:           ptr += MINBPC(enc);
                   1341:         }
                   1342:       }
                   1343:       break;
                   1344:     case BT_RSQB:
                   1345:       if ((ptr += MINBPC(enc)) == end)
                   1346:         return XML_TOK_PARTIAL;
                   1347:       if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
                   1348:         if ((ptr += MINBPC(enc)) == end)
                   1349:           return XML_TOK_PARTIAL;
                   1350:         if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
                   1351:           ptr += MINBPC(enc);
                   1352:           if (level == 0) {
                   1353:             *nextTokPtr = ptr;
                   1354:             return XML_TOK_IGNORE_SECT;
                   1355:           }
                   1356:           --level;
                   1357:         }
                   1358:       }
                   1359:       break;
                   1360:     default:
                   1361:       ptr += MINBPC(enc);
                   1362:       break;
                   1363:     }
                   1364:   }
                   1365:   return XML_TOK_PARTIAL;
                   1366: }
                   1367: 
                   1368: #endif /* XML_DTD */
                   1369: 
                   1370: static int PTRCALL
                   1371: PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
                   1372:                    const char **badPtr)
                   1373: {
                   1374:   ptr += MINBPC(enc);
                   1375:   end -= MINBPC(enc);
                   1376:   for (; ptr != end; ptr += MINBPC(enc)) {
                   1377:     switch (BYTE_TYPE(enc, ptr)) {
                   1378:     case BT_DIGIT:
                   1379:     case BT_HEX:
                   1380:     case BT_MINUS:
                   1381:     case BT_APOS:
                   1382:     case BT_LPAR:
                   1383:     case BT_RPAR:
                   1384:     case BT_PLUS:
                   1385:     case BT_COMMA:
                   1386:     case BT_SOL:
                   1387:     case BT_EQUALS:
                   1388:     case BT_QUEST:
                   1389:     case BT_CR:
                   1390:     case BT_LF:
                   1391:     case BT_SEMI:
                   1392:     case BT_EXCL:
                   1393:     case BT_AST:
                   1394:     case BT_PERCNT:
                   1395:     case BT_NUM:
                   1396: #ifdef XML_NS
                   1397:     case BT_COLON:
                   1398: #endif
                   1399:       break;
                   1400:     case BT_S:
                   1401:       if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
                   1402:         *badPtr = ptr;
                   1403:         return 0;
                   1404:       }
                   1405:       break;
                   1406:     case BT_NAME:
                   1407:     case BT_NMSTRT:
                   1408:       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
                   1409:         break;
                   1410:     default:
                   1411:       switch (BYTE_TO_ASCII(enc, ptr)) {
                   1412:       case 0x24: /* $ */
                   1413:       case 0x40: /* @ */
                   1414:         break;
                   1415:       default:
                   1416:         *badPtr = ptr;
                   1417:         return 0;
                   1418:       }
                   1419:       break;
                   1420:     }
                   1421:   }
                   1422:   return 1;
                   1423: }
                   1424: 
                   1425: /* This must only be called for a well-formed start-tag or empty
                   1426:    element tag.  Returns the number of attributes.  Pointers to the
                   1427:    first attsMax attributes are stored in atts.
                   1428: */
                   1429: 
                   1430: static int PTRCALL
                   1431: PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
                   1432:                 int attsMax, ATTRIBUTE *atts)
                   1433: {
                   1434:   enum { other, inName, inValue } state = inName;
                   1435:   int nAtts = 0;
                   1436:   int open = 0; /* defined when state == inValue;
                   1437:                    initialization just to shut up compilers */
                   1438: 
                   1439:   for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
                   1440:     switch (BYTE_TYPE(enc, ptr)) {
                   1441: #define START_NAME \
                   1442:       if (state == other) { \
                   1443:         if (nAtts < attsMax) { \
                   1444:           atts[nAtts].name = ptr; \
                   1445:           atts[nAtts].normalized = 1; \
                   1446:         } \
                   1447:         state = inName; \
                   1448:       }
                   1449: #define LEAD_CASE(n) \
                   1450:     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
                   1451:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1452: #undef LEAD_CASE
                   1453:     case BT_NONASCII:
                   1454:     case BT_NMSTRT:
                   1455:     case BT_HEX:
                   1456:       START_NAME
                   1457:       break;
                   1458: #undef START_NAME
                   1459:     case BT_QUOT:
                   1460:       if (state != inValue) {
                   1461:         if (nAtts < attsMax)
                   1462:           atts[nAtts].valuePtr = ptr + MINBPC(enc);
                   1463:         state = inValue;
                   1464:         open = BT_QUOT;
                   1465:       }
                   1466:       else if (open == BT_QUOT) {
                   1467:         state = other;
                   1468:         if (nAtts < attsMax)
                   1469:           atts[nAtts].valueEnd = ptr;
                   1470:         nAtts++;
                   1471:       }
                   1472:       break;
                   1473:     case BT_APOS:
                   1474:       if (state != inValue) {
                   1475:         if (nAtts < attsMax)
                   1476:           atts[nAtts].valuePtr = ptr + MINBPC(enc);
                   1477:         state = inValue;
                   1478:         open = BT_APOS;
                   1479:       }
                   1480:       else if (open == BT_APOS) {
                   1481:         state = other;
                   1482:         if (nAtts < attsMax)
                   1483:           atts[nAtts].valueEnd = ptr;
                   1484:         nAtts++;
                   1485:       }
                   1486:       break;
                   1487:     case BT_AMP:
                   1488:       if (nAtts < attsMax)
                   1489:         atts[nAtts].normalized = 0;
                   1490:       break;
                   1491:     case BT_S:
                   1492:       if (state == inName)
                   1493:         state = other;
                   1494:       else if (state == inValue
                   1495:                && nAtts < attsMax
                   1496:                && atts[nAtts].normalized
                   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))
                   1501:         atts[nAtts].normalized = 0;
                   1502:       break;
                   1503:     case BT_CR: case BT_LF:
                   1504:       /* This case ensures that the first attribute name is counted
                   1505:          Apart from that we could just change state on the quote. */
                   1506:       if (state == inName)
                   1507:         state = other;
                   1508:       else if (state == inValue && nAtts < attsMax)
                   1509:         atts[nAtts].normalized = 0;
                   1510:       break;
                   1511:     case BT_GT:
                   1512:     case BT_SOL:
                   1513:       if (state != inValue)
                   1514:         return nAtts;
                   1515:       break;
                   1516:     default:
                   1517:       break;
                   1518:     }
                   1519:   }
                   1520:   /* not reached */
                   1521: }
                   1522: 
                   1523: static int PTRFASTCALL
                   1524: PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
                   1525: {
                   1526:   int result = 0;
                   1527:   /* skip &# */
                   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);
                   1534:       switch (c) {
                   1535:       case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4:
                   1536:       case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9:
                   1537:         result <<= 4;
                   1538:         result |= (c - ASCII_0);
                   1539:         break;
                   1540:       case ASCII_A: case ASCII_B: case ASCII_C:
                   1541:       case ASCII_D: case ASCII_E: case ASCII_F:
                   1542:         result <<= 4;
                   1543:         result += 10 + (c - ASCII_A);
                   1544:         break;
                   1545:       case ASCII_a: case ASCII_b: case ASCII_c:
                   1546:       case ASCII_d: case ASCII_e: case ASCII_f:
                   1547:         result <<= 4;
                   1548:         result += 10 + (c - ASCII_a);
                   1549:         break;
                   1550:       }
                   1551:       if (result >= 0x110000)
                   1552:         return -1;
                   1553:     }
                   1554:   }
                   1555:   else {
                   1556:     for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
                   1557:       int c = BYTE_TO_ASCII(enc, ptr);
                   1558:       result *= 10;
                   1559:       result += (c - ASCII_0);
                   1560:       if (result >= 0x110000)
                   1561:         return -1;
                   1562:     }
                   1563:   }
                   1564:   return checkCharRefNumber(result);
                   1565: }
                   1566: 
                   1567: static int PTRCALL
                   1568: PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
                   1569:                              const char *end)
                   1570: {
                   1571:   switch ((end - ptr)/MINBPC(enc)) {
                   1572:   case 2:
                   1573:     if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
                   1574:       switch (BYTE_TO_ASCII(enc, ptr)) {
                   1575:       case ASCII_l:
                   1576:         return ASCII_LT;
                   1577:       case ASCII_g:
                   1578:         return ASCII_GT;
                   1579:       }
                   1580:     }
                   1581:     break;
                   1582:   case 3:
                   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))
                   1588:           return ASCII_AMP;
                   1589:       }
                   1590:     }
                   1591:     break;
                   1592:   case 4:
                   1593:     switch (BYTE_TO_ASCII(enc, ptr)) {
                   1594:     case ASCII_q:
                   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))
                   1601:             return ASCII_QUOT;
                   1602:         }
                   1603:       }
                   1604:       break;
                   1605:     case ASCII_a:
                   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))
                   1612:             return ASCII_APOS;
                   1613:         }
                   1614:       }
                   1615:       break;
                   1616:     }
                   1617:   }
                   1618:   return 0;
                   1619: }
                   1620: 
                   1621: static int PTRCALL
                   1622: PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
                   1623: {
                   1624:   for (;;) {
                   1625:     switch (BYTE_TYPE(enc, ptr1)) {
                   1626: #define LEAD_CASE(n) \
                   1627:     case BT_LEAD ## n: \
                   1628:       if (*ptr1++ != *ptr2++) \
                   1629:         return 0;
                   1630:     LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
                   1631: #undef LEAD_CASE
                   1632:       /* fall through */
                   1633:       if (*ptr1++ != *ptr2++)
                   1634:         return 0;
                   1635:       break;
                   1636:     case BT_NONASCII:
                   1637:     case BT_NMSTRT:
                   1638: #ifdef XML_NS
                   1639:     case BT_COLON:
                   1640: #endif
                   1641:     case BT_HEX:
                   1642:     case BT_DIGIT:
                   1643:     case BT_NAME:
                   1644:     case BT_MINUS:
                   1645:       if (*ptr2++ != *ptr1++)
                   1646:         return 0;
                   1647:       if (MINBPC(enc) > 1) {
                   1648:         if (*ptr2++ != *ptr1++)
                   1649:           return 0;
                   1650:         if (MINBPC(enc) > 2) {
                   1651:           if (*ptr2++ != *ptr1++)
                   1652:             return 0;
                   1653:           if (MINBPC(enc) > 3) {
                   1654:             if (*ptr2++ != *ptr1++)
                   1655:               return 0;
                   1656:           }
                   1657:         }
                   1658:       }
                   1659:       break;
                   1660:     default:
                   1661:       if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
                   1662:         return 1;
                   1663:       switch (BYTE_TYPE(enc, ptr2)) {
                   1664:       case BT_LEAD2:
                   1665:       case BT_LEAD3:
                   1666:       case BT_LEAD4:
                   1667:       case BT_NONASCII:
                   1668:       case BT_NMSTRT:
                   1669: #ifdef XML_NS
                   1670:       case BT_COLON:
                   1671: #endif
                   1672:       case BT_HEX:
                   1673:       case BT_DIGIT:
                   1674:       case BT_NAME:
                   1675:       case BT_MINUS:
                   1676:         return 0;
                   1677:       default:
                   1678:         return 1;
                   1679:       }
                   1680:     }
                   1681:   }
                   1682:   /* not reached */
                   1683: }
                   1684: 
                   1685: static int PTRCALL
                   1686: PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
                   1687:                          const char *end1, const char *ptr2)
                   1688: {
                   1689:   for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
                   1690:     if (ptr1 == end1)
                   1691:       return 0;
                   1692:     if (!CHAR_MATCHES(enc, ptr1, *ptr2))
                   1693:       return 0;
                   1694:   }
                   1695:   return ptr1 == end1;
                   1696: }
                   1697: 
                   1698: static int PTRFASTCALL
                   1699: PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
                   1700: {
                   1701:   const char *start = ptr;
                   1702:   for (;;) {
                   1703:     switch (BYTE_TYPE(enc, ptr)) {
                   1704: #define LEAD_CASE(n) \
                   1705:     case BT_LEAD ## n: ptr += n; break;
                   1706:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1707: #undef LEAD_CASE
                   1708:     case BT_NONASCII:
                   1709:     case BT_NMSTRT:
                   1710: #ifdef XML_NS
                   1711:     case BT_COLON:
                   1712: #endif
                   1713:     case BT_HEX:
                   1714:     case BT_DIGIT:
                   1715:     case BT_NAME:
                   1716:     case BT_MINUS:
                   1717:       ptr += MINBPC(enc);
                   1718:       break;
                   1719:     default:
                   1720:       return (int)(ptr - start);
                   1721:     }
                   1722:   }
                   1723: }
                   1724: 
                   1725: static const char * PTRFASTCALL
                   1726: PREFIX(skipS)(const ENCODING *enc, const char *ptr)
                   1727: {
                   1728:   for (;;) {
                   1729:     switch (BYTE_TYPE(enc, ptr)) {
                   1730:     case BT_LF:
                   1731:     case BT_CR:
                   1732:     case BT_S:
                   1733:       ptr += MINBPC(enc);
                   1734:       break;
                   1735:     default:
                   1736:       return ptr;
                   1737:     }
                   1738:   }
                   1739: }
                   1740: 
                   1741: static void PTRCALL
                   1742: PREFIX(updatePosition)(const ENCODING *enc,
                   1743:                        const char *ptr,
                   1744:                        const char *end,
                   1745:                        POSITION *pos)
                   1746: {
1.1.1.1.2.1! misho    1747:   while (ptr < end) {
1.1       misho    1748:     switch (BYTE_TYPE(enc, ptr)) {
                   1749: #define LEAD_CASE(n) \
                   1750:     case BT_LEAD ## n: \
                   1751:       ptr += n; \
                   1752:       break;
                   1753:     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
                   1754: #undef LEAD_CASE
                   1755:     case BT_LF:
                   1756:       pos->columnNumber = (XML_Size)-1;
                   1757:       pos->lineNumber++;
                   1758:       ptr += MINBPC(enc);
                   1759:       break;
                   1760:     case BT_CR:
                   1761:       pos->lineNumber++;
                   1762:       ptr += MINBPC(enc);
                   1763:       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
                   1764:         ptr += MINBPC(enc);
                   1765:       pos->columnNumber = (XML_Size)-1;
                   1766:       break;
                   1767:     default:
                   1768:       ptr += MINBPC(enc);
                   1769:       break;
                   1770:     }
                   1771:     pos->columnNumber++;
                   1772:   }
                   1773: }
                   1774: 
                   1775: #undef DO_LEAD_CASE
                   1776: #undef MULTIBYTE_CASES
                   1777: #undef INVALID_CASES
                   1778: #undef CHECK_NAME_CASE
                   1779: #undef CHECK_NAME_CASES
                   1780: #undef CHECK_NMSTRT_CASE
                   1781: #undef CHECK_NMSTRT_CASES
                   1782: 
                   1783: #endif /* XML_TOK_IMPL_C */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>