home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / modules / xml / expat / xmltok / xmltok_impl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  35.2 KB  |  1,510 lines
  1. /*
  2. The contents of this file are subject to the Mozilla Public License
  3. Version 1.0 (the "License"); you may not use this file except in
  4. compliance with the License. You may obtain a copy of the License at
  5. http://www.mozilla.org/MPL/
  6.  
  7. Software distributed under the License is distributed on an "AS IS"
  8. basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
  9. License for the specific language governing rights and limitations
  10. under the License.
  11.  
  12. The Original Code is expat.
  13.  
  14. The Initial Developer of the Original Code is James Clark.
  15. Portions created by James Clark are Copyright (C) 1998
  16. James Clark. All Rights Reserved.
  17.  
  18. Contributor(s):
  19. */
  20.  
  21. #ifndef IS_INVALID_CHAR
  22. #define IS_INVALID_CHAR(enc, ptr, n) (0)
  23. #endif
  24.  
  25. #define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
  26.     case BT_LEAD ## n: \
  27.       if (end - ptr < n) \
  28.     return XML_TOK_PARTIAL_CHAR; \
  29.       if (IS_INVALID_CHAR(enc, ptr, n)) { \
  30.         *(nextTokPtr) = (ptr); \
  31.         return XML_TOK_INVALID; \
  32.       } \
  33.       ptr += n; \
  34.       break;
  35.  
  36. #define INVALID_CASES(ptr, nextTokPtr) \
  37.   INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
  38.   INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
  39.   INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
  40.   case BT_NONXML: \
  41.   case BT_MALFORM: \
  42.   case BT_TRAIL: \
  43.     *(nextTokPtr) = (ptr); \
  44.     return XML_TOK_INVALID;
  45.  
  46. #define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
  47.    case BT_LEAD ## n: \
  48.      if (end - ptr < n) \
  49.        return XML_TOK_PARTIAL_CHAR; \
  50.      if (!IS_NAME_CHAR(enc, ptr, n)) { \
  51.        *nextTokPtr = ptr; \
  52.        return XML_TOK_INVALID; \
  53.      } \
  54.      ptr += n; \
  55.      break;
  56.  
  57. #define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
  58.   case BT_NONASCII: \
  59.     if (!IS_NAME_CHAR(enc, ptr, MINBPC)) { \
  60.       *nextTokPtr = ptr; \
  61.       return XML_TOK_INVALID; \
  62.     } \
  63.   case BT_NMSTRT: \
  64.   case BT_HEX: \
  65.   case BT_DIGIT: \
  66.   case BT_NAME: \
  67.   case BT_MINUS: \
  68.     ptr += MINBPC; \
  69.     break; \
  70.   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
  71.   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
  72.   CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
  73.  
  74. #define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
  75.    case BT_LEAD ## n: \
  76.      if (end - ptr < n) \
  77.        return XML_TOK_PARTIAL_CHAR; \
  78.      if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
  79.        *nextTokPtr = ptr; \
  80.        return XML_TOK_INVALID; \
  81.      } \
  82.      ptr += n; \
  83.      break;
  84.  
  85. #define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
  86.   case BT_NONASCII: \
  87.     if (!IS_NMSTRT_CHAR(enc, ptr, MINBPC)) { \
  88.       *nextTokPtr = ptr; \
  89.       return XML_TOK_INVALID; \
  90.     } \
  91.   case BT_NMSTRT: \
  92.   case BT_HEX: \
  93.     ptr += MINBPC; \
  94.     break; \
  95.   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
  96.   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
  97.   CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
  98.  
  99. #ifndef PREFIX
  100. #define PREFIX(ident) ident
  101. #endif
  102.  
  103. /* ptr points to character following "<!-" */
  104.  
  105. static
  106. int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
  107.             const char **nextTokPtr)
  108. {
  109.   if (ptr != end) {
  110.     if (!CHAR_MATCHES(enc, ptr, '-')) {
  111.       *nextTokPtr = ptr;
  112.       return XML_TOK_INVALID;
  113.     }
  114.     ptr += MINBPC;
  115.     while (ptr != end) {
  116.       switch (BYTE_TYPE(enc, ptr)) {
  117.       INVALID_CASES(ptr, nextTokPtr)
  118.       case BT_MINUS:
  119.     if ((ptr += MINBPC) == end)
  120.       return XML_TOK_PARTIAL;
  121.     if (CHAR_MATCHES(enc, ptr, '-')) {
  122.       if ((ptr += MINBPC) == end)
  123.         return XML_TOK_PARTIAL;
  124.       if (!CHAR_MATCHES(enc, ptr, '>')) {
  125.         *nextTokPtr = ptr;
  126.         return XML_TOK_INVALID;
  127.       }
  128.       *nextTokPtr = ptr + MINBPC;
  129.       return XML_TOK_COMMENT;
  130.     }
  131.     /* fall through */
  132.       default:
  133.     ptr += MINBPC;
  134.     break;
  135.       }
  136.     }
  137.   }
  138.   return XML_TOK_PARTIAL;
  139. }
  140.  
  141. /* ptr points to character following "<!" */
  142.  
  143. static
  144. int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
  145.              const char **nextTokPtr)
  146. {
  147.   if (ptr == end)
  148.     return XML_TOK_PARTIAL;
  149.   switch (BYTE_TYPE(enc, ptr)) {
  150.   case BT_MINUS:
  151.     return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
  152.   case BT_LSQB:
  153.     *nextTokPtr = ptr + MINBPC;
  154.     return XML_TOK_COND_SECT_OPEN;
  155.   case BT_NMSTRT:
  156.   case BT_HEX:
  157.     ptr += MINBPC;
  158.     break;
  159.   default:
  160.     *nextTokPtr = ptr;
  161.     return XML_TOK_INVALID;
  162.   }
  163.   while (ptr != end) {
  164.     switch (BYTE_TYPE(enc, ptr)) {
  165.     case BT_PERCNT:
  166.       if (ptr + MINBPC == end)
  167.     return XML_TOK_PARTIAL;
  168.       /* don't allow <!ENTITY% foo "whatever"> */
  169.       switch (BYTE_TYPE(enc, ptr + MINBPC)) {
  170.       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
  171.     *nextTokPtr = ptr;
  172.     return XML_TOK_INVALID;
  173.       }
  174.       /* fall through */
  175.     case BT_S: case BT_CR: case BT_LF:
  176.       *nextTokPtr = ptr;
  177.       return XML_TOK_DECL_OPEN;
  178.     case BT_NMSTRT:
  179.     case BT_HEX:
  180.       ptr += MINBPC;
  181.       break;
  182.     default:
  183.       *nextTokPtr = ptr;
  184.       return XML_TOK_INVALID;
  185.     }
  186.   }
  187.   return XML_TOK_PARTIAL;
  188. }
  189.  
  190. static
  191. int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end, int *tokPtr)
  192. {
  193.   int upper = 0;
  194.   *tokPtr = XML_TOK_PI;
  195.   if (end - ptr != MINBPC*3)
  196.     return 1;
  197.   switch (BYTE_TO_ASCII(enc, ptr)) {
  198.   case 'x':
  199.     break;
  200.   case 'X':
  201.     upper = 1;
  202.     break;
  203.   default:
  204.     return 1;
  205.   }
  206.   ptr += MINBPC;
  207.   switch (BYTE_TO_ASCII(enc, ptr)) {
  208.   case 'm':
  209.     break;
  210.   case 'M':
  211.     upper = 1;
  212.     break;
  213.   default:
  214.     return 1;
  215.   }
  216.   ptr += MINBPC;
  217.   switch (BYTE_TO_ASCII(enc, ptr)) {
  218.   case 'l':
  219.     break;
  220.   case 'L':
  221.     upper = 1;
  222.     break;
  223.   default:
  224.     return 1;
  225.   }
  226.   if (upper)
  227.     return 0;
  228.   *tokPtr = XML_TOK_XML_DECL;
  229.   return 1;
  230. }
  231.  
  232. /* ptr points to character following "<?" */
  233.  
  234. static
  235. int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
  236.            const char **nextTokPtr)
  237. {
  238.   int tok;
  239.   const char *target = ptr;
  240.   if (ptr == end)
  241.     return XML_TOK_PARTIAL;
  242.   switch (BYTE_TYPE(enc, ptr)) {
  243.   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  244.   default:
  245.     *nextTokPtr = ptr;
  246.     return XML_TOK_INVALID;
  247.   }
  248.   while (ptr != end) {
  249.     switch (BYTE_TYPE(enc, ptr)) {
  250.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  251.     case BT_S: case BT_CR: case BT_LF:
  252.       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
  253.     *nextTokPtr = ptr;
  254.     return XML_TOK_INVALID;
  255.       }
  256.       ptr += MINBPC;
  257.       while (ptr != end) {
  258.         switch (BYTE_TYPE(enc, ptr)) {
  259.         INVALID_CASES(ptr, nextTokPtr)
  260.     case BT_QUEST:
  261.       ptr += MINBPC;
  262.       if (ptr == end)
  263.         return XML_TOK_PARTIAL;
  264.       if (CHAR_MATCHES(enc, ptr, '>')) {
  265.         *nextTokPtr = ptr + MINBPC;
  266.         return tok;
  267.       }
  268.       break;
  269.     default:
  270.       ptr += MINBPC;
  271.       break;
  272.     }
  273.       }
  274.       return XML_TOK_PARTIAL;
  275.     case BT_QUEST:
  276.       if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
  277.     *nextTokPtr = ptr;
  278.     return XML_TOK_INVALID;
  279.       }
  280.       ptr += MINBPC;
  281.       if (ptr == end)
  282.     return XML_TOK_PARTIAL;
  283.       if (CHAR_MATCHES(enc, ptr, '>')) {
  284.     *nextTokPtr = ptr + MINBPC;
  285.     return tok;
  286.       }
  287.       /* fall through */
  288.     default:
  289.       *nextTokPtr = ptr;
  290.       return XML_TOK_INVALID;
  291.     }
  292.   }
  293.   return XML_TOK_PARTIAL;
  294. }
  295.  
  296. /* ptr points to character following "<![" */
  297.  
  298. static
  299. int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
  300.                  const char **nextTokPtr)
  301. {
  302.   int i;
  303.   /* CDATA[]]> */
  304.   if (end - ptr < 9 * MINBPC)
  305.     return XML_TOK_PARTIAL;
  306.   for (i = 0; i < 6; i++, ptr += MINBPC) {
  307.     if (!CHAR_MATCHES(enc, ptr, "CDATA["[i])) {
  308.       *nextTokPtr = ptr;
  309.       return XML_TOK_INVALID;
  310.     }
  311.   }
  312.   end -= 2 * MINBPC;
  313.   while (ptr != end) {
  314.     switch (BYTE_TYPE(enc, ptr)) {
  315.     INVALID_CASES(ptr, nextTokPtr)
  316.     case BT_RSQB:
  317.       if (CHAR_MATCHES(enc, ptr + MINBPC, ']')
  318.       && CHAR_MATCHES(enc, ptr + 2 * MINBPC, '>')) {
  319.     *nextTokPtr = ptr + 3 * MINBPC;
  320.     return XML_TOK_CDATA_SECTION;
  321.       }
  322.     /* fall through */
  323.     default:
  324.       ptr += MINBPC;
  325.     }
  326.   }
  327.   return XML_TOK_PARTIAL;
  328. }
  329.  
  330. /* ptr points to character following "</" */
  331.  
  332. static
  333. int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
  334.                const char **nextTokPtr)
  335. {
  336.   if (ptr == end)
  337.     return XML_TOK_PARTIAL;
  338.   switch (BYTE_TYPE(enc, ptr)) {
  339.   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  340.   default:
  341.     *nextTokPtr = ptr;
  342.     return XML_TOK_INVALID;
  343.   }
  344.   while (ptr != end) {
  345.     switch (BYTE_TYPE(enc, ptr)) {
  346.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  347.     case BT_S: case BT_CR: case BT_LF:
  348.       for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
  349.     switch (BYTE_TYPE(enc, ptr)) {
  350.     case BT_S: case BT_CR: case BT_LF:
  351.       break;
  352.     case BT_GT:
  353.       *nextTokPtr = ptr + MINBPC;
  354.           return XML_TOK_END_TAG;
  355.     default:
  356.       *nextTokPtr = ptr;
  357.       return XML_TOK_INVALID;
  358.     }
  359.       }
  360.       return XML_TOK_PARTIAL;
  361.     case BT_GT:
  362.       *nextTokPtr = ptr + MINBPC;
  363.       return XML_TOK_END_TAG;
  364.     default:
  365.       *nextTokPtr = ptr;
  366.       return XML_TOK_INVALID;
  367.     }
  368.   }
  369.   return XML_TOK_PARTIAL;
  370. }
  371.  
  372. /* ptr points to character following "&#X" */
  373.  
  374. static
  375. int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
  376.                const char **nextTokPtr)
  377. {
  378.   if (ptr != end) {
  379.     switch (BYTE_TYPE(enc, ptr)) {
  380.     case BT_DIGIT:
  381.     case BT_HEX:
  382.       break;
  383.     default:
  384.       *nextTokPtr = ptr;
  385.       return XML_TOK_INVALID;
  386.     }
  387.     for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
  388.       switch (BYTE_TYPE(enc, ptr)) {
  389.       case BT_DIGIT:
  390.       case BT_HEX:
  391.     break;
  392.       case BT_SEMI:
  393.     *nextTokPtr = ptr + MINBPC;
  394.     return XML_TOK_CHAR_REF;
  395.       default:
  396.     *nextTokPtr = ptr;
  397.     return XML_TOK_INVALID;
  398.       }
  399.     }
  400.   }
  401.   return XML_TOK_PARTIAL;
  402. }
  403.  
  404. /* ptr points to character following "&#" */
  405.  
  406. static
  407. int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
  408.             const char **nextTokPtr)
  409. {
  410.   if (ptr != end) {
  411.     if (CHAR_MATCHES(enc, ptr, 'x'))
  412.       return PREFIX(scanHexCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
  413.     switch (BYTE_TYPE(enc, ptr)) {
  414.     case BT_DIGIT:
  415.       break;
  416.     default:
  417.       *nextTokPtr = ptr;
  418.       return XML_TOK_INVALID;
  419.     }
  420.     for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
  421.       switch (BYTE_TYPE(enc, ptr)) {
  422.       case BT_DIGIT:
  423.     break;
  424.       case BT_SEMI:
  425.     *nextTokPtr = ptr + MINBPC;
  426.     return XML_TOK_CHAR_REF;
  427.       default:
  428.     *nextTokPtr = ptr;
  429.     return XML_TOK_INVALID;
  430.       }
  431.     }
  432.   }
  433.   return XML_TOK_PARTIAL;
  434. }
  435.  
  436. /* ptr points to character following "&" */
  437.  
  438. static
  439. int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
  440.             const char **nextTokPtr)
  441. {
  442.   if (ptr == end)
  443.     return XML_TOK_PARTIAL;
  444.   switch (BYTE_TYPE(enc, ptr)) {
  445.   CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
  446.   case BT_NUM:
  447.     return PREFIX(scanCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
  448.   default:
  449.     *nextTokPtr = ptr;
  450.     return XML_TOK_INVALID;
  451.   }
  452.   while (ptr != end) {
  453.     switch (BYTE_TYPE(enc, ptr)) {
  454.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  455.     case BT_SEMI:
  456.       *nextTokPtr = ptr + MINBPC;
  457.       return XML_TOK_ENTITY_REF;
  458.     default:
  459.       *nextTokPtr = ptr;
  460.       return XML_TOK_INVALID;
  461.     }
  462.   }
  463.   return XML_TOK_PARTIAL;
  464. }
  465.  
  466. /* ptr points to character following first character of attribute name */
  467.  
  468. static
  469. int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
  470.              const char **nextTokPtr)
  471. {
  472.   while (ptr != end) {
  473.     switch (BYTE_TYPE(enc, ptr)) {
  474.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  475.     case BT_S: case BT_CR: case BT_LF:
  476.       for (;;) {
  477.     int t;
  478.  
  479.     ptr += MINBPC;
  480.     if (ptr == end)
  481.       return XML_TOK_PARTIAL;
  482.     t = BYTE_TYPE(enc, ptr);
  483.     if (t == BT_EQUALS)
  484.       break;
  485.     switch (t) {
  486.     case BT_S:
  487.     case BT_LF:
  488.     case BT_CR:
  489.       break;
  490.     default:
  491.       *nextTokPtr = ptr;
  492.       return XML_TOK_INVALID;
  493.     }
  494.       }
  495.     /* fall through */
  496.     case BT_EQUALS:
  497.       {
  498.     int open;
  499.     for (;;) {
  500.       
  501.       ptr += MINBPC;
  502.       if (ptr == end)
  503.         return XML_TOK_PARTIAL;
  504.       open = BYTE_TYPE(enc, ptr);
  505.       if (open == BT_QUOT || open == BT_APOS)
  506.         break;
  507.       switch (open) {
  508.       case BT_S:
  509.       case BT_LF:
  510.       case BT_CR:
  511.         break;
  512.       default:
  513.         *nextTokPtr = ptr;
  514.         return XML_TOK_INVALID;
  515.       }
  516.     }
  517.     ptr += MINBPC;
  518.     /* in attribute value */
  519.     for (;;) {
  520.       int t;
  521.       if (ptr == end)
  522.         return XML_TOK_PARTIAL;
  523.       t = BYTE_TYPE(enc, ptr);
  524.       if (t == open)
  525.         break;
  526.       switch (t) {
  527.       INVALID_CASES(ptr, nextTokPtr)
  528.       case BT_AMP:
  529.         {
  530.           int tok = PREFIX(scanRef)(enc, ptr + MINBPC, end, &ptr);
  531.           if (tok <= 0) {
  532.         if (tok == XML_TOK_INVALID)
  533.           *nextTokPtr = ptr;
  534.         return tok;
  535.           }
  536.           break;
  537.         }
  538.       case BT_LT:
  539.         *nextTokPtr = ptr;
  540.         return XML_TOK_INVALID;
  541.       default:
  542.         ptr += MINBPC;
  543.         break;
  544.       }
  545.     }
  546.     /* ptr points to closing quote */
  547.     for (;;) {
  548.       ptr += MINBPC;
  549.       if (ptr == end)
  550.         return XML_TOK_PARTIAL;
  551.       switch (BYTE_TYPE(enc, ptr)) {
  552.       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  553.       case BT_S: case BT_CR: case BT_LF:
  554.         continue;
  555.       case BT_GT:
  556.         *nextTokPtr = ptr + MINBPC;
  557.         return XML_TOK_START_TAG_WITH_ATTS;
  558.       case BT_SOL:
  559.         ptr += MINBPC;
  560.         if (ptr == end)
  561.           return XML_TOK_PARTIAL;
  562.         if (!CHAR_MATCHES(enc, ptr, '>')) {
  563.           *nextTokPtr = ptr;
  564.           return XML_TOK_INVALID;
  565.         }
  566.         *nextTokPtr = ptr + MINBPC;
  567.         return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
  568.       default:
  569.         *nextTokPtr = ptr;
  570.         return XML_TOK_INVALID;
  571.       }
  572.       break;
  573.     }
  574.     break;
  575.       }
  576.     default:
  577.       *nextTokPtr = ptr;
  578.       return XML_TOK_INVALID;
  579.     }
  580.   }
  581.   return XML_TOK_PARTIAL;
  582. }
  583.  
  584. /* ptr points to character following "<" */
  585.  
  586. static
  587. int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
  588.            const char **nextTokPtr)
  589. {
  590.   if (ptr == end)
  591.     return XML_TOK_PARTIAL;
  592.   switch (BYTE_TYPE(enc, ptr)) {
  593.   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  594.   case BT_EXCL:
  595.     if ((ptr += MINBPC) == end)
  596.       return XML_TOK_PARTIAL;
  597.     switch (BYTE_TYPE(enc, ptr)) {
  598.     case BT_MINUS:
  599.       return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
  600.     case BT_LSQB:
  601.       return PREFIX(scanCdataSection)(enc, ptr + MINBPC, end, nextTokPtr);
  602.     }
  603.     *nextTokPtr = ptr;
  604.     return XML_TOK_INVALID;
  605.   case BT_QUEST:
  606.     return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
  607.   case BT_SOL:
  608.     return PREFIX(scanEndTag)(enc, ptr + MINBPC, end, nextTokPtr);
  609.   default:
  610.     *nextTokPtr = ptr;
  611.     return XML_TOK_INVALID;
  612.   }
  613.   /* we have a start-tag */
  614.   while (ptr != end) {
  615.     switch (BYTE_TYPE(enc, ptr)) {
  616.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  617.     case BT_S: case BT_CR: case BT_LF:
  618.       {
  619.         ptr += MINBPC;
  620.     while (ptr != end) {
  621.       switch (BYTE_TYPE(enc, ptr)) {
  622.       CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
  623.       case BT_GT:
  624.         goto gt;
  625.       case BT_SOL:
  626.         goto sol;
  627.       case BT_S: case BT_CR: case BT_LF:
  628.         ptr += MINBPC;
  629.         continue;
  630.       default:
  631.         *nextTokPtr = ptr;
  632.         return XML_TOK_INVALID;
  633.       }
  634.       return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
  635.     }
  636.     return XML_TOK_PARTIAL;
  637.       }
  638.     case BT_GT:
  639.     gt:
  640.       *nextTokPtr = ptr + MINBPC;
  641.       return XML_TOK_START_TAG_NO_ATTS;
  642.     case BT_SOL:
  643.     sol:
  644.       ptr += MINBPC;
  645.       if (ptr == end)
  646.     return XML_TOK_PARTIAL;
  647.       if (!CHAR_MATCHES(enc, ptr, '>')) {
  648.     *nextTokPtr = ptr;
  649.     return XML_TOK_INVALID;
  650.       }
  651.       *nextTokPtr = ptr + MINBPC;
  652.       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
  653.     default:
  654.       *nextTokPtr = ptr;
  655.       return XML_TOK_INVALID;
  656.     }
  657.   }
  658.   return XML_TOK_PARTIAL;
  659. }
  660.  
  661. static
  662. int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
  663.                const char **nextTokPtr)
  664. {
  665.   if (ptr == end)
  666.     return XML_TOK_NONE;
  667. #if MINBPC > 1
  668.   {
  669.     size_t n = end - ptr;
  670.     if (n & (MINBPC - 1)) {
  671.       n &= ~(MINBPC - 1);
  672.       if (n == 0)
  673.     return XML_TOK_PARTIAL;
  674.       end = ptr + n;
  675.     }
  676.   }
  677. #endif
  678.   switch (BYTE_TYPE(enc, ptr)) {
  679.   case BT_LT:
  680.     return PREFIX(scanLt)(enc, ptr + MINBPC, end, nextTokPtr);
  681.   case BT_AMP:
  682.     return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
  683.   case BT_CR:
  684.     ptr += MINBPC;
  685.     if (ptr == end)
  686.       return XML_TOK_TRAILING_CR;
  687.     if (BYTE_TYPE(enc, ptr) == BT_LF)
  688.       ptr += MINBPC;
  689.     *nextTokPtr = ptr;
  690.     return XML_TOK_DATA_NEWLINE;
  691.   case BT_LF:
  692.     *nextTokPtr = ptr + MINBPC;
  693.     return XML_TOK_DATA_NEWLINE;
  694.   case BT_RSQB:
  695.     ptr += MINBPC;
  696.     if (ptr == end)
  697.       return XML_TOK_PARTIAL;
  698.     if (!CHAR_MATCHES(enc, ptr, ']'))
  699.       break;
  700.     ptr += MINBPC;
  701.     if (ptr == end)
  702.       return XML_TOK_PARTIAL;
  703.     if (!CHAR_MATCHES(enc, ptr, '>')) {
  704.       ptr -= MINBPC;
  705.       break;
  706.     }
  707.     *nextTokPtr = ptr;
  708.     return XML_TOK_INVALID;
  709.   INVALID_CASES(ptr, nextTokPtr)
  710.   default:
  711.     ptr += MINBPC;
  712.     break;
  713.   }
  714.   while (ptr != end) {
  715.     switch (BYTE_TYPE(enc, ptr)) {
  716. #define LEAD_CASE(n) \
  717.     case BT_LEAD ## n: \
  718.       if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
  719.     *nextTokPtr = ptr; \
  720.     return XML_TOK_DATA_CHARS; \
  721.       } \
  722.       ptr += n; \
  723.       break;
  724.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  725. #undef LEAD_CASE
  726.     case BT_RSQB:
  727.       if (ptr + MINBPC != end) {
  728.      if (!CHAR_MATCHES(enc, ptr + MINBPC, ']')) {
  729.        ptr += MINBPC;
  730.        break;
  731.      }
  732.      if (ptr + 2*MINBPC != end) {
  733.        if (!CHAR_MATCHES(enc, ptr + 2*MINBPC, '>')) {
  734.          ptr += MINBPC;
  735.          break;
  736.        }
  737.        *nextTokPtr = ptr + 2*MINBPC;
  738.        return XML_TOK_INVALID;
  739.      }
  740.       }
  741.       /* fall through */
  742.     case BT_AMP:
  743.     case BT_LT:
  744.     case BT_NONXML:
  745.     case BT_MALFORM:
  746.     case BT_TRAIL:
  747.     case BT_CR:
  748.     case BT_LF:
  749.       *nextTokPtr = ptr;
  750.       return XML_TOK_DATA_CHARS;
  751.     default:
  752.       ptr += MINBPC;
  753.       break;
  754.     }
  755.   }
  756.   *nextTokPtr = ptr;
  757.   return XML_TOK_DATA_CHARS;
  758. }
  759.  
  760. /* ptr points to character following "%" */
  761.  
  762. static
  763. int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
  764.             const char **nextTokPtr)
  765. {
  766.   if (ptr == end)
  767.     return XML_TOK_PARTIAL;
  768.   switch (BYTE_TYPE(enc, ptr)) {
  769.   CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
  770.   case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
  771.     *nextTokPtr = ptr;
  772.     return XML_TOK_PERCENT;
  773.   default:
  774.     *nextTokPtr = ptr;
  775.     return XML_TOK_INVALID;
  776.   }
  777.   while (ptr != end) {
  778.     switch (BYTE_TYPE(enc, ptr)) {
  779.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  780.     case BT_SEMI:
  781.       *nextTokPtr = ptr + MINBPC;
  782.       return XML_TOK_PARAM_ENTITY_REF;
  783.     default:
  784.       *nextTokPtr = ptr;
  785.       return XML_TOK_INVALID;
  786.     }
  787.   }
  788.   return XML_TOK_PARTIAL;
  789. }
  790.  
  791. static
  792. int PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
  793.               const char **nextTokPtr)
  794. {
  795.   if (ptr == end)
  796.     return XML_TOK_PARTIAL;
  797.   switch (BYTE_TYPE(enc, ptr)) {
  798.   CHECK_NMSTRT_CASES(end, ptr, end, nextTokPtr)
  799.   default:
  800.     *nextTokPtr = ptr;
  801.     return XML_TOK_INVALID;
  802.   }
  803.   while (ptr != end) {
  804.     switch (BYTE_TYPE(enc, ptr)) {
  805.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  806.     case BT_CR: case BT_LF: case BT_S:
  807.     case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
  808.       *nextTokPtr = ptr;
  809.       return XML_TOK_POUND_NAME;
  810.     default:
  811.       *nextTokPtr = ptr;
  812.       return XML_TOK_INVALID;
  813.     }
  814.   }
  815.   return XML_TOK_PARTIAL;
  816. }
  817.  
  818. static
  819. int PREFIX(scanLit)(int open, const ENCODING *enc,
  820.             const char *ptr, const char *end,
  821.             const char **nextTokPtr)
  822. {
  823.   while (ptr != end) {
  824.     int t = BYTE_TYPE(enc, ptr);
  825.     switch (t) {
  826.     INVALID_CASES(ptr, nextTokPtr)
  827.     case BT_QUOT:
  828.     case BT_APOS:
  829.       ptr += MINBPC;
  830.       if (t != open)
  831.     break;
  832.       if (ptr == end)
  833.     return XML_TOK_PARTIAL;
  834.       *nextTokPtr = ptr;
  835.       switch (BYTE_TYPE(enc, ptr)) {
  836.       case BT_S: case BT_CR: case BT_LF:
  837.       case BT_GT: case BT_PERCNT: case BT_LSQB:
  838.     return XML_TOK_LITERAL;
  839.       default:
  840.     return XML_TOK_INVALID;
  841.       }
  842.     default:
  843.       ptr += MINBPC;
  844.       break;
  845.     }
  846.   }
  847.   return XML_TOK_PARTIAL;
  848. }
  849.  
  850. static
  851. int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
  852.               const char **nextTokPtr)
  853. {
  854.   int tok;
  855.   if (ptr == end)
  856.     return XML_TOK_NONE;
  857. #if MINBPC > 1
  858.   {
  859.     size_t n = end - ptr;
  860.     if (n & (MINBPC - 1)) {
  861.       n &= ~(MINBPC - 1);
  862.       if (n == 0)
  863.     return XML_TOK_PARTIAL;
  864.       end = ptr + n;
  865.     }
  866.   }
  867. #endif
  868.   switch (BYTE_TYPE(enc, ptr)) {
  869.   case BT_QUOT:
  870.     return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC, end, nextTokPtr);
  871.   case BT_APOS:
  872.     return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC, end, nextTokPtr);
  873.   case BT_LT:
  874.     {
  875.       ptr += MINBPC;
  876.       if (ptr == end)
  877.     return XML_TOK_PARTIAL;
  878.       switch (BYTE_TYPE(enc, ptr)) {
  879.       case BT_EXCL:
  880.     return PREFIX(scanDecl)(enc, ptr + MINBPC, end, nextTokPtr);
  881.       case BT_QUEST:
  882.     return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
  883.       case BT_NMSTRT:
  884.       case BT_HEX:
  885.       case BT_NONASCII:
  886.       case BT_LEAD2:
  887.       case BT_LEAD3:
  888.       case BT_LEAD4:
  889.     *nextTokPtr = ptr - MINBPC;
  890.     return XML_TOK_INSTANCE_START;
  891.       }
  892.       *nextTokPtr = ptr;
  893.       return XML_TOK_INVALID;
  894.     }
  895.   case BT_CR:
  896.     if (ptr + MINBPC == end)
  897.       return XML_TOK_TRAILING_CR;
  898.     /* fall through */
  899.   case BT_S: case BT_LF:
  900.     for (;;) {
  901.       ptr += MINBPC;
  902.       if (ptr == end)
  903.     break;
  904.       switch (BYTE_TYPE(enc, ptr)) {
  905.       case BT_S: case BT_LF:
  906.     break;
  907.       case BT_CR:
  908.     /* don't split CR/LF pair */
  909.     if (ptr + MINBPC != end)
  910.       break;
  911.     /* fall through */
  912.       default:
  913.     *nextTokPtr = ptr;
  914.     return XML_TOK_PROLOG_S;
  915.       }
  916.     }
  917.     *nextTokPtr = ptr;
  918.     return XML_TOK_PROLOG_S;
  919.   case BT_PERCNT:
  920.     return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
  921.   case BT_COMMA:
  922.     *nextTokPtr = ptr + MINBPC;
  923.     return XML_TOK_COMMA;
  924.   case BT_LSQB:
  925.     *nextTokPtr = ptr + MINBPC;
  926.     return XML_TOK_OPEN_BRACKET;
  927.   case BT_RSQB:
  928.     ptr += MINBPC;
  929.     if (ptr == end)
  930.       return XML_TOK_PARTIAL;
  931.     if (CHAR_MATCHES(enc, ptr, ']')) {
  932.       if (ptr + MINBPC == end)
  933.     return XML_TOK_PARTIAL;
  934.       if (CHAR_MATCHES(enc, ptr + MINBPC, '>')) {
  935.     *nextTokPtr = ptr + 2*MINBPC;
  936.     return XML_TOK_COND_SECT_CLOSE;
  937.       }
  938.     }
  939.     *nextTokPtr = ptr;
  940.     return XML_TOK_CLOSE_BRACKET;
  941.   case BT_LPAR:
  942.     *nextTokPtr = ptr + MINBPC;
  943.     return XML_TOK_OPEN_PAREN;
  944.   case BT_RPAR:
  945.     ptr += MINBPC;
  946.     if (ptr == end)
  947.       return XML_TOK_INVALID;
  948.     switch (BYTE_TYPE(enc, ptr)) {
  949.     case BT_AST:
  950.       *nextTokPtr = ptr + MINBPC;
  951.       return XML_TOK_CLOSE_PAREN_ASTERISK;
  952.     case BT_QUEST:
  953.       *nextTokPtr = ptr + MINBPC;
  954.       return XML_TOK_CLOSE_PAREN_QUESTION;
  955.     case BT_PLUS:
  956.       *nextTokPtr = ptr + MINBPC;
  957.       return XML_TOK_CLOSE_PAREN_PLUS;
  958.     case BT_CR: case BT_LF: case BT_S:
  959.     case BT_GT: case BT_COMMA: case BT_VERBAR:
  960.     case BT_RPAR:
  961.       *nextTokPtr = ptr;
  962.       return XML_TOK_CLOSE_PAREN;
  963.     }
  964.     *nextTokPtr = ptr;
  965.     return XML_TOK_INVALID;
  966.   case BT_VERBAR:
  967.     *nextTokPtr = ptr + MINBPC;
  968.     return XML_TOK_OR;
  969.   case BT_GT:
  970.     *nextTokPtr = ptr + MINBPC;
  971.     return XML_TOK_DECL_CLOSE;
  972.   case BT_NUM:
  973.     return PREFIX(scanPoundName)(enc, ptr + MINBPC, end, nextTokPtr);
  974. #define LEAD_CASE(n) \
  975.   case BT_LEAD ## n: \
  976.     if (end - ptr < n) \
  977.       return XML_TOK_PARTIAL_CHAR; \
  978.     if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
  979.       ptr += n; \
  980.       tok = XML_TOK_NAME; \
  981.       break; \
  982.     } \
  983.     if (IS_NAME_CHAR(enc, ptr, n)) { \
  984.       ptr += n; \
  985.       tok = XML_TOK_NMTOKEN; \
  986.       break; \
  987.     } \
  988.     *nextTokPtr = ptr; \
  989.     return XML_TOK_INVALID;
  990.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  991. #undef LEAD_CASE
  992.   case BT_NMSTRT:
  993.   case BT_HEX:
  994.     tok = XML_TOK_NAME;
  995.     ptr += MINBPC;
  996.     break;
  997.   case BT_DIGIT:
  998.   case BT_NAME:
  999.   case BT_MINUS:
  1000.     tok = XML_TOK_NMTOKEN;
  1001.     ptr += MINBPC;
  1002.     break;
  1003.   case BT_NONASCII:
  1004.     if (IS_NMSTRT_CHAR(enc, ptr, MINBPC)) {
  1005.       ptr += MINBPC;
  1006.       tok = XML_TOK_NAME;
  1007.       break;
  1008.     }
  1009.     if (IS_NAME_CHAR(enc, ptr, MINBPC)) {
  1010.       ptr += MINBPC;
  1011.       tok = XML_TOK_NMTOKEN;
  1012.       break;
  1013.     }
  1014.     /* fall through */
  1015.   default:
  1016.     *nextTokPtr = ptr;
  1017.     return XML_TOK_INVALID;
  1018.   }
  1019.   while (ptr != end) {
  1020.     switch (BYTE_TYPE(enc, ptr)) {
  1021.     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
  1022.     case BT_GT: case BT_RPAR: case BT_COMMA:
  1023.     case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
  1024.     case BT_S: case BT_CR: case BT_LF:
  1025.       *nextTokPtr = ptr;
  1026.       return tok;
  1027.     case BT_PLUS:
  1028.       if (tok != XML_TOK_NAME)  {
  1029.     *nextTokPtr = ptr;
  1030.     return XML_TOK_INVALID;
  1031.       }
  1032.       *nextTokPtr = ptr + MINBPC;
  1033.       return XML_TOK_NAME_PLUS;
  1034.     case BT_AST:
  1035.       if (tok != XML_TOK_NAME)  {
  1036.     *nextTokPtr = ptr;
  1037.     return XML_TOK_INVALID;
  1038.       }
  1039.       *nextTokPtr = ptr + MINBPC;
  1040.       return XML_TOK_NAME_ASTERISK;
  1041.     case BT_QUEST:
  1042.       if (tok != XML_TOK_NAME)  {
  1043.     *nextTokPtr = ptr;
  1044.     return XML_TOK_INVALID;
  1045.       }
  1046.       *nextTokPtr = ptr + MINBPC;
  1047.       return XML_TOK_NAME_QUESTION;
  1048.     default:
  1049.       *nextTokPtr = ptr;
  1050.       return XML_TOK_INVALID;
  1051.     }
  1052.   }
  1053.   return XML_TOK_PARTIAL;
  1054. }
  1055.  
  1056. static
  1057. int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
  1058.                   const char **nextTokPtr)
  1059. {
  1060.   const char *start;
  1061.   if (ptr == end)
  1062.     return XML_TOK_NONE;
  1063.   start = ptr;
  1064.   while (ptr != end) {
  1065.     switch (BYTE_TYPE(enc, ptr)) {
  1066. #define LEAD_CASE(n) \
  1067.     case BT_LEAD ## n: ptr += n; break;
  1068.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  1069. #undef LEAD_CASE
  1070.     case BT_AMP:
  1071.       if (ptr == start)
  1072.     return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
  1073.       *nextTokPtr = ptr;
  1074.       return XML_TOK_DATA_CHARS;
  1075.     case BT_LT:
  1076.       /* this is for inside entity references */
  1077.       *nextTokPtr = ptr;
  1078.       return XML_TOK_INVALID;
  1079.     case BT_LF:
  1080.       if (ptr == start) {
  1081.     *nextTokPtr = ptr + MINBPC;
  1082.     return XML_TOK_DATA_NEWLINE;
  1083.       }
  1084.       *nextTokPtr = ptr;
  1085.       return XML_TOK_DATA_CHARS;
  1086.     case BT_CR:
  1087.       if (ptr == start) {
  1088.     ptr += MINBPC;
  1089.     if (ptr == end)
  1090.       return XML_TOK_TRAILING_CR;
  1091.     if (BYTE_TYPE(enc, ptr) == BT_LF)
  1092.       ptr += MINBPC;
  1093.     *nextTokPtr = ptr;
  1094.     return XML_TOK_DATA_NEWLINE;
  1095.       }
  1096.       *nextTokPtr = ptr;
  1097.       return XML_TOK_DATA_CHARS;
  1098.     case BT_S:
  1099.       if (ptr == start) {
  1100.     *nextTokPtr = ptr + MINBPC;
  1101.     return XML_TOK_ATTRIBUTE_VALUE_S;
  1102.       }
  1103.       *nextTokPtr = ptr;
  1104.       return XML_TOK_DATA_CHARS;
  1105.     default:
  1106.       ptr += MINBPC;
  1107.       break;
  1108.     }
  1109.   }
  1110.   *nextTokPtr = ptr;
  1111.   return XML_TOK_DATA_CHARS;
  1112. }
  1113.  
  1114. static
  1115. int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
  1116.                const char **nextTokPtr)
  1117. {
  1118.   const char *start;
  1119.   if (ptr == end)
  1120.     return XML_TOK_NONE;
  1121.   start = ptr;
  1122.   while (ptr != end) {
  1123.     switch (BYTE_TYPE(enc, ptr)) {
  1124. #define LEAD_CASE(n) \
  1125.     case BT_LEAD ## n: ptr += n; break;
  1126.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  1127. #undef LEAD_CASE
  1128.     case BT_AMP:
  1129.       if (ptr == start)
  1130.     return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
  1131.       *nextTokPtr = ptr;
  1132.       return XML_TOK_DATA_CHARS;
  1133.     case BT_PERCNT:
  1134.       if (ptr == start)
  1135.     return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
  1136.       *nextTokPtr = ptr;
  1137.       return XML_TOK_DATA_CHARS;
  1138.     case BT_LF:
  1139.       if (ptr == start) {
  1140.     *nextTokPtr = ptr + MINBPC;
  1141.     return XML_TOK_DATA_NEWLINE;
  1142.       }
  1143.       *nextTokPtr = ptr;
  1144.       return XML_TOK_DATA_CHARS;
  1145.     case BT_CR:
  1146.       if (ptr == start) {
  1147.     ptr += MINBPC;
  1148.     if (ptr == end)
  1149.       return XML_TOK_TRAILING_CR;
  1150.     if (BYTE_TYPE(enc, ptr) == BT_LF)
  1151.       ptr += MINBPC;
  1152.     *nextTokPtr = ptr;
  1153.     return XML_TOK_DATA_NEWLINE;
  1154.       }
  1155.       *nextTokPtr = ptr;
  1156.       return XML_TOK_DATA_CHARS;
  1157.     default:
  1158.       ptr += MINBPC;
  1159.       break;
  1160.     }
  1161.   }
  1162.   *nextTokPtr = ptr;
  1163.   return XML_TOK_DATA_CHARS;
  1164. }
  1165.  
  1166. static
  1167. int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
  1168.                const char **badPtr)
  1169. {
  1170.   ptr += MINBPC;
  1171.   end -= MINBPC;
  1172.   for (; ptr != end; ptr += MINBPC) {
  1173.     switch (BYTE_TYPE(enc, ptr)) {
  1174.     case BT_DIGIT:
  1175.     case BT_HEX:
  1176.     case BT_MINUS:
  1177.     case BT_APOS:
  1178.     case BT_LPAR:
  1179.     case BT_RPAR:
  1180.     case BT_PLUS:
  1181.     case BT_COMMA:
  1182.     case BT_SOL:
  1183.     case BT_EQUALS:
  1184.     case BT_QUEST:
  1185.     case BT_CR:
  1186.     case BT_LF:
  1187.     case BT_SEMI:
  1188.     case BT_EXCL:
  1189.     case BT_AST:
  1190.     case BT_PERCNT:
  1191.     case BT_NUM:
  1192.       break;
  1193.     case BT_S:
  1194.       if (CHAR_MATCHES(enc, ptr, '\t')) {
  1195.     *badPtr = ptr;
  1196.     return 0;
  1197.       }
  1198.       break;
  1199.     case BT_NAME:
  1200.     case BT_NMSTRT:
  1201.       if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
  1202.     break;
  1203.     default:
  1204.       switch (BYTE_TO_ASCII(enc, ptr)) {
  1205.       case 0x24: /* $ */
  1206.       case 0x40: /* @ */
  1207.     break;
  1208.       default:
  1209.     *badPtr = ptr;
  1210.     return 0;
  1211.       }
  1212.       break;
  1213.     }
  1214.   }
  1215.   return 1;
  1216. }
  1217.  
  1218. /* This must only be called for a well-formed start-tag or empty element tag.
  1219. Returns the number of attributes.  Pointers to the first attsMax attributes 
  1220. are stored in atts. */
  1221.  
  1222. static
  1223. int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
  1224.             int attsMax, ATTRIBUTE *atts)
  1225. {
  1226.   enum { other, inName, inValue } state = inName;
  1227.   int nAtts = 0;
  1228.   int open;
  1229.  
  1230.   for (ptr += MINBPC;; ptr += MINBPC) {
  1231.     switch (BYTE_TYPE(enc, ptr)) {
  1232. #define START_NAME \
  1233.       if (state == other) { \
  1234.     if (nAtts < attsMax) { \
  1235.       atts[nAtts].name = ptr; \
  1236.       atts[nAtts].normalized = 1; \
  1237.     } \
  1238.     state = inName; \
  1239.       }
  1240. #define LEAD_CASE(n) \
  1241.     case BT_LEAD ## n: START_NAME ptr += (n - MINBPC); break;
  1242.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  1243. #undef LEAD_CASE
  1244.     case BT_NONASCII:
  1245.     case BT_NMSTRT:
  1246.     case BT_HEX:
  1247.       START_NAME
  1248.       break;
  1249. #undef START_NAME
  1250.     case BT_QUOT:
  1251.       if (state != inValue) {
  1252.     atts[nAtts].valuePtr = ptr + MINBPC;
  1253.         state = inValue;
  1254.         open = BT_QUOT;
  1255.       }
  1256.       else if (open == BT_QUOT) {
  1257.         state = other;
  1258.     atts[nAtts++].valueEnd = ptr;
  1259.       }
  1260.       break;
  1261.     case BT_APOS:
  1262.       if (state != inValue) {
  1263.     atts[nAtts].valuePtr = ptr + MINBPC;
  1264.         state = inValue;
  1265.         open = BT_APOS;
  1266.       }
  1267.       else if (open == BT_APOS) {
  1268.         state = other;
  1269.     atts[nAtts++].valueEnd = ptr;
  1270.       }
  1271.       break;
  1272.     case BT_AMP:
  1273.       atts[nAtts].normalized = 0;
  1274.       break;
  1275.     case BT_S:
  1276.       if (state == inName)
  1277.         state = other;
  1278.       else if (state == inValue
  1279.            && atts[nAtts].normalized
  1280.            && (ptr == atts[nAtts].valuePtr
  1281.            || BYTE_TO_ASCII(enc, ptr) != ' '
  1282.            || BYTE_TO_ASCII(enc, ptr + MINBPC) == ' '
  1283.                || BYTE_TYPE(enc, ptr + MINBPC) == open))
  1284.     atts[nAtts].normalized = 0;
  1285.       break;
  1286.     case BT_CR: case BT_LF:
  1287.       /* This case ensures that the first attribute name is counted
  1288.          Apart from that we could just change state on the quote. */
  1289.       if (state == inName)
  1290.         state = other;
  1291.       else if (state == inValue)
  1292.     atts[nAtts].normalized = 0;
  1293.       break;
  1294.     case BT_GT:
  1295.     case BT_SOL:
  1296.       if (state != inValue)
  1297.     return nAtts;
  1298.       break;
  1299.     default:
  1300.       break;
  1301.     }
  1302.   }
  1303.   /* not reached */
  1304. }
  1305.  
  1306. static
  1307. int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
  1308. {
  1309.   int result = 0;
  1310.   /* skip &# */
  1311.   ptr += 2*MINBPC;
  1312.   if (CHAR_MATCHES(enc, ptr, 'x')) {
  1313.     for (ptr += MINBPC; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
  1314.       int c = BYTE_TO_ASCII(enc, ptr);
  1315.       switch (c) {
  1316.       case '0': case '1': case '2': case '3': case '4':
  1317.       case '5': case '6': case '7': case '8': case '9':
  1318.     result <<= 4;
  1319.     result |= (c - '0');
  1320.     break;
  1321.       case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  1322.     result <<= 4;
  1323.     result += 10 + (c - 'A');
  1324.     break;
  1325.       case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
  1326.     result <<= 4;
  1327.     result += 10 + (c - 'a');
  1328.     break;
  1329.       }
  1330.       if (result >= 0x110000)
  1331.     return -1;
  1332.     }
  1333.   }
  1334.   else {
  1335.     for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
  1336.       int c = BYTE_TO_ASCII(enc, ptr);
  1337.       result *= 10;
  1338.       result += (c - '0');
  1339.       if (result >= 0x110000)
  1340.     return -1;
  1341.     }
  1342.   }
  1343.   return checkCharRefNumber(result);
  1344. }
  1345.  
  1346. static
  1347. int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
  1348. {
  1349.   for (;;) {
  1350.     switch (BYTE_TYPE(enc, ptr1)) {
  1351. #define LEAD_CASE(n) \
  1352.     case BT_LEAD ## n: \
  1353.       if (*ptr1++ != *ptr2++) \
  1354.     return 0;
  1355.     LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
  1356. #undef LEAD_CASE
  1357.       /* fall through */
  1358.       if (*ptr1++ != *ptr2++)
  1359.     return 0;
  1360.       break;
  1361.     case BT_NONASCII:
  1362.     case BT_NMSTRT:
  1363.     case BT_HEX:
  1364.     case BT_DIGIT:
  1365.     case BT_NAME:
  1366.     case BT_MINUS:
  1367.       if (*ptr2++ != *ptr1++)
  1368.     return 0;
  1369. #if MINBPC > 1
  1370.       if (*ptr2++ != *ptr1++)
  1371.     return 0;
  1372. #if MINBPC > 2
  1373.       if (*ptr2++ != *ptr1++)
  1374.     return 0;
  1375. #if MINBPC > 3
  1376.       if (*ptr2++ != *ptr1++)
  1377.     return 0;
  1378. #endif
  1379. #endif
  1380. #endif
  1381.       break;
  1382.     default:
  1383. #if MINBPC == 1
  1384.       if (*ptr1 == *ptr2)
  1385.     return 1;
  1386. #endif
  1387.       switch (BYTE_TYPE(enc, ptr2)) {
  1388.       case BT_LEAD2:
  1389.       case BT_LEAD3:
  1390.       case BT_LEAD4:
  1391.       case BT_NONASCII:
  1392.       case BT_NMSTRT:
  1393.       case BT_HEX:
  1394.       case BT_DIGIT:
  1395.       case BT_NAME:
  1396.       case BT_MINUS:
  1397.     return 0;
  1398.       default:
  1399.     return 1;
  1400.       }
  1401.     }
  1402.   }
  1403.   /* not reached */
  1404. }
  1405.  
  1406. static
  1407. int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *ptr2)
  1408. {
  1409.   for (; *ptr2; ptr1 += MINBPC, ptr2++) {
  1410.     if (!CHAR_MATCHES(end, ptr1, *ptr2))
  1411.       return 0;
  1412.   }
  1413.   switch (BYTE_TYPE(enc, ptr1)) {
  1414.   case BT_LEAD2:
  1415.   case BT_LEAD3:
  1416.   case BT_LEAD4:
  1417.   case BT_NONASCII:
  1418.   case BT_NMSTRT:
  1419.   case BT_HEX:
  1420.   case BT_DIGIT:
  1421.   case BT_NAME:
  1422.   case BT_MINUS:
  1423.     return 0;
  1424.   default:
  1425.     return 1;
  1426.   }
  1427. }
  1428.  
  1429. static
  1430. int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
  1431. {
  1432.   const char *start = ptr;
  1433.   for (;;) {
  1434.     switch (BYTE_TYPE(enc, ptr)) {
  1435. #define LEAD_CASE(n) \
  1436.     case BT_LEAD ## n: ptr += n; break;
  1437.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  1438. #undef LEAD_CASE
  1439.     case BT_NONASCII:
  1440.     case BT_NMSTRT:
  1441.     case BT_HEX:
  1442.     case BT_DIGIT:
  1443.     case BT_NAME:
  1444.     case BT_MINUS:
  1445.       ptr += MINBPC;
  1446.       break;
  1447.     default:
  1448.       return ptr - start;
  1449.     }
  1450.   }
  1451. }
  1452.  
  1453. static
  1454. const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
  1455. {
  1456.   for (;;) {
  1457.     switch (BYTE_TYPE(enc, ptr)) {
  1458.     case BT_LF:
  1459.     case BT_CR:
  1460.     case BT_S:
  1461.       ptr += MINBPC;
  1462.       break;
  1463.     default:
  1464.       return ptr;
  1465.     }
  1466.   }
  1467. }
  1468.  
  1469. static
  1470. void PREFIX(updatePosition)(const ENCODING *enc,
  1471.                 const char *ptr,
  1472.                 const char *end,
  1473.                 POSITION *pos)
  1474. {
  1475.   while (ptr != end) {
  1476.     switch (BYTE_TYPE(enc, ptr)) {
  1477. #define LEAD_CASE(n) \
  1478.     case BT_LEAD ## n: \
  1479.       ptr += n; \
  1480.       break;
  1481.     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
  1482. #undef LEAD_CASE
  1483.     case BT_LF:
  1484.       pos->columnNumber = (unsigned)-1;
  1485.       pos->lineNumber++;
  1486.       ptr += MINBPC;
  1487.       break;
  1488.     case BT_CR:
  1489.       pos->lineNumber++;
  1490.       ptr += MINBPC;
  1491.       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
  1492.     ptr += MINBPC;
  1493.       pos->columnNumber = (unsigned)-1;
  1494.       break;
  1495.     default:
  1496.       ptr += MINBPC;
  1497.       break;
  1498.     }
  1499.     pos->columnNumber++;
  1500.   }
  1501. }
  1502.  
  1503. #undef DO_LEAD_CASE
  1504. #undef MULTIBYTE_CASES
  1505. #undef INVALID_CASES
  1506. #undef CHECK_NAME_CASE
  1507. #undef CHECK_NAME_CASES
  1508. #undef CHECK_NMSTRT_CASE
  1509. #undef CHECK_NMSTRT_CASES
  1510.