regcomp.c: Use macro accessor uniformly
authorKarl Williamson <public@khwilliamson.com>
Tue, 10 Sep 2013 02:33:48 +0000 (20:33 -0600)
committerKarl Williamson <public@khwilliamson.com>
Tue, 24 Sep 2013 17:36:18 +0000 (11:36 -0600)
These instances were using the structure field directly; everywhere else
uses a macro that hides the field's location in the structure.  This
converts to use the macro everywhere.

regcomp.c

index c6de479..cade962 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -821,7 +821,7 @@ S_ssc_anything(const RExC_state_t *pRExC_state, regnode_ssc *ssc)
     PERL_ARGS_ASSERT_SSC_ANYTHING;
 
     ANYOF_BITMAP_SETALL(ssc);
-    ssc->flags = ANYOF_ABOVE_LATIN1_ALL;
+    ANYOF_FLAGS(ssc) = ANYOF_ABOVE_LATIN1_ALL;
     SET_SSC_EOS(ssc);
 
     /* If any portion of the regex is to operate under locale rules,
@@ -833,7 +833,7 @@ S_ssc_anything(const RExC_state_t *pRExC_state, regnode_ssc *ssc)
      * necessary. */
     if (RExC_contains_locale) {
        ANYOF_POSIXL_SETALL(ssc);
-       ssc->flags |= ANYOF_LOCALE|ANYOF_POSIXL|ANYOF_LOC_FOLD;
+       ANYOF_FLAGS(ssc) |= ANYOF_LOCALE|ANYOF_POSIXL|ANYOF_LOC_FOLD;
     }
     else {
        ANYOF_POSIXL_ZERO(ssc);
@@ -851,7 +851,7 @@ S_ssc_is_anything(const regnode_ssc *ssc)
     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_ABOVE_LATIN1_ALL))
+    if (!(ANYOF_FLAGS(ssc) & ANYOF_ABOVE_LATIN1_ALL))
        return 0;
     if (!ANYOF_BITMAP_TESTALLSET((const void*)ssc))
        return 0;
@@ -887,12 +887,12 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode
     /* I (khw) am not sure all these restrictions are necessary XXX */
     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)) {
+       && (ANYOF_FLAGS(and_with) & ANYOF_LOCALE) == (ANYOF_FLAGS(ssc) & ANYOF_LOCALE)
+       && !(ANYOF_FLAGS(and_with) & ANYOF_LOC_FOLD)
+       && !(ANYOF_FLAGS(ssc) & ANYOF_LOC_FOLD)) {
        int i;
 
-       if (and_with->flags & ANYOF_INVERT)
+       if (ANYOF_FLAGS(and_with) & ANYOF_INVERT)
            for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
                ssc->bitmap[i] &= ~and_with->bitmap[i];
        else
@@ -900,7 +900,7 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode
                ssc->bitmap[i] &= and_with->bitmap[i];
     } /* XXXX: logic is complicated otherwise, leave it along for a moment. */
 
-    if (and_with->flags & ANYOF_INVERT) {
+    if (ANYOF_FLAGS(and_with) & ANYOF_INVERT) {
 
         /* Here, the and'ed node is inverted.  Get the AND of the flags that
          * aren't affected by the inversion.  Those that are affected are
@@ -917,11 +917,11 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode
 
         /* The inversion of these two flags indicate that the resulting
          * intersection doesn't have them */
-       if (and_with->flags & ANYOF_ABOVE_LATIN1_ALL) {
-           ssc->flags &= ~ANYOF_ABOVE_LATIN1_ALL;
+       if (ANYOF_FLAGS(and_with) & ANYOF_ABOVE_LATIN1_ALL) {
+           ANYOF_FLAGS(ssc) &= ~ANYOF_ABOVE_LATIN1_ALL;
        }
-       if (and_with->flags & ANYOF_NON_UTF8_LATIN1_ALL) {
-           ssc->flags &= ~ANYOF_NON_UTF8_LATIN1_ALL;
+       if (ANYOF_FLAGS(and_with) & ANYOF_NON_UTF8_LATIN1_ALL) {
+           ANYOF_FLAGS(ssc) &= ~ANYOF_NON_UTF8_LATIN1_ALL;
        }
     }
     else {   /* and'd node is not inverted */
@@ -935,9 +935,9 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode
              * which case we don't know what the intersection is, but it's no
              * greater than what ssc already has, so can just leave it alone,
              * with possible false positives */
-            if (! (and_with->flags & ANYOF_ABOVE_LATIN1_ALL)) {
+            if (! (ANYOF_FLAGS(and_with) & ANYOF_ABOVE_LATIN1_ALL)) {
                 ARG_SET(ssc, ANYOF_NONBITMAP_EMPTY);
-               ssc->flags &= ~ANYOF_NONBITMAP_NON_UTF8;
+               ANYOF_FLAGS(ssc) &= ~ANYOF_NONBITMAP_NON_UTF8;
             }
        }
        else if (! ANYOF_NONBITMAP(ssc)) {
@@ -950,13 +950,13 @@ S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode
              * match anything outside the bitmap (since the 'if' that got us
              * into this block tested for that), so we leave the bitmap empty.
              */
-           if (ssc->flags & ANYOF_ABOVE_LATIN1_ALL) {
+           if (ANYOF_FLAGS(ssc) & ANYOF_ABOVE_LATIN1_ALL) {
                ARG_SET(ssc, ARG(and_with));
 
                 /* and_with's ARG may match things that don't require UTF8.
                  * And now ssc's will too, in spite of this being an 'and'.  See
                  * the comments below about the kludge */
-               ssc->flags |= and_with->flags & ANYOF_NONBITMAP_NON_UTF8;
+               ANYOF_FLAGS(ssc) |= ANYOF_FLAGS(and_with) & ANYOF_NONBITMAP_NON_UTF8;
            }
        }
        else {
@@ -1004,7 +1004,7 @@ S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *o
 {
     PERL_ARGS_ASSERT_SSC_OR;
 
-    if (or_with->flags & ANYOF_INVERT) {
+    if (ANYOF_FLAGS(or_with) & ANYOF_INVERT) {
 
         /* Here, the or'd node is to be inverted.  This means we take the
          * complement of everything not in the bitmap, but currently we don't
@@ -1021,9 +1021,9 @@ S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *o
         *   (OK1(i) | OK1(i')) | !(OK1(i) | OK1(i')) =
         *   (OK1(i) | OK1(i')) | (!OK1(i) & !OK1(i'))
         */
-       else if ( (or_with->flags & ANYOF_LOCALE) == (ssc->flags & ANYOF_LOCALE)
-            && !(or_with->flags & ANYOF_LOC_FOLD)
-            && !(ssc->flags & ANYOF_LOC_FOLD) ) {
+       else if ( (ANYOF_FLAGS(or_with) & ANYOF_LOCALE) == (ANYOF_FLAGS(ssc) & ANYOF_LOCALE)
+            && !(ANYOF_FLAGS(or_with) & ANYOF_LOC_FOLD)
+            && !(ANYOF_FLAGS(ssc) & ANYOF_LOC_FOLD) ) {
            int i;
 
            for (i = 0; i < ANYOF_BITMAP_SIZE; i++)
@@ -1048,15 +1048,15 @@ S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *o
          */
     } else {    /* 'or_with' is not inverted */
        /* (B1 | CL1) | (B2 | CL2) = (B1 | B2) | (CL1 | CL2)) */
-       if ( (or_with->flags & ANYOF_LOCALE) == (ssc->flags & ANYOF_LOCALE)
-            && (!(or_with->flags & ANYOF_LOC_FOLD)
-                || (ssc->flags & ANYOF_LOC_FOLD)) ) {
+       if ( (ANYOF_FLAGS(or_with) & ANYOF_LOCALE) == (ANYOF_FLAGS(ssc) & ANYOF_LOCALE)
+            && (!(ANYOF_FLAGS(or_with) & ANYOF_LOC_FOLD)
+                || (ANYOF_FLAGS(ssc) & ANYOF_LOC_FOLD)) ) {
            int i;
 
            /* 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_POSIXL) {
+            if (ANYOF_FLAGS(or_with) & ANYOF_POSIXL) {
                 ANYOF_POSIXL_OR(or_with, ssc);
             }
        }
@@ -1078,11 +1078,11 @@ S_ssc_or(const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *o
            }
            else if (ARG(ssc) != ARG(or_with)) {
 
-               if ((or_with->flags & ANYOF_NONBITMAP_NON_UTF8)) {
+               if ((ANYOF_FLAGS(or_with) & ANYOF_NONBITMAP_NON_UTF8)) {
                    ssc_anything(pRExC_state, ssc);
                }
                else {
-                   ssc->flags |= ANYOF_ABOVE_LATIN1_ALL;
+                   ANYOF_FLAGS(ssc) |= ANYOF_ABOVE_LATIN1_ALL;
                }
            }
        }
@@ -3638,9 +3638,9 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                 * utf8 string, so accept a possible false positive for
                 * latin1-range folds */
                if (uc >= 0x100 ||
-                   (!(data->start_class->flags & ANYOF_LOCALE)
+                   (!(ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE)
                    && !ANYOF_BITMAP_TEST(data->start_class, uc)
-                   && (!(data->start_class->flags & ANYOF_LOC_FOLD)
+                   && (!(ANYOF_FLAGS(data->start_class) & ANYOF_LOC_FOLD)
                        || !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
                     )
                {
@@ -3668,14 +3668,14 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                }
                 CLEAR_SSC_EOS(data->start_class);
                if (uc < 0x100)
-                 data->start_class->flags &= ~ANYOF_ABOVE_LATIN1_ALL;
+                 ANYOF_FLAGS(data->start_class) &= ~ANYOF_ABOVE_LATIN1_ALL;
            }
            else if (flags & SCF_DO_STCLASS_OR) {
                /* false positive possible if the class is case-folded */
                if (uc < 0x100)
                    ANYOF_BITMAP_SET(data->start_class, uc);
                else
-                   data->start_class->flags |= ANYOF_ABOVE_LATIN1_ALL;
+                   ANYOF_FLAGS(data->start_class) |= ANYOF_ABOVE_LATIN1_ALL;
                 CLEAR_SSC_EOS(data->start_class);
                ssc_and(pRExC_state, data->start_class, and_withp);
            }
@@ -3715,7 +3715,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                /* Check whether it is compatible with what we know already! */
                int compat = 1;
                if (uc >= 0x100 ||
-                (!(data->start_class->flags & ANYOF_LOCALE)
+                (!(ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE)
                  && !ANYOF_BITMAP_TEST(data->start_class, uc)
                  && !ANYOF_BITMAP_TEST(data->start_class, PL_fold_latin1[uc])))
                {
@@ -3730,7 +3730,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                        /* XXX This set is probably no longer necessary, and
                         * probably wrong as LOCALE now is on in the initial
                         * state */
-                       data->start_class->flags |= ANYOF_LOCALE|ANYOF_LOC_FOLD;
+                       ANYOF_FLAGS(data->start_class) |= ANYOF_LOCALE|ANYOF_LOC_FOLD;
                    }
                    else {
 
@@ -3766,7 +3766,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                }
            }
            else if (flags & SCF_DO_STCLASS_OR) {
-               if (data->start_class->flags & ANYOF_LOC_FOLD) {
+               if (ANYOF_FLAGS(data->start_class) & ANYOF_LOC_FOLD) {
                    /* false positive possible if the class is case-folded.
                       Assume that the locale settings are the same... */
                    if (uc < 0x100) {
@@ -4260,7 +4260,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                case POSIXU:
                     classnum = FLAGS(scan);
                    if (flags & SCF_DO_STCLASS_AND) {
-                       if (!(data->start_class->flags & ANYOF_LOCALE)) {
+                       if (!(ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE)) {
                            ANYOF_POSIXL_CLEAR(data->start_class,
                                          classnum_to_namedclass(classnum) + 1);
                             for (value = 0; value < loop_max; value++) {
@@ -4271,7 +4271,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                        }
                    }
                    else {
-                       if (data->start_class->flags & ANYOF_LOCALE) {
+                       if (ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE) {
                            ANYOF_POSIXL_SET(data->start_class,
                                              classnum_to_namedclass(classnum));
                         }
@@ -4296,7 +4296,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                case NPOSIXD:
                     classnum = FLAGS(scan);
                    if (flags & SCF_DO_STCLASS_AND) {
-                       if (!(data->start_class->flags & ANYOF_LOCALE)) {
+                       if (!(ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE)) {
                            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)) {
@@ -4306,7 +4306,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                        }
                    }
                    else {
-                       if (data->start_class->flags & ANYOF_LOCALE) {
+                       if (ANYOF_FLAGS(data->start_class) & ANYOF_LOCALE) {
                            ANYOF_POSIXL_SET(data->start_class,
                                          classnum_to_namedclass(classnum) + 1);
                         }
@@ -4321,7 +4321,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                             }
                         }
                         if (PL_regkind[OP(scan)] == NPOSIXD) {
-                            data->start_class->flags |= ANYOF_NON_UTF8_LATIN1_ALL;
+                            ANYOF_FLAGS(data->start_class) |= ANYOF_NON_UTF8_LATIN1_ALL;
                         }
                         }
                    }