Some further minor fixes

Author: NWilson

.github/workflows/dev.yml

@@ -68,7 +68,7 @@ jobs:
 
       - name: Test (main test script)
         run: |
-          ulimit -S -s 32768 # Raise stack limit; ASAN with -O0 is very stack-hungry
+          ulimit -S -s 49152 # Raise stack limit; ASAN with -O0 is very stack-hungry
           ./RunTest
 
       - name: Test (JIT test program)

src/pcre2_compile.c

@@ -6224,39 +6224,29 @@ for (;; pptr++)
         too, we use a special-cased encoding of OP_ALLANY. */
 
         if (op_info.op_single_type == ECL_ANY && allbitsone)
-          {
-          if (lengthptr == NULL) *code++ = OP_ALLANY;
-          }
+          *code++ = OP_ALLANY;
 
         /* If the high bits are all matched / all not-matched, then we emit an
         OP_NCLASS/OP_CLASS respectively. */
 
         else if (op_info.op_single_type == ECL_ANY ||
                  op_info.op_single_type == ECL_NONE)
           {
-          PCRE2_SIZE required_len = 1 + (32 / sizeof(PCRE2_UCHAR));
-
-          if (lengthptr != NULL)
-            {
-            /* Don't unconditionally request 32 more bytes - we probably already
-            reserved that much space inside compile_class_nested(). */
-            if (required_len > (*lengthptr - previous_length))
-              {
-              *lengthptr = previous_length + required_len;
-              }
-            }
-          else
-            {
-            *code++ = (op_info.op_single_type == ECL_ANY)? OP_NCLASS : OP_CLASS;
-            memcpy(code, op_info.bits.classbits, 32);
-            code += 32 / sizeof(PCRE2_UCHAR);
-            }
+          *code++ = (op_info.op_single_type == ECL_ANY)? OP_NCLASS : OP_CLASS;
+          memcpy(code, op_info.bits.classbits, 32);
+          code += 32 / sizeof(PCRE2_UCHAR);
           }
 
         /* Otherwise, we have an ECL_XCLASS, so we have the OP_XCLASS data
         there, but, we pulled out its bitmap into op_info, so now we have to
         put that back into the OP_XCLASS. */
 
+#ifndef SUPPORT_WIDE_CHARS
+        else
+          {
+          PCRE2_DEBUG_UNREACHABLE();
+          }
+#else
         else
           {
           BOOL need_map;
@@ -6269,10 +6259,22 @@ for (;; pptr++)
 
           if (lengthptr != NULL)
             {
+            /* Don't unconditionally request all the space we need - we may
+            already have asked for more during processing of the ECLASS. */
             if (required_len > (*lengthptr - previous_length))
               {
               *lengthptr = previous_length + required_len;
               }
+
+            /* The code we write out here won't be ignored, even during the
+            (lengthptr != NULL) phase, because if there's a following quantifier
+            it will peek backwards. So we do have to write out a (truncated)
+            OP_XCLASS, even on this branch. */
+            *lengthptr -= 1 + LINK_SIZE + 1;
+            *code++ = OP_XCLASS;
+            PUT(code, 0, 1 + LINK_SIZE + 1);
+            code += LINK_SIZE;
+            *code++ = 0;
             }
           else
             {
@@ -6307,6 +6309,7 @@ for (;; pptr++)
             code += rest_len;
             }
           }
+#endif /* SUPPORT_WIDE_CHARS */
         }
 
       /* Otherwise, we're going to keep the OP_ECLASS. However, again we need

src/pcre2_compile_class.c

@@ -2161,7 +2161,7 @@ switch (meta)
       data_start = map_start + 32 / sizeof(PCRE2_UCHAR);
       memcpy(pop_info->bits.classbits, map_start, 32);
       memmove(map_start, data_start, CU2BYTES(code - data_start));
-      
+
       /* Rewind the code pointer, but make sure we adjust *lengthptr, because we
       do need to reserve that space (even though we only use it temporarily). */
       if (lengthptr != NULL)
@@ -2229,7 +2229,7 @@ while (*ptr != META_CLASS_END &&
   uint32_t op;
   BOOL rhs_negated;
   eclass_op_info rhs_op_info;
-  
+
   if (negated)
     {
     /* !(A juxtapose B)  ->  !A && !B */
@@ -2322,7 +2322,7 @@ while (*ptr == META_ECLASS_AND)
   uint32_t op;
   BOOL rhs_negated;
   eclass_op_info rhs_op_info;
-  
+
   if (negated)
     {
     /* !(A && B)  ->  !A || !B */
@@ -2399,7 +2399,7 @@ while (*ptr >= META_ECLASS_OR && *ptr <= META_ECLASS_XOR)
   BOOL op_neg;
   BOOL rhs_negated;
   eclass_op_info rhs_op_info;
-  
+
   if (negated)
     {
     /* The whole expression is being negated; we respond by unconditionally