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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
xmltok_impl.c
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：43k
源码类别：

Symbian

开发平台：

C/C++

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