regcomp.h: Add better named synonyms
authorKarl Williamson <public@khwilliamson.com>
Fri, 9 Aug 2013 17:51:09 +0000 (11:51 -0600)
committerKarl Williamson <public@khwilliamson.com>
Tue, 24 Sep 2013 17:36:14 +0000 (11:36 -0600)
This continues the process started two commits ago of removing some of
the overloading of the term 'class'.

In this case, this commit adds some #defines referring to the portions
of the regnode associated with bracketed character classes, the ANYOF
node.  Specifically those portions that deal with the Posix character
classes, like \w and [:punct:] under /l (locale) matching are renamed
substituting POSIXL for CLASS.  POSIXL is already used for POSIX-related
things under /l.  I remember being terribly confused when I started
reading this code about this.  One had a class within a class.  This
should clarify things somewhat.

The old names are retained in case files outside the core #include and
use it (there are a few such in cpan).

regcomp.c
regcomp.h
regexec.c

index 3838904..8252ba6 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -829,11 +829,11 @@ S_ssc_anything(const RExC_state_t *pRExC_state, regnode_ssc *ssc)
      * parts of it may not work properly, it is safest to avoid locale unless
      * necessary. */
     if (RExC_contains_locale) {
-       ANYOF_CLASS_SETALL(ssc);            /* /l uses class */
-       ssc->flags |= ANYOF_LOCALE|ANYOF_CLASS|ANYOF_LOC_FOLD;
+       ANYOF_POSIXL_SETALL(ssc);
+       ssc->flags |= ANYOF_LOCALE|ANYOF_POSIXL|ANYOF_LOC_FOLD;
     }
     else {
-       ANYOF_CLASS_ZERO(ssc);      /* Only /l uses class now */
+       ANYOF_POSIXL_ZERO(ssc);
     }
 }
 
@@ -845,8 +845,8 @@ S_ssc_is_anything(const regnode_ssc *ssc)
 
     PERL_ARGS_ASSERT_SSC_IS_ANYTHING;
 
-    for (value = 0; value < ANYOF_MAX; value += 2)
-       if (ANYOF_CLASS_TEST(ssc, value) && ANYOF_CLASS_TEST(ssc, value + 1))
+    for (value = 0; value < ANYOF_POSIXL_MAX; value += 2)
+       if (ANYOF_POSIXL_TEST(ssc, value) && ANYOF_POSIXL_TEST(ssc, value + 1))
            return 1;
     if (!(ssc->flags & ANYOF_UNICODE_ALL))
        return 0;
@@ -872,7 +872,7 @@ S_ssc_init(const RExC_state_t *pRExC_state, regnode_ssc *ssc)
 #define ssc_init_zero          ssc_init
 
 /* 'AND' a given class with another one.  Can create false positives.  'ssc'
- * should not be inverted.  'and_with->flags & ANYOF_CLASS' should be 0 if
+ * should not be inverted.  'and_with->flags & ANYOF_POSIXL' should be 0 if
  * 'and_with' is a regnode_charclass instead of a regnode_ssc. */
 STATIC void
 S_ssc_and(regnode_ssc *ssc, const regnode_ssc *and_with)
@@ -882,8 +882,8 @@ S_ssc_and(regnode_ssc *ssc, const regnode_ssc *and_with)
     assert(PL_regkind[and_with->type] == ANYOF);
 
     /* I (khw) am not sure all these restrictions are necessary XXX */
-    if (!(ANYOF_CLASS_TEST_ANY_SET(and_with))
-       && !(ANYOF_CLASS_TEST_ANY_SET(ssc))
+    if (!(ANYOF_POSIXL_TEST_ANY_SET(and_with))
+       && !(ANYOF_POSIXL_TEST_ANY_SET(ssc))
        && (and_with->flags & ANYOF_LOCALE) == (ssc->flags & ANYOF_LOCALE)
        && !(and_with->flags & ANYOF_LOC_FOLD)
        && !(ssc->flags & ANYOF_LOC_FOLD)) {
@@ -994,7 +994,7 @@ S_ssc_and(regnode_ssc *ssc, const regnode_ssc *and_with)
 }
 
 /* 'OR' a given class with another one.  Can create false positives.  'ssc'
- * should not be inverted.  'or_with->flags & ANYOF_CLASS' should be 0 if
+ * should not be inverted.  'or_with->flags & ANYOF_POSIXL' should be 0 if
  * 'or_with' is a regnode_charclass instead of a regnode_ssc. */
 STATIC void
 S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *or_with)
@@ -1053,8 +1053,8 @@ S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *o
            /* OR char bitmap and class bitmap separately */
            for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
                ssc->bitmap[i] |= or_with->bitmap[i];
-            if (or_with->flags & ANYOF_CLASS) {
-                ANYOF_CLASS_OR(or_with, ssc);
+            if (or_with->flags & ANYOF_POSIXL) {
+                ANYOF_POSIXL_OR(or_with, ssc);
             }
        }
        else { /* XXXX: logic is complicated, leave it along for a moment. */
@@ -3643,7 +3643,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                {
                    compat = 0;
                }
-               ANYOF_CLASS_ZERO(data->start_class);
+               ANYOF_POSIXL_ZERO(data->start_class);
                ANYOF_BITMAP_ZERO(data->start_class);
                if (compat)
                    ANYOF_BITMAP_SET(data->start_class, uc);
@@ -3718,7 +3718,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                {
                    compat = 0;
                }
-               ANYOF_CLASS_ZERO(data->start_class);
+               ANYOF_POSIXL_ZERO(data->start_class);
                ANYOF_BITMAP_ZERO(data->start_class);
                if (compat) {
                    ANYOF_BITMAP_SET(data->start_class, uc);
@@ -4229,7 +4229,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                        goto do_default;
                    if (flags & SCF_DO_STCLASS_OR) { /* Everything but \n */
                        value = (ANYOF_BITMAP_TEST(data->start_class,'\n')
-                               || ANYOF_CLASS_TEST_ANY_SET(data->start_class));
+                             || ANYOF_POSIXL_TEST_ANY_SET(data->start_class));
                        ssc_anything(pRExC_state, data->start_class);
                    }
                    if (flags & SCF_DO_STCLASS_AND || !value)
@@ -4251,7 +4251,8 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                     classnum = FLAGS(scan);
                    if (flags & SCF_DO_STCLASS_AND) {
                        if (!(data->start_class->flags & ANYOF_LOCALE)) {
-                           ANYOF_CLASS_CLEAR(data->start_class, classnum_to_namedclass(classnum) + 1);
+                           ANYOF_POSIXL_CLEAR(data->start_class,
+                                         classnum_to_namedclass(classnum) + 1);
                             for (value = 0; value < loop_max; value++) {
                                 if (! _generic_isCC(LATIN1_TO_NATIVE(value), classnum)) {
                                     ANYOF_BITMAP_CLEAR(data->start_class, LATIN1_TO_NATIVE(value));
@@ -4261,7 +4262,8 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                    }
                    else {
                        if (data->start_class->flags & ANYOF_LOCALE) {
-                           ANYOF_CLASS_SET(data->start_class, classnum_to_namedclass(classnum));
+                           ANYOF_POSIXL_SET(data->start_class,
+                                             classnum_to_namedclass(classnum));
                         }
                         else {
 
@@ -4285,7 +4287,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                     classnum = FLAGS(scan);
                    if (flags & SCF_DO_STCLASS_AND) {
                        if (!(data->start_class->flags & ANYOF_LOCALE)) {
-                           ANYOF_CLASS_CLEAR(data->start_class, classnum_to_namedclass(classnum));
+                           ANYOF_POSIXL_CLEAR(data->start_class, classnum_to_namedclass(classnum));
                             for (value = 0; value < loop_max; value++) {
                                 if (_generic_isCC(LATIN1_TO_NATIVE(value), classnum)) {
                                     ANYOF_BITMAP_CLEAR(data->start_class, LATIN1_TO_NATIVE(value));
@@ -4295,7 +4297,8 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                    }
                    else {
                        if (data->start_class->flags & ANYOF_LOCALE) {
-                           ANYOF_CLASS_SET(data->start_class, classnum_to_namedclass(classnum) + 1);
+                           ANYOF_POSIXL_SET(data->start_class,
+                                         classnum_to_namedclass(classnum) + 1);
                         }
                         else {
 
@@ -12753,18 +12756,19 @@ parseit:
          * not affected by locale, and hence are dealt with separately */
         if (LOC
             && ! need_class
-            && (ANYOF_LOCALE == ANYOF_CLASS
-                || (namedclass > OOB_NAMEDCLASS && namedclass < ANYOF_MAX)))
+            && (ANYOF_LOCALE == ANYOF_POSIXL
+                || (namedclass > OOB_NAMEDCLASS
+                    && namedclass < ANYOF_POSIXL_MAX)))
         {
             need_class = 1;
             if (SIZE_ONLY) {
-                RExC_size += ANYOF_CLASS_SKIP - ANYOF_SKIP;
+                RExC_size += ANYOF_POSIXL_SKIP - ANYOF_SKIP;
             }
             else {
-                RExC_emit += ANYOF_CLASS_SKIP - ANYOF_SKIP;
-                ANYOF_CLASS_ZERO(ret);
+                RExC_emit += ANYOF_POSIXL_SKIP - ANYOF_SKIP;
+                ANYOF_POSIXL_ZERO(ret);
             }
-            ANYOF_FLAGS(ret) |= ANYOF_CLASS;
+            ANYOF_FLAGS(ret) |= ANYOF_POSIXL;
         }
 
        if (namedclass > OOB_NAMEDCLASS) { /* this is a named class \blah */
@@ -12799,7 +12803,7 @@ parseit:
 
            if (! SIZE_ONLY) {
                 U8 classnum = namedclass_to_classnum(namedclass);
-                if (namedclass >= ANYOF_MAX) {  /* If a special class */
+                if (namedclass >= ANYOF_POSIXL_MAX) {  /* If a special class */
                     if (namedclass != ANYOF_UNIPROP) { /* UNIPROP = \p and \P */
 
                         /* Here, should be \h, \H, \v, or \V.  Neither /d nor
@@ -12828,7 +12832,7 @@ parseit:
                 else if (classnum == _CC_ASCII) {
 #ifdef HAS_ISASCII
                     if (LOC) {
-                        ANYOF_CLASS_SET(ret, namedclass);
+                        ANYOF_POSIXL_SET(ret, namedclass);
                     }
                     else
 #endif  /* Not isascii(); just use the hard-coded definition for it */
@@ -12891,7 +12895,7 @@ parseit:
                                 }
                                 if (LOC) {  /* Under locale, set run-time
                                                lookup */
-                                    ANYOF_CLASS_SET(ret, namedclass);
+                                    ANYOF_POSIXL_SET(ret, namedclass);
                                 }
                                 else {
                                     /* Add the current class's code points to
@@ -12919,7 +12923,7 @@ parseit:
                                                                  Xname);
                                     runtime_posix_matches_above_Unicode = TRUE;
                                     if (LOC) {
-                                        ANYOF_CLASS_SET(ret, namedclass);
+                                        ANYOF_POSIXL_SET(ret, namedclass);
                                     }
                                     else {
 
@@ -13000,7 +13004,7 @@ parseit:
 #endif
                                 /* Set this class in the node for runtime
                                  * matching */
-                                ANYOF_CLASS_SET(ret, namedclass);
+                                ANYOF_POSIXL_SET(ret, namedclass);
 #ifndef HAS_ISBLANK
                             }
                             else {
@@ -13041,7 +13045,7 @@ parseit:
 #ifndef HAS_ISBLANK
                             if (namedclass != ANYOF_NBLANK) {
 #endif
-                                ANYOF_CLASS_SET(ret, namedclass);
+                                ANYOF_POSIXL_SET(ret, namedclass);
 #ifndef HAS_ISBLANK
                             }
                             else {
@@ -13465,7 +13469,7 @@ parseit:
                     /* To get locale nodes to not use the full ANYOF size would
                      * require moving the code above that writes the portions
                      * of it that aren't in other nodes to after this point.
-                     * e.g.  ANYOF_CLASS_SET */
+                     * e.g.  ANYOF_POSIXL_SET */
                     RExC_size = orig_size;
                 }
             }
@@ -13831,7 +13835,7 @@ parseit:
      * invert if there are things such as \w, which aren't known until runtime
      * */
     if (invert
-        && ! (LOC && (FOLD || (ANYOF_FLAGS(ret) & ANYOF_CLASS)))
+        && ! (LOC && (FOLD || (ANYOF_FLAGS(ret) & ANYOF_POSIXL)))
        && ! depends_list
        && ! HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)
     {
@@ -13888,7 +13892,7 @@ parseit:
     if (cp_list
         && ! invert
         && ! depends_list
-        && ! (ANYOF_FLAGS(ret) & ANYOF_CLASS)
+        && ! (ANYOF_FLAGS(ret) & ANYOF_POSIXL)
         && ! HAS_NONLOCALE_RUNTIME_PROPERTY_DEFINITION)
     {
         UV start, end;
@@ -14879,10 +14883,10 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o)
         
         EMIT_ANYOF_TEST_SEPARATOR(do_sep,sv,flags);
         /* output any special charclass tests (used entirely under use locale) */
-       if (ANYOF_CLASS_TEST_ANY_SET(o)) {
+       if (ANYOF_POSIXL_TEST_ANY_SET(o)) {
             int i;
            for (i = 0; i < (int)(sizeof(anyofs)/sizeof(char*)); i++) {
-               if (ANYOF_CLASS_TEST(o,i)) {
+               if (ANYOF_POSIXL_TEST(o,i)) {
                    sv_catpv(sv, anyofs[i]);
                    do_sep = 1;
                }
@@ -15792,8 +15796,8 @@ S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node,
        }
        else if (PL_regkind[(U8)op] == ANYOF) {
            /* arglen 1 + class block */
-           node += 1 + ((ANYOF_FLAGS(node) & ANYOF_CLASS)
-                   ? ANYOF_CLASS_SKIP : ANYOF_SKIP);
+           node += 1 + ((ANYOF_FLAGS(node) & ANYOF_POSIXL)
+                   ? ANYOF_POSIXL_SKIP : ANYOF_SKIP);
            node = NEXTOPER(node);
        }
        else if (PL_regkind[(U8)op] == EXACT) {
index 6b3f52d..92c2f3f 100644 (file)
--- a/regcomp.h
+++ b/regcomp.h
@@ -183,7 +183,7 @@ struct regnode_charclass {
 
 /* has runtime (locale) \d, \w, ..., [:posix:] classes */
 struct regnode_charclass_class {
-    U8 flags;                          /* ANYOF_CLASS bit must go here */
+    U8 flags;                          /* ANYOF_POSIXL bit must go here */
     U8  type;
     U16 next_off;
     U32 arg1;                                  /* used as ptr in S_regclass */
@@ -193,7 +193,7 @@ struct regnode_charclass_class {
 
 /* Synthetic start class, is a regnode_charclass_class plus an SV* */
 struct regnode_ssc {
-    U8 flags;                          /* ANYOF_CLASS bit must go here */
+    U8 flags;                          /* ANYOF_POSIXL bit must go here */
     U8  type;
     U16 next_off;
     U32 arg1;                          /* used as ptr in S_regclass */
@@ -314,7 +314,7 @@ struct regnode_ssc {
 
 /* Flags for node->flags of ANYOF.  These are in short supply, but there is one
  * currently available.  If more than this are needed, the ANYOF_LOCALE and
- * ANYOF_CLASS bits could be shared, making a space penalty for all locale nodes.
+ * ANYOF_POSIXL bits could be shared, making a space penalty for all locale nodes.
  * Also, the UNICODE_ALL bit could be freed up by resorting to creating a swash
  * containing everything above 255.  This introduces a performance penalty.
  * Better would be to split it off into a separate node, which actually would
@@ -338,8 +338,9 @@ struct regnode_ssc {
  * and the optimizer's synthetic start class.  Non-locale \d, etc are resolved
  * at compile-time.  Could be shared with ANYOF_LOCALE, forcing all locale
  * nodes to be large */
-#define ANYOF_CLASS             0x08
-#define ANYOF_LARGE       ANYOF_CLASS   /* Same; name retained for back compat */
+#define ANYOF_POSIXL            0x08
+#define ANYOF_CLASS             ANYOF_POSIXL
+#define ANYOF_LARGE              ANYOF_POSIXL
 
 /* Unused: 0x10.  When using, be sure to change ANYOF_FLAGS_ALL below */
 
@@ -361,7 +362,7 @@ struct regnode_ssc {
  * different if inverted */
 #define INVERSION_UNAFFECTED_FLAGS (ANYOF_LOCALE                        \
                                   |ANYOF_LOC_FOLD                      \
-                                  |ANYOF_CLASS                         \
+                                  |ANYOF_POSIXL                         \
                                   |ANYOF_NONBITMAP_NON_UTF8)
 
 /* Character classes for node->classflags of ANYOF */
@@ -414,19 +415,21 @@ struct regnode_ssc {
 #   error Problem with handy.h _HIGHEST_REGCOMP_DOT_H_SYNC #define
 #endif
 
-#define ANYOF_MAX      (ANYOF_VERTWS) /* So upper loop limit is written:
-                                       *       '< ANYOF_MAX'
-                                       * Hence doesn't include VERTWS, as that
-                                       * is a pseudo class */
-#if (ANYOF_MAX > 32)   /* Must fit in 32-bit word */
+#define ANYOF_POSIXL_MAX (ANYOF_VERTWS) /* So upper loop limit is written:
+                                         *       '< ANYOF_MAX'
+                                         * Hence doesn't include VERTWS, as that
+                                         * is a pseudo class */
+#define ANYOF_MAX      ANYOF_POSIXL_MAX
+
+#if (ANYOF_POSIXL_MAX > 32)   /* Must fit in 32-bit word */
 #   error Problem with handy.h _CC_foo #defines
 #endif
 
-#define ANYOF_HORIZWS  ((ANYOF_MAX)+2) /* = (ANYOF_NVERTWS + 1) */
-#define ANYOF_NHORIZWS ((ANYOF_MAX)+3)
+#define ANYOF_HORIZWS  ((ANYOF_POSIXL_MAX)+2) /* = (ANYOF_NVERTWS + 1) */
+#define ANYOF_NHORIZWS ((ANYOF_POSIXL_MAX)+3)
 
-#define ANYOF_UNIPROP   ((ANYOF_MAX)+4)  /* Used to indicate a Unicode
-                                            property: \p{} or \P{} */
+#define ANYOF_UNIPROP   ((ANYOF_POSIXL_MAX)+4)  /* Used to indicate a Unicode
+                                                   property: \p{} or \P{} */
 
 /* Backward source code compatibility. */
 
@@ -440,26 +443,36 @@ struct regnode_ssc {
 /* Utility macros for the bitmap and classes of ANYOF */
 
 #define ANYOF_SIZE             (sizeof(struct regnode_charclass))
-#define ANYOF_CLASS_SIZE       (sizeof(struct regnode_charclass_class))
+#define ANYOF_POSIXL_SIZE      (sizeof(struct regnode_charclass_class))
+#define ANYOF_CLASS_SIZE       ANYOF_POSIXL_SIZE
 
 #define ANYOF_FLAGS(p)         ((p)->flags)
 
 #define ANYOF_BIT(c)           (1 << ((c) & 7))
 
-#define ANYOF_CLASS_SET(p, c)  (((struct regnode_charclass_class*) (p))->classflags |= (1U << (c)))
-#define ANYOF_CLASS_CLEAR(p, c)        (((struct regnode_charclass_class*) (p))->classflags &= ~ (1U <<(c)))
-#define ANYOF_CLASS_TEST(p, c) (((struct regnode_charclass_class*) (p))->classflags & (1U << (c)))
+#define ANYOF_POSIXL_SET(p, c) (((struct regnode_charclass_class*) (p))->classflags |= (1U << (c)))
+#define ANYOF_CLASS_SET(p, c)  ANYOF_POSIXL_SET((p), (c))
+
+#define ANYOF_POSIXL_CLEAR(p, c) (((struct regnode_charclass_class*) (p))->classflags &= ~ (1U <<(c)))
+#define ANYOF_CLASS_CLEAR(p, c)        ANYOF_POSIXL_CLEAR((p), (c))
+
+#define ANYOF_POSIXL_TEST(p, c)        (((struct regnode_charclass_class*) (p))->classflags & (1U << (c)))
+#define ANYOF_CLASS_TEST(p, c) ANYOF_POSIXL_TEST((p), (c))
 
-#define ANYOF_CLASS_ZERO(ret)  STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = 0; } STMT_END
+#define ANYOF_POSIXL_ZERO(ret) STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = 0; } STMT_END
+#define ANYOF_CLASS_ZERO(ret)  ANYOF_POSIXL_ZERO(ret)
 
 /* Shifts a bit to get, eg. 0x4000_0000, then subtracts 1 to get 0x3FFF_FFFF */
-#define ANYOF_CLASS_SETALL(ret) STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = ((1U << ((ANYOF_MAX) - 1))) - 1; } STMT_END
+#define ANYOF_POSIXL_SETALL(ret) STMT_START { ((struct regnode_charclass_class*) (ret))->classflags = ((1U << ((ANYOF_POSIXL_MAX) - 1))) - 1; } STMT_END
+#define ANYOF_CLASS_SETALL(ret) ANYOF_POSIXL_SETALL(ret)
 
-#define ANYOF_CLASS_TEST_ANY_SET(p)                               \
-        ((ANYOF_FLAGS(p) & ANYOF_CLASS)                           \
+#define ANYOF_POSIXL_TEST_ANY_SET(p)                               \
+        ((ANYOF_FLAGS(p) & ANYOF_POSIXL)                           \
         && (((struct regnode_charclass_class*)(p))->classflags))
+#define ANYOF_CLASS_TEST_ANY_SET(p) ANYOF_POSIXL_TEST_ANY_SET(p)
 
-#define ANYOF_CLASS_OR(source, dest) STMT_START { (dest)->classflags |= source->classflags ; } STMT_END
+#define ANYOF_POSIXL_OR(source, dest) STMT_START { (dest)->classflags |= source->classflags ; } STMT_END
+#define ANYOF_CLASS_OR(source, dest) ANYOF_POSIXL_OR((source), (dest))
 
 #define ANYOF_BITMAP_ZERO(ret) Zero(((struct regnode_charclass*)(ret))->bitmap, ANYOF_BITMAP_SIZE, char)
 #define ANYOF_BITMAP(p)                (((struct regnode_charclass*)(p))->bitmap)
@@ -477,7 +490,8 @@ struct regnode_ssc {
        memEQ (ANYOF_BITMAP(p), "\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377", ANYOF_BITMAP_SIZE)
 
 #define ANYOF_SKIP             ((ANYOF_SIZE - 1)/sizeof(regnode))
-#define ANYOF_CLASS_SKIP       ((ANYOF_CLASS_SIZE - 1)/sizeof(regnode))
+#define ANYOF_POSIXL_SKIP      ((ANYOF_POSIXL_SIZE - 1)/sizeof(regnode))
+#define ANYOF_CLASS_SKIP       ANYOF_POSIXL_SKIP
 
 /*
  * Utility definitions.
index b68eb97..7b61357 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -7447,7 +7447,7 @@ S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const
            {
                match = TRUE;
            }
-           else if (ANYOF_CLASS_TEST_ANY_SET(n)) {
+           else if (ANYOF_POSIXL_TEST_ANY_SET(n)) {
 
                 /* The data structure is arranged so bits 0, 2, 4, ... are set
                  * if the class includes the Posix character class given by
@@ -7482,7 +7482,7 @@ S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const
                 int count = 0;
                 int to_complement = 0;
                 while (count < ANYOF_MAX) {
-                    if (ANYOF_CLASS_TEST(n, count)
+                    if (ANYOF_POSIXL_TEST(n, count)
                         && to_complement ^ cBOOL(isFOO_lc(count/2, (U8) c)))
                     {
                         match = TRUE;