开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
xmltok_impl.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：44k
源码类别：

其他游戏

开发平台：

Visual C++

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