Allow MINBPC to depend on enc

diff --git a/expat/xmltok/xmltok_impl.c b/expat/xmltok/xmltok_impl.c
index 449492383495aedb3e4418f7a29c1f4d3401ebbb..0a5ebd7c995e6d4aa0198387ef0c5a35cbe3950c 100755 (executable)
--- a/expat/xmltok/xmltok_impl.c
+++ b/expat/xmltok/xmltok_impl.c
@@ -65,7 +65,7 @@ Contributor(s):
   case BT_DIGIT: \
   case BT_NAME: \
   case BT_MINUS: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -90,7 +90,7 @@ Contributor(s):
     } \
   case BT_NMSTRT: \
   case BT_HEX: \
-    ptr += MINBPC; \
+    ptr += MINBPC(enc); \
     break; \
   CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
   CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
@@ -111,26 +111,26 @@ int PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     while (ptr != end) {
       switch (BYTE_TYPE(enc, ptr)) {
       INVALID_CASES(ptr, nextTokPtr)
       case BT_MINUS:
-       if ((ptr += MINBPC) == end)
+       if ((ptr += MINBPC(enc)) == end)
          return XML_TOK_PARTIAL;
        if (CHAR_MATCHES(enc, ptr, '-')) {
-         if ((ptr += MINBPC) == end)
+         if ((ptr += MINBPC(enc)) == end)
            return XML_TOK_PARTIAL;
          if (!CHAR_MATCHES(enc, ptr, '>')) {
            *nextTokPtr = ptr;
            return XML_TOK_INVALID;
          }
-         *nextTokPtr = ptr + MINBPC;
+         *nextTokPtr = ptr + MINBPC(enc);
          return XML_TOK_COMMENT;
        }
        break;
       default:
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        break;
       }
     }
@@ -148,13 +148,13 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
     return XML_TOK_PARTIAL;
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_MINUS:
-    return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COND_SECT_OPEN;
   case BT_NMSTRT:
   case BT_HEX:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   default:
     *nextTokPtr = ptr;
@@ -163,10 +163,10 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
   while (ptr != end) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_PERCNT:
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
        return XML_TOK_PARTIAL;
       /* don't allow <!ENTITY% foo "whatever"> */
-      switch (BYTE_TYPE(enc, ptr + MINBPC)) {
+      switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
       case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
@@ -177,7 +177,7 @@ int PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
       return XML_TOK_DECL_OPEN;
     case BT_NMSTRT:
     case BT_HEX:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       *nextTokPtr = ptr;
@@ -192,7 +192,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
 {
   int upper = 0;
   *tokPtr = XML_TOK_PI;
-  if (end - ptr != MINBPC*3)
+  if (end - ptr != MINBPC(enc)*3)
     return 1;
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'x':
@@ -203,7 +203,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'm':
     break;
@@ -213,7 +213,7 @@ int PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
   default:
     return 1;
   }
-  ptr += MINBPC;
+  ptr += MINBPC(enc);
   switch (BYTE_TO_ASCII(enc, ptr)) {
   case 'l':
     break;
@@ -253,21 +253,21 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       while (ptr != end) {
         switch (BYTE_TYPE(enc, ptr)) {
         INVALID_CASES(ptr, nextTokPtr)
        case BT_QUEST:
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          if (ptr == end)
            return XML_TOK_PARTIAL;
          if (CHAR_MATCHES(enc, ptr, '>')) {
-           *nextTokPtr = ptr + MINBPC;
+           *nextTokPtr = ptr + MINBPC(enc);
            return tok;
          }
          break;
        default:
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          break;
        }
       }
@@ -277,11 +277,11 @@ int PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        return XML_TOK_PARTIAL;
       if (CHAR_MATCHES(enc, ptr, '>')) {
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return tok;
       }
       /* fall through */
@@ -300,9 +300,9 @@ int PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *e
 {
   int i;
   /* CDATA[ */
-  if (end - ptr < 6 * MINBPC)
+  if (end - ptr < 6 * MINBPC(enc))
     return XML_TOK_PARTIAL;
-  for (i = 0; i < 6; i++, ptr += MINBPC) {
+  for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
     if (!CHAR_MATCHES(enc, ptr, "CDATA["[i])) {
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
@@ -318,47 +318,45 @@ int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *en
 {
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
        return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (!CHAR_MATCHES(enc, ptr, ']'))
       break;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (!CHAR_MATCHES(enc, ptr, '>')) {
-      ptr -= MINBPC;
+      ptr -= MINBPC(enc);
       break;
     }
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_CDATA_SECT_CLOSE;
   case BT_CR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   INVALID_CASES(ptr, nextTokPtr)
   default:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   }
   while (ptr != end) {
@@ -382,7 +380,7 @@ int PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *en
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -408,12 +406,12 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_S: case BT_CR: case BT_LF:
-      for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+      for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
        switch (BYTE_TYPE(enc, ptr)) {
        case BT_S: case BT_CR: case BT_LF:
          break;
        case BT_GT:
-         *nextTokPtr = ptr + MINBPC;
+         *nextTokPtr = ptr + MINBPC(enc);
           return XML_TOK_END_TAG;
        default:
          *nextTokPtr = ptr;
@@ -424,11 +422,11 @@ int PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
 #ifdef XMLNS
     case BT_COLON:
       /* no need to check qname syntax here, since end-tag must match exactly */
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
 #endif
     case BT_GT:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_END_TAG;
     default:
       *nextTokPtr = ptr;
@@ -453,13 +451,13 @@ int PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
       case BT_HEX:
        break;
       case BT_SEMI:
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_CHAR_REF;
       default:
        *nextTokPtr = ptr;
@@ -478,7 +476,7 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr != end) {
     if (CHAR_MATCHES(enc, ptr, 'x'))
-      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
       break;
@@ -486,12 +484,12 @@ int PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
-    for (ptr += MINBPC; ptr != end; ptr += MINBPC) {
+    for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_DIGIT:
        break;
       case BT_SEMI:
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_CHAR_REF;
       default:
        *nextTokPtr = ptr;
@@ -513,7 +511,7 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
   switch (BYTE_TYPE(enc, ptr)) {
   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_NUM:
-    return PREFIX(scanCharRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -522,7 +520,7 @@ int PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -551,7 +549,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
        return XML_TOK_INVALID;
       }
       hadColon = 1;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -566,7 +564,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
       for (;;) {
        int t;
 
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_PARTIAL;
        t = BYTE_TYPE(enc, ptr);
@@ -591,7 +589,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
 #endif
        for (;;) {
          
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          if (ptr == end)
            return XML_TOK_PARTIAL;
          open = BYTE_TYPE(enc, ptr);
@@ -607,7 +605,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
            return XML_TOK_INVALID;
          }
        }
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        /* in attribute value */
        for (;;) {
          int t;
@@ -620,7 +618,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
          INVALID_CASES(ptr, nextTokPtr)
          case BT_AMP:
            {
-             int tok = PREFIX(scanRef)(enc, ptr + MINBPC, end, &ptr);
+             int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
              if (tok <= 0) {
                if (tok == XML_TOK_INVALID)
                  *nextTokPtr = ptr;
@@ -632,11 +630,11 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
            *nextTokPtr = ptr;
            return XML_TOK_INVALID;
          default:
-           ptr += MINBPC;
+           ptr += MINBPC(enc);
            break;
          }
        }
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_PARTIAL;
        switch (BYTE_TYPE(enc, ptr)) {
@@ -654,7 +652,7 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
        }
        /* ptr points to closing quote */
        for (;;) {
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          if (ptr == end)
            return XML_TOK_PARTIAL;
          switch (BYTE_TYPE(enc, ptr)) {
@@ -663,18 +661,18 @@ int PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
            continue;
          case BT_GT:
           gt:
-           *nextTokPtr = ptr + MINBPC;
+           *nextTokPtr = ptr + MINBPC(enc);
            return XML_TOK_START_TAG_WITH_ATTS;
          case BT_SOL:
           sol:
-           ptr += MINBPC;
+           ptr += MINBPC(enc);
            if (ptr == end)
              return XML_TOK_PARTIAL;
            if (!CHAR_MATCHES(enc, ptr, '>')) {
              *nextTokPtr = ptr;
              return XML_TOK_INVALID;
            }
-           *nextTokPtr = ptr + MINBPC;
+           *nextTokPtr = ptr + MINBPC(enc);
            return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
          default:
            *nextTokPtr = ptr;
@@ -706,20 +704,20 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
   switch (BYTE_TYPE(enc, ptr)) {
   CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
   case BT_EXCL:
-    if ((ptr += MINBPC) == end)
+    if ((ptr += MINBPC(enc)) == end)
       return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_MINUS:
-      return PREFIX(scanComment)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     case BT_LSQB:
-      return PREFIX(scanCdataSection)(enc, ptr + MINBPC, end, nextTokPtr);
+      return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_QUEST:
-    return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_SOL:
-    return PREFIX(scanEndTag)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   default:
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
@@ -738,7 +736,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
        return XML_TOK_INVALID;
       }
       hadColon = 1;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -751,7 +749,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
 #endif
     case BT_S: case BT_CR: case BT_LF:
       {
-        ptr += MINBPC;
+        ptr += MINBPC(enc);
        while (ptr != end) {
          switch (BYTE_TYPE(enc, ptr)) {
          CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@@ -760,7 +758,7 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
          case BT_SOL:
            goto sol;
          case BT_S: case BT_CR: case BT_LF:
-           ptr += MINBPC;
+           ptr += MINBPC(enc);
            continue;
          default:
            *nextTokPtr = ptr;
@@ -772,18 +770,18 @@ int PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
       }
     case BT_GT:
     gt:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_START_TAG_NO_ATTS;
     case BT_SOL:
     sol:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        return XML_TOK_PARTIAL;
       if (!CHAR_MATCHES(enc, ptr, '>')) {
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
     default:
       *nextTokPtr = ptr;
@@ -799,51 +797,49 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
 {
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
        return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_LT:
-    return PREFIX(scanLt)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_AMP:
-    return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_CR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_CR;
     if (BYTE_TYPE(enc, ptr) == BT_LF)
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
     *nextTokPtr = ptr;
     return XML_TOK_DATA_NEWLINE;
   case BT_LF:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DATA_NEWLINE;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, ']'))
       break;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_TRAILING_RSQB;
     if (!CHAR_MATCHES(enc, ptr, '>')) {
-      ptr -= MINBPC;
+      ptr -= MINBPC(enc);
       break;
     }
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   INVALID_CASES(ptr, nextTokPtr)
   default:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   }
   while (ptr != end) {
@@ -859,17 +855,17 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_RSQB:
-      if (ptr + MINBPC != end) {
-        if (!CHAR_MATCHES(enc, ptr + MINBPC, ']')) {
-          ptr += MINBPC;
+      if (ptr + MINBPC(enc) != end) {
+        if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ']')) {
+          ptr += MINBPC(enc);
           break;
         }
-        if (ptr + 2*MINBPC != end) {
-          if (!CHAR_MATCHES(enc, ptr + 2*MINBPC, '>')) {
-            ptr += MINBPC;
+        if (ptr + 2*MINBPC(enc) != end) {
+          if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), '>')) {
+            ptr += MINBPC(enc);
             break;
           }
-          *nextTokPtr = ptr + 2*MINBPC;
+          *nextTokPtr = ptr + 2*MINBPC(enc);
           return XML_TOK_INVALID;
         }
       }
@@ -884,7 +880,7 @@ int PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -913,7 +909,7 @@ int PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
     switch (BYTE_TYPE(enc, ptr)) {
     CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
     case BT_SEMI:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_PARAM_ENTITY_REF;
     default:
       *nextTokPtr = ptr;
@@ -961,7 +957,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
     INVALID_CASES(ptr, nextTokPtr)
     case BT_QUOT:
     case BT_APOS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (t != open)
        break;
       if (ptr == end)
@@ -975,7 +971,7 @@ int PREFIX(scanLit)(int open, const ENCODING *enc,
        return XML_TOK_INVALID;
       }
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -989,51 +985,49 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   int tok;
   if (ptr == end)
     return XML_TOK_NONE;
-#if MINBPC > 1
-  {
+  if (MINBPC(enc) > 1) {
     size_t n = end - ptr;
-    if (n & (MINBPC - 1)) {
-      n &= ~(MINBPC - 1);
+    if (n & (MINBPC(enc) - 1)) {
+      n &= ~(MINBPC(enc) - 1);
       if (n == 0)
        return XML_TOK_PARTIAL;
       end = ptr + n;
     }
   }
-#endif
   switch (BYTE_TYPE(enc, ptr)) {
   case BT_QUOT:
-    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_APOS:
-    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_LT:
     {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        return XML_TOK_PARTIAL;
       switch (BYTE_TYPE(enc, ptr)) {
       case BT_EXCL:
-       return PREFIX(scanDecl)(enc, ptr + MINBPC, end, nextTokPtr);
+       return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_QUEST:
-       return PREFIX(scanPi)(enc, ptr + MINBPC, end, nextTokPtr);
+       return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       case BT_NMSTRT:
       case BT_HEX:
       case BT_NONASCII:
       case BT_LEAD2:
       case BT_LEAD3:
       case BT_LEAD4:
-       *nextTokPtr = ptr - MINBPC;
+       *nextTokPtr = ptr - MINBPC(enc);
        return XML_TOK_INSTANCE_START;
       }
       *nextTokPtr = ptr;
       return XML_TOK_INVALID;
     }
   case BT_CR:
-    if (ptr + MINBPC == end)
+    if (ptr + MINBPC(enc) == end)
       return XML_TOK_TRAILING_CR;
     /* fall through */
   case BT_S: case BT_LF:
     for (;;) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr == end)
        break;
       switch (BYTE_TYPE(enc, ptr)) {
@@ -1041,7 +1035,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
        break;
       case BT_CR:
        /* don't split CR/LF pair */
-       if (ptr + MINBPC != end)
+       if (ptr + MINBPC(enc) != end)
          break;
        /* fall through */
       default:
@@ -1052,43 +1046,43 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_PROLOG_S;
   case BT_PERCNT:
-    return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
   case BT_COMMA:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_COMMA;
   case BT_LSQB:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_BRACKET;
   case BT_RSQB:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     if (CHAR_MATCHES(enc, ptr, ']')) {
-      if (ptr + MINBPC == end)
+      if (ptr + MINBPC(enc) == end)
        return XML_TOK_PARTIAL;
-      if (CHAR_MATCHES(enc, ptr + MINBPC, '>')) {
-       *nextTokPtr = ptr + 2*MINBPC;
+      if (CHAR_MATCHES(enc, ptr + MINBPC(enc), '>')) {
+       *nextTokPtr = ptr + 2*MINBPC(enc);
        return XML_TOK_COND_SECT_CLOSE;
       }
     }
     *nextTokPtr = ptr;
     return XML_TOK_CLOSE_BRACKET;
   case BT_LPAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OPEN_PAREN;
   case BT_RPAR:
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     if (ptr == end)
       return XML_TOK_PARTIAL;
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_AST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_ASTERISK;
     case BT_QUEST:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_QUESTION;
     case BT_PLUS:
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_CLOSE_PAREN_PLUS;
     case BT_CR: case BT_LF: case BT_S:
     case BT_GT: case BT_COMMA: case BT_VERBAR:
@@ -1099,13 +1093,13 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
     *nextTokPtr = ptr;
     return XML_TOK_INVALID;
   case BT_VERBAR:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_OR;
   case BT_GT:
-    *nextTokPtr = ptr + MINBPC;
+    *nextTokPtr = ptr + MINBPC(enc);
     return XML_TOK_DECL_CLOSE;
   case BT_NUM:
-    return PREFIX(scanPoundName)(enc, ptr + MINBPC, end, nextTokPtr);
+    return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
 #define LEAD_CASE(n) \
   case BT_LEAD ## n: \
     if (end - ptr < n) \
@@ -1127,7 +1121,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_NMSTRT:
   case BT_HEX:
     tok = XML_TOK_NAME;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_DIGIT:
   case BT_NAME:
@@ -1136,16 +1130,16 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
   case BT_COLON:
 #endif
     tok = XML_TOK_NMTOKEN;
-    ptr += MINBPC;
+    ptr += MINBPC(enc);
     break;
   case BT_NONASCII:
     if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       tok = XML_TOK_NAME;
       break;
     }
     if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       tok = XML_TOK_NMTOKEN;
       break;
     }
@@ -1164,7 +1158,7 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
       return tok;
 #ifdef XMLNS
     case BT_COLON:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       switch (tok) {
       case XML_TOK_NAME:
        if (ptr == end)
@@ -1188,21 +1182,21 @@ int PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_PLUS;
     case BT_AST:
       if (tok == XML_TOK_NMTOKEN)  {
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_ASTERISK;
     case BT_QUEST:
       if (tok == XML_TOK_NMTOKEN)  {
        *nextTokPtr = ptr;
        return XML_TOK_INVALID;
       }
-      *nextTokPtr = ptr + MINBPC;
+      *nextTokPtr = ptr + MINBPC(enc);
       return XML_TOK_NAME_QUESTION;
     default:
       *nextTokPtr = ptr;
@@ -1228,7 +1222,7 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-       return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+       return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LT:
@@ -1237,18 +1231,18 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_INVALID;
     case BT_LF:
       if (ptr == start) {
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_TRAILING_CR;
        if (BYTE_TYPE(enc, ptr) == BT_LF)
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
        *nextTokPtr = ptr;
        return XML_TOK_DATA_NEWLINE;
       }
@@ -1256,13 +1250,13 @@ int PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *
       return XML_TOK_DATA_CHARS;
     case BT_S:
       if (ptr == start) {
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_ATTRIBUTE_VALUE_S;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1286,35 +1280,35 @@ int PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end
 #undef LEAD_CASE
     case BT_AMP:
       if (ptr == start)
-       return PREFIX(scanRef)(enc, ptr + MINBPC, end, nextTokPtr);
+       return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_PERCNT:
       if (ptr == start)
-       return PREFIX(scanPercent)(enc, ptr + MINBPC, end, nextTokPtr);
+       return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_LF:
       if (ptr == start) {
-       *nextTokPtr = ptr + MINBPC;
+       *nextTokPtr = ptr + MINBPC(enc);
        return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     case BT_CR:
       if (ptr == start) {
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (ptr == end)
          return XML_TOK_TRAILING_CR;
        if (BYTE_TYPE(enc, ptr) == BT_LF)
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
        *nextTokPtr = ptr;
        return XML_TOK_DATA_NEWLINE;
       }
       *nextTokPtr = ptr;
       return XML_TOK_DATA_CHARS;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
   }
@@ -1326,9 +1320,9 @@ static
 int PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
                       const char **badPtr)
 {
-  ptr += MINBPC;
-  end -= MINBPC;
-  for (; ptr != end; ptr += MINBPC) {
+  ptr += MINBPC(enc);
+  end -= MINBPC(enc);
+  for (; ptr != end; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
     case BT_DIGIT:
     case BT_HEX:
@@ -1389,7 +1383,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
   int nAtts = 0;
   int open;
 
-  for (ptr += MINBPC;; ptr += MINBPC) {
+  for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
     switch (BYTE_TYPE(enc, ptr)) {
 #define START_NAME \
       if (state == other) { \
@@ -1400,7 +1394,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
        state = inName; \
       }
 #define LEAD_CASE(n) \
-    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC); break;
+    case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
     LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
 #undef LEAD_CASE
     case BT_NONASCII:
@@ -1411,7 +1405,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
 #undef START_NAME
     case BT_QUOT:
       if (state != inValue) {
-       atts[nAtts].valuePtr = ptr + MINBPC;
+       atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_QUOT;
       }
@@ -1422,7 +1416,7 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
       break;
     case BT_APOS:
       if (state != inValue) {
-       atts[nAtts].valuePtr = ptr + MINBPC;
+       atts[nAtts].valuePtr = ptr + MINBPC(enc);
         state = inValue;
         open = BT_APOS;
       }
@@ -1441,8 +1435,8 @@ int PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
               && atts[nAtts].normalized
               && (ptr == atts[nAtts].valuePtr
                   || BYTE_TO_ASCII(enc, ptr) != ' '
-                  || BYTE_TO_ASCII(enc, ptr + MINBPC) == ' '
-                  || BYTE_TYPE(enc, ptr + MINBPC) == open))
+                  || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ' '
+                  || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
        atts[nAtts].normalized = 0;
       break;
     case BT_CR: case BT_LF:
@@ -1470,9 +1464,9 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
 {
   int result = 0;
   /* skip &# */
-  ptr += 2*MINBPC;
+  ptr += 2*MINBPC(enc);
   if (CHAR_MATCHES(enc, ptr, 'x')) {
-    for (ptr += MINBPC; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (ptr += MINBPC(enc); !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       switch (c) {
       case '0': case '1': case '2': case '3': case '4':
@@ -1494,7 +1488,7 @@ int PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
     }
   }
   else {
-    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC) {
+    for (; !CHAR_MATCHES(enc, ptr, ';'); ptr += MINBPC(enc)) {
       int c = BYTE_TO_ASCII(enc, ptr);
       result *= 10;
       result += (c - '0');
@@ -1509,8 +1503,8 @@ static
 int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const char *end)
 {
   switch (end - ptr) {
-  case 2 * MINBPC:
-    if (CHAR_MATCHES(enc, ptr + MINBPC, 't')) {
+  case 2 * MINBPC(enc):
+    if (CHAR_MATCHES(enc, ptr + MINBPC(enc), 't')) {
       switch (BYTE_TO_ASCII(enc, ptr)) {
       case 'l':
        return '<';
@@ -1519,35 +1513,35 @@ int PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr, const cha
       }
     }
     break;
-  case 3 * MINBPC:
+  case 3 * MINBPC(enc):
     if (CHAR_MATCHES(enc, ptr, 'a')) {
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'm')) {
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, 'p'))
          return '&';
       }
     }
     break;
-  case 4 * MINBPC:
+  case 4 * MINBPC(enc):
     switch (BYTE_TO_ASCII(enc, ptr)) {
     case 'q':
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'u')) {
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, 'o')) {
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, 't'))
            return '"';
        }
       }
       break;
     case 'a':
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (CHAR_MATCHES(enc, ptr, 'p')) {
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
        if (CHAR_MATCHES(enc, ptr, 'o')) {
-         ptr += MINBPC;
+         ptr += MINBPC(enc);
          if (CHAR_MATCHES(enc, ptr, 's'))
            return '\'';
        }
@@ -1584,24 +1578,22 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
     case BT_MINUS:
       if (*ptr2++ != *ptr1++)
        return 0;
-#if MINBPC > 1
-      if (*ptr2++ != *ptr1++)
-       return 0;
-#if MINBPC > 2
-      if (*ptr2++ != *ptr1++)
-       return 0;
-#if MINBPC > 3
-      if (*ptr2++ != *ptr1++)
-       return 0;
-#endif
-#endif
-#endif
+      if (MINBPC(enc) > 1) {
+       if (*ptr2++ != *ptr1++)
+         return 0;
+       if (MINBPC(enc) > 2) {
+         if (*ptr2++ != *ptr1++)
+           return 0;
+          if (MINBPC(enc) > 3) {
+           if (*ptr2++ != *ptr1++)
+             return 0;
+         }
+       }
+      }
       break;
     default:
-#if MINBPC == 1
-      if (*ptr1 == *ptr2)
+      if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
        return 1;
-#endif
       switch (BYTE_TYPE(enc, ptr2)) {
       case BT_LEAD2:
       case BT_LEAD3:
@@ -1627,7 +1619,7 @@ int PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 static
 int PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1, const char *ptr2)
 {
-  for (; *ptr2; ptr1 += MINBPC, ptr2++) {
+  for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
     if (!CHAR_MATCHES(end, ptr1, *ptr2))
       return 0;
   }
@@ -1669,7 +1661,7 @@ int PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
     case BT_DIGIT:
     case BT_NAME:
     case BT_MINUS:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr - start;
@@ -1685,7 +1677,7 @@ const char *PREFIX(skipS)(const ENCODING *enc, const char *ptr)
     case BT_LF:
     case BT_CR:
     case BT_S:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     default:
       return ptr;
@@ -1710,17 +1702,17 @@ void PREFIX(updatePosition)(const ENCODING *enc,
     case BT_LF:
       pos->columnNumber = (unsigned)-1;
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     case BT_CR:
       pos->lineNumber++;
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
-       ptr += MINBPC;
+       ptr += MINBPC(enc);
       pos->columnNumber = (unsigned)-1;
       break;
     default:
-      ptr += MINBPC;
+      ptr += MINBPC(enc);
       break;
     }
     pos->columnNumber++;