Personal comments as I read through...

Author: NWilson

src/pcre2_compile.c

@@ -6147,7 +6147,7 @@ for (;; pptr++)
     else
       {
       *code++ = OP_CLASS;
-      memset(code, 0, 32 * sizeof(uint8_t));
+      memset(code, 0, 32);
       code += 32 / sizeof(PCRE2_UCHAR);
       }
 

src/pcre2_compile_class.c

@@ -742,7 +742,7 @@ BOOL set_bit;
 
 if (ptype == PT_ANY)
   {
-  if (!negated) memset(classbits, 0xff, 32 * sizeof(uint8_t));
+  if (!negated) memset(classbits, 0xff, 32);
   return;
   }
 
@@ -1094,14 +1094,14 @@ if (utf)
   }
 
 class_uchardata = code + LINK_SIZE + 2;   /* For XCLASS items */
-#endif
+#endif /* SUPPORT_WIDE_CHARS */
 
 /* Initialize the 256-bit (32-byte) bit map to all zeros. We build the map
 in a temporary bit of memory, in case the class contains fewer than two
 8-bit characters because in that case the compiled code doesn't use the bit
 map. */
 
-memset(classbits, 0, 32 * sizeof(uint8_t));
+memset(classbits, 0, 32);
 
 /* Process items until end_ptr is reached. */
 
@@ -1111,7 +1111,7 @@ while (TRUE)
   BOOL local_negate;
   int posix_class;
   int taboffset, tabopt;
-  uint8_t pbits[32];
+  class_bits_storage pbits;
   uint32_t escape, c;
 
   /* Handle POSIX classes such as [:alpha:] etc. */
@@ -1123,6 +1123,8 @@ while (TRUE)
     local_negate = (meta == META_POSIX_NEG);
     posix_class = *(pptr++);
 
+    /* XXX !?!? why set this back to false, if you have local_negate=FALSE AFTER locale_negate=TRUE?
+    eg. [ [^:digit:] [:alpha:] ] */
     should_flip_negation = local_negate;  /* Note negative special */
 
     /* If matching is caseless, upper and lower are converted to alpha.
@@ -1151,7 +1153,7 @@ while (TRUE)
         ptype = (posix_class == PC_GRAPH)? PT_PXGRAPH :
                 (posix_class == PC_PRINT)? PT_PXPRINT : PT_PXPUNCT;
 
-        PRIV(update_classbits)(ptype, 0, !local_negate, classbits);
+        PRIV(update_classbits)(ptype, 0, !local_negate /* XXX what? why flipped? */, classbits);
 
         if ((xclass_props & XCLASS_HIGH_ANY) == 0)
           {
@@ -1199,8 +1201,7 @@ while (TRUE)
 
     /* Copy in the first table (always present) */
 
-    memcpy(pbits, cbits + PRIV(posix_class_maps)[posix_class],
-      32 * sizeof(uint8_t));
+    memcpy(pbits.classbits, cbits + PRIV(posix_class_maps)[posix_class], 32);
 
     /* If there is a second table, add or remove it as required. */
 
@@ -1210,27 +1211,35 @@ while (TRUE)
     if (taboffset >= 0)
       {
       if (tabopt >= 0)
-        for (int i = 0; i < 32; i++) pbits[i] |= cbits[(int)i + taboffset];
+        for (int i = 0; i < 32; i++)
+          pbits.classbits[i] |= cbits[(int)i + taboffset];
       else
-        for (int i = 0; i < 32; i++) pbits[i] &= ~cbits[(int)i + taboffset];
+        for (int i = 0; i < 32; i++)
+          pbits.classbits[i] &= ~cbits[(int)i + taboffset];
       }
 
     /* Now see if we need to remove any special characters. An option
     value of 1 removes vertical space and 2 removes underscore. */
 
     if (tabopt < 0) tabopt = -tabopt;
-    if (tabopt == 1) pbits[1] &= ~0x3c;
-      else if (tabopt == 2) pbits[11] &= 0x7f;
+    if (tabopt == 1) pbits.classbits[1] &= ~0x3c;
+      else if (tabopt == 2) pbits.classbits[11] &= 0x7f;
 
     /* Add the POSIX table or its complement into the main table that is
     being built and we are done. */
 
-    if (local_negate)
-      for (int i = 0; i < 32; i++) classbits[i] |= (uint8_t)(~pbits[i]);
-    else
-      for (int i = 0; i < 32; i++) classbits[i] |= pbits[i];
+      {
+      uint32_t *classwords = cb->classbits.classwords;
 
-#ifdef SUPPORT_UNICODE
+      if (local_negate)
+        for (int i = 0; i < 8; i++)
+          classwords[i] |= (uint8_t)(~pbits.classwords[i]);
+      else
+        for (int i = 0; i < 8; i++)
+          classwords[i] |= pbits.classwords[i];
+      }
+
+#ifdef SUPPORT_WIDE_CHARS
     /* Every class contains at least one < 256 character. */
     xclass_props |= XCLASS_HAS_8BIT_CHARS;
 #endif
@@ -1239,8 +1248,8 @@ while (TRUE)
     /* Other than POSIX classes, the only items we should encounter are
     \d-type escapes and literal characters (possibly as ranges). */
     case META_BIGVALUE:
-      meta = *(pptr++);
-      break;
+    meta = *(pptr++);
+    break;
 
     case META_ESCAPE:
     escape = META_DATA(meta);
@@ -1293,7 +1302,8 @@ while (TRUE)
       case ESC_h:
 #if PCRE2_CODE_UNIT_WIDTH == 8
 #ifdef SUPPORT_UNICODE
-      if (cranges != NULL) break;
+      if (utf) { PCRE2_ASSERT(cranges != NULL); }
+      else
 #endif
       add_list_to_class(options & ~PCRE2_CASELESS,
         cb, PRIV(hspace_list));
@@ -1303,9 +1313,11 @@ while (TRUE)
       break;
 
       case ESC_H:
+      // XXX WHY NO should_flip_negation HERE?
 #if PCRE2_CODE_UNIT_WIDTH == 8
 #ifdef SUPPORT_UNICODE
-      if (cranges != NULL) break;
+      if (utf) { PCRE2_ASSERT(cranges != NULL); }
+      else
 #endif
       add_not_list_to_class(options & ~PCRE2_CASELESS,
         cb, PRIV(hspace_list));
@@ -1317,7 +1329,8 @@ while (TRUE)
       case ESC_v:
 #if PCRE2_CODE_UNIT_WIDTH == 8
 #ifdef SUPPORT_UNICODE
-      if (cranges != NULL) break;
+      if (utf) { PCRE2_ASSERT(cranges != NULL); }
+      else
 #endif
       add_list_to_class(options & ~PCRE2_CASELESS,
         cb, PRIV(vspace_list));
@@ -1327,9 +1340,11 @@ while (TRUE)
       break;
 
       case ESC_V:
+      // XXX WHY NO should_flip_negation HERE?
 #if PCRE2_CODE_UNIT_WIDTH == 8
 #ifdef SUPPORT_UNICODE
-      if (cranges != NULL) break;
+      if (utf) { PCRE2_ASSERT(cranges != NULL); }
+      else
 #endif
       add_not_list_to_class(options & ~PCRE2_CASELESS,
         cb, PRIV(vspace_list));
@@ -1352,7 +1367,7 @@ while (TRUE)
         if (ptype == PT_ANY)
           {
 #if PCRE2_CODE_UNIT_WIDTH == 8
-          if (!utf && escape == ESC_p) memset(classbits, 0xff, 32 * sizeof(uint8_t));
+          if (!utf && escape == ESC_p) memset(classbits, 0xff, 32);
 #endif
           continue;
           }
@@ -1368,6 +1383,8 @@ while (TRUE)
           pdata = 0;
           }
 
+        // XXX wow! so we update the classbits, but then throw them away!?!? (for compactness...?)
+        // actually... did I change this?
         PRIV(update_classbits)(ptype, pdata,
           (escape == ESC_P), classbits);
 
@@ -1390,14 +1407,17 @@ while (TRUE)
 
 #ifdef SUPPORT_WIDE_CHARS
     /* Every non-property class contains at least one < 256 character. */
-    xclass_props |= XCLASS_HAS_8BIT_CHARS;
+    xclass_props |= XCLASS_HAS_8BIT_CHARS; // XXX << !!!!!!! OK so this really isn't a guarantee, is it...
 #endif
     /* End handling \d-type escapes */
     continue;
 
+    // XXX so, do we guarantee at least that if we *don't* have any 8-bit chars, and we *don't* XCLAS_HAS_PROPS, then it doesn't match any low values?
+
     CLASS_END_CASES(meta)
     /* Literals. */
     if (meta < META_END) break;
+    /* Non-literals: end of class contents. */
     goto END_PROCESSING;
     }
 
@@ -1594,7 +1614,7 @@ if (cranges != NULL)
       cb->cx->memctl.free(cranges, cb->cx->memctl.memory_data);
     }
   }
-#endif
+#endif /* SUPPORT_WIDE_CHARS */
 
 /* If there are characters with values > 255, or Unicode property settings
 (\p or \P), we have to compile an extended class, with its own opcode,