This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Free up regex ANYOF bit.
authorKarl Williamson <public@khwilliamson.com>
Thu, 27 Dec 2012 17:59:13 +0000 (10:59 -0700)
committerKarl Williamson <public@khwilliamson.com>
Fri, 28 Dec 2012 17:38:55 +0000 (10:38 -0700)
This uses a regnode type, of which we have many available, to free up
a bit in the ANYOF regnode flag field, of which we have none, and are
trying to have the same bit do double duty.  This will enable us to
remove some of that double duty in the next commit.

pod/perldebguts.pod
regcomp.c
regcomp.h
regcomp.sym
regexec.c
regnodes.h

index 715ef34..2d413e4 100644 (file)
@@ -580,6 +580,9 @@ will be lost.
  CANY               no         Match any one byte.
  ANYOF              sv         Match character in (or not in) this
                                class, single char match only
+ ANYOF_WARN_SUPER   sv         Match character in (or not in) this
+                               class, warn (if enabled) upon matching a
+                               char above Unicode max;
 
  POSIXD             none       Some [[:class:]] under /d; the FLAGS
                                field gives which one
index c935476..4a7067b 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -816,7 +816,7 @@ S_cl_and(struct regnode_charclass_class *cl,
 {
     PERL_ARGS_ASSERT_CL_AND;
 
-    assert(and_with->type == ANYOF);
+    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))
@@ -12680,7 +12680,7 @@ parseit:
         }
 
         if (warn_super) {
-            ANYOF_FLAGS(ret) |= ANYOF_WARN_SUPER;
+            OP(ret) = ANYOF_WARN_SUPER;
         }
     }
 
index be3970d..7ed2869 100644 (file)
--- a/regcomp.h
+++ b/regcomp.h
@@ -340,10 +340,6 @@ struct regnode_charclass_class {
 #define ANYOF_CLASS     ANYOF_LOCALE
 #define ANYOF_LARGE      ANYOF_CLASS    /* Same; name retained for back compat */
 
-/* Should this character class warn if matched against a character above
- * Unicode */
-#define ANYOF_WARN_SUPER        0x08
-
 /* EOS, meaning that it can match an empty string too, is used for the
  * synthetic start class only. */
 #define ANYOF_EOS              0x10
index e9fc84e..68182c9 100644 (file)
@@ -55,6 +55,7 @@ REG_ANY     REG_ANY,    no 0 S    ; Match any one character (except newline).
 SANY        REG_ANY,    no 0 S    ; Match any one character.
 CANY        REG_ANY,    no 0 S    ; Match any one byte.
 ANYOF       ANYOF,      sv 0 S    ; Match character in (or not in) this class, single char match only
+ANYOF_WARN_SUPER ANYOF, sv 0 S    ; Match character in (or not in) this class, warn (if enabled) upon matching a char above Unicode max;
 
 # Order of the below is important.  See ordering comment above.
 POSIXD      POSIXD,     none 0 S   ; Some [[:class:]] under /d; the FLAGS field gives which one
index 02d2b19..1b37394 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -1457,6 +1457,7 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
     /* We know what class it must start with. */
     switch (OP(c)) {
     case ANYOF:
+    case ANYOF_WARN_SUPER:
         if (utf8_target) {
             REXEC_FBC_UTF8_CLASS_SCAN(
                       reginclass(prog, c, (U8*)s, utf8_target));
@@ -4266,6 +4267,7 @@ S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
            break;
 
        case ANYOF:  /*  /[abc]/       */
+       case ANYOF_WARN_SUPER:
             if (NEXTCHR_IS_EOS)
                 sayNO;
            if (utf8_target) {
@@ -6858,6 +6860,7 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
        break;
     }
     case ANYOF:
+    case ANYOF_WARN_SUPER:
        if (utf8_target) {
            while (hardcount < max
                    && scan < loceol
@@ -7384,7 +7387,7 @@ S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const
        }
 
         if (UNICODE_IS_SUPER(c)
-            && (flags & ANYOF_WARN_SUPER)
+            && OP(n) == ANYOF_WARN_SUPER
             && ckWARN_d(WARN_NON_UNICODE))
         {
             Perl_warner(aTHX_ packWARN(WARN_NON_UNICODE),
index 4754921..d1d3cab 100644 (file)
@@ -6,8 +6,8 @@
 
 /* Regops and State definitions */
 
-#define REGNODE_MAX            93
-#define REGMATCH_STATE_MAX     133
+#define REGNODE_MAX            94
+#define REGMATCH_STATE_MAX     134
 
 #define        END                     0       /* 0000 End of program. */
 #define        SUCCEED                 1       /* 0x01 Return from a subroutine, basically. */
 #define        SANY                    19      /* 0x13 Match any one character. */
 #define        CANY                    20      /* 0x14 Match any one byte. */
 #define        ANYOF                   21      /* 0x15 Match character in (or not in) this class, single char match only */
-#define        POSIXD                  22      /* 0x16 Some [[:class:]] under /d; the FLAGS field gives which one */
-#define        POSIXL                  23      /* 0x17 Some [[:class:]] under /l; the FLAGS field gives which one */
-#define        POSIXU                  24      /* 0x18 Some [[:class:]] under /u; the FLAGS field gives which one */
-#define        POSIXA                  25      /* 0x19 Some [[:class:]] under /a; the FLAGS field gives which one */
-#define        NPOSIXD                 26      /* 0x1a complement of POSIXD, [[:^class:]] */
-#define        NPOSIXL                 27      /* 0x1b complement of POSIXL, [[:^class:]] */
-#define        NPOSIXU                 28      /* 0x1c complement of POSIXU, [[:^class:]] */
-#define        NPOSIXA                 29      /* 0x1d complement of POSIXA, [[:^class:]] */
-#define        CLUMP                   30      /* 0x1e Match any extended grapheme cluster sequence */
-#define        BRANCH                  31      /* 0x1f Match this alternative, or the next... */
-#define        BACK                    32      /* 0x20 Match "", "next" ptr points backward. */
-#define        EXACT                   33      /* 0x21 Match this string (preceded by length). */
-#define        EXACTF                  34      /* 0x22 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
-#define        EXACTFL                 35      /* 0x23 Match this string (not guaranteed to be folded) using /il rules (w/len). */
-#define        EXACTFU                 36      /* 0x24 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */
-#define        EXACTFA                 37      /* 0x25 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
-#define        EXACTFU_SS              38      /* 0x26 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */
-#define        EXACTFU_TRICKYFOLD      39      /* 0x27 Match this folded UTF-8 string using /iu rules */
-#define        NOTHING                 40      /* 0x28 Match empty string. */
-#define        TAIL                    41      /* 0x29 Match empty string. Can jump here from outside. */
-#define        STAR                    42      /* 0x2a Match this (simple) thing 0 or more times. */
-#define        PLUS                    43      /* 0x2b Match this (simple) thing 1 or more times. */
-#define        CURLY                   44      /* 0x2c Match this simple thing {n,m} times. */
-#define        CURLYN                  45      /* 0x2d Capture next-after-this simple thing */
-#define        CURLYM                  46      /* 0x2e Capture this medium-complex thing {n,m} times. */
-#define        CURLYX                  47      /* 0x2f Match this complex thing {n,m} times. */
-#define        WHILEM                  48      /* 0x30 Do curly processing and see if rest matches. */
-#define        OPEN                    49      /* 0x31 Mark this point in input as start of #n. */
-#define        CLOSE                   50      /* 0x32 Analogous to OPEN. */
-#define        REF                     51      /* 0x33 Match some already matched string */
-#define        REFF                    52      /* 0x34 Match already matched string, folded using native charset semantics for non-utf8 */
-#define        REFFL                   53      /* 0x35 Match already matched string, folded in loc. */
-#define        REFFU                   54      /* 0x36 Match already matched string, folded using unicode semantics for non-utf8 */
-#define        REFFA                   55      /* 0x37 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define        NREF                    56      /* 0x38 Match some already matched string */
-#define        NREFF                   57      /* 0x39 Match already matched string, folded using native charset semantics for non-utf8 */
-#define        NREFFL                  58      /* 0x3a Match already matched string, folded in loc. */
-#define        NREFFU                  59      /* 0x3b Match already matched string, folded using unicode semantics for non-utf8 */
-#define        NREFFA                  60      /* 0x3c Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define        IFMATCH                 61      /* 0x3d Succeeds if the following matches. */
-#define        UNLESSM                 62      /* 0x3e Fails if the following matches. */
-#define        SUSPEND                 63      /* 0x3f "Independent" sub-RE. */
-#define        IFTHEN                  64      /* 0x40 Switch, should be preceded by switcher. */
-#define        GROUPP                  65      /* 0x41 Whether the group matched. */
-#define        LONGJMP                 66      /* 0x42 Jump far away. */
-#define        BRANCHJ                 67      /* 0x43 BRANCH with long offset. */
-#define        EVAL                    68      /* 0x44 Execute some Perl code. */
-#define        MINMOD                  69      /* 0x45 Next operator is not greedy. */
-#define        LOGICAL                 70      /* 0x46 Next opcode should set the flag only. */
-#define        RENUM                   71      /* 0x47 Group with independently numbered parens. */
-#define        TRIE                    72      /* 0x48 Match many EXACT(F[ALU]?)? at once. flags==type */
-#define        TRIEC                   73      /* 0x49 Same as TRIE, but with embedded charclass data */
-#define        AHOCORASICK             74      /* 0x4a Aho Corasick stclass. flags==type */
-#define        AHOCORASICKC            75      /* 0x4b Same as AHOCORASICK, but with embedded charclass data */
-#define        GOSUB                   76      /* 0x4c recurse to paren arg1 at (signed) ofs arg2 */
-#define        GOSTART                 77      /* 0x4d recurse to start of pattern */
-#define        NGROUPP                 78      /* 0x4e Whether the group matched. */
-#define        INSUBP                  79      /* 0x4f Whether we are in a specific recurse. */
-#define        DEFINEP                 80      /* 0x50 Never execute directly. */
-#define        ENDLIKE                 81      /* 0x51 Used only for the type field of verbs */
-#define        OPFAIL                  82      /* 0x52 Same as (?!) */
-#define        ACCEPT                  83      /* 0x53 Accepts the current matched string. */
-#define        VERB                    84      /* 0x54 Used only for the type field of verbs */
-#define        PRUNE                   85      /* 0x55 Pattern fails at this startpoint if no-backtracking through this */
-#define        MARKPOINT               86      /* 0x56 Push the current location for rollback by cut. */
-#define        SKIP                    87      /* 0x57 On failure skip forward (to the mark) before retrying */
-#define        COMMIT                  88      /* 0x58 Pattern fails outright if backtracking through this */
-#define        CUTGROUP                89      /* 0x59 On failure go to the next alternation in the group */
-#define        KEEPS                   90      /* 0x5a $& begins here. */
-#define        LNBREAK                 91      /* 0x5b generic newline pattern */
-#define        OPTIMIZED               92      /* 0x5c Placeholder for dump. */
-#define        PSEUDO                  93      /* 0x5d Pseudo opcode for internal use. */
+#define        ANYOF_WARN_SUPER        22      /* 0x16 Match character in (or not in) this class, warn (if enabled) upon matching a char above Unicode max; */
+#define        POSIXD                  23      /* 0x17 Some [[:class:]] under /d; the FLAGS field gives which one */
+#define        POSIXL                  24      /* 0x18 Some [[:class:]] under /l; the FLAGS field gives which one */
+#define        POSIXU                  25      /* 0x19 Some [[:class:]] under /u; the FLAGS field gives which one */
+#define        POSIXA                  26      /* 0x1a Some [[:class:]] under /a; the FLAGS field gives which one */
+#define        NPOSIXD                 27      /* 0x1b complement of POSIXD, [[:^class:]] */
+#define        NPOSIXL                 28      /* 0x1c complement of POSIXL, [[:^class:]] */
+#define        NPOSIXU                 29      /* 0x1d complement of POSIXU, [[:^class:]] */
+#define        NPOSIXA                 30      /* 0x1e complement of POSIXA, [[:^class:]] */
+#define        CLUMP                   31      /* 0x1f Match any extended grapheme cluster sequence */
+#define        BRANCH                  32      /* 0x20 Match this alternative, or the next... */
+#define        BACK                    33      /* 0x21 Match "", "next" ptr points backward. */
+#define        EXACT                   34      /* 0x22 Match this string (preceded by length). */
+#define        EXACTF                  35      /* 0x23 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
+#define        EXACTFL                 36      /* 0x24 Match this string (not guaranteed to be folded) using /il rules (w/len). */
+#define        EXACTFU                 37      /* 0x25 Match this string (folded iff in UTF-8, length in folding doesn't change if not in UTF-8) using /iu rules (w/len). */
+#define        EXACTFA                 38      /* 0x26 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
+#define        EXACTFU_SS              39      /* 0x27 Match this string (folded iff in UTF-8, length in folding may change even if not in UTF-8) using /iu rules (w/len). */
+#define        EXACTFU_TRICKYFOLD      40      /* 0x28 Match this folded UTF-8 string using /iu rules */
+#define        NOTHING                 41      /* 0x29 Match empty string. */
+#define        TAIL                    42      /* 0x2a Match empty string. Can jump here from outside. */
+#define        STAR                    43      /* 0x2b Match this (simple) thing 0 or more times. */
+#define        PLUS                    44      /* 0x2c Match this (simple) thing 1 or more times. */
+#define        CURLY                   45      /* 0x2d Match this simple thing {n,m} times. */
+#define        CURLYN                  46      /* 0x2e Capture next-after-this simple thing */
+#define        CURLYM                  47      /* 0x2f Capture this medium-complex thing {n,m} times. */
+#define        CURLYX                  48      /* 0x30 Match this complex thing {n,m} times. */
+#define        WHILEM                  49      /* 0x31 Do curly processing and see if rest matches. */
+#define        OPEN                    50      /* 0x32 Mark this point in input as start of #n. */
+#define        CLOSE                   51      /* 0x33 Analogous to OPEN. */
+#define        REF                     52      /* 0x34 Match some already matched string */
+#define        REFF                    53      /* 0x35 Match already matched string, folded using native charset semantics for non-utf8 */
+#define        REFFL                   54      /* 0x36 Match already matched string, folded in loc. */
+#define        REFFU                   55      /* 0x37 Match already matched string, folded using unicode semantics for non-utf8 */
+#define        REFFA                   56      /* 0x38 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define        NREF                    57      /* 0x39 Match some already matched string */
+#define        NREFF                   58      /* 0x3a Match already matched string, folded using native charset semantics for non-utf8 */
+#define        NREFFL                  59      /* 0x3b Match already matched string, folded in loc. */
+#define        NREFFU                  60      /* 0x3c Match already matched string, folded using unicode semantics for non-utf8 */
+#define        NREFFA                  61      /* 0x3d Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
+#define        IFMATCH                 62      /* 0x3e Succeeds if the following matches. */
+#define        UNLESSM                 63      /* 0x3f Fails if the following matches. */
+#define        SUSPEND                 64      /* 0x40 "Independent" sub-RE. */
+#define        IFTHEN                  65      /* 0x41 Switch, should be preceded by switcher. */
+#define        GROUPP                  66      /* 0x42 Whether the group matched. */
+#define        LONGJMP                 67      /* 0x43 Jump far away. */
+#define        BRANCHJ                 68      /* 0x44 BRANCH with long offset. */
+#define        EVAL                    69      /* 0x45 Execute some Perl code. */
+#define        MINMOD                  70      /* 0x46 Next operator is not greedy. */
+#define        LOGICAL                 71      /* 0x47 Next opcode should set the flag only. */
+#define        RENUM                   72      /* 0x48 Group with independently numbered parens. */
+#define        TRIE                    73      /* 0x49 Match many EXACT(F[ALU]?)? at once. flags==type */
+#define        TRIEC                   74      /* 0x4a Same as TRIE, but with embedded charclass data */
+#define        AHOCORASICK             75      /* 0x4b Aho Corasick stclass. flags==type */
+#define        AHOCORASICKC            76      /* 0x4c Same as AHOCORASICK, but with embedded charclass data */
+#define        GOSUB                   77      /* 0x4d recurse to paren arg1 at (signed) ofs arg2 */
+#define        GOSTART                 78      /* 0x4e recurse to start of pattern */
+#define        NGROUPP                 79      /* 0x4f Whether the group matched. */
+#define        INSUBP                  80      /* 0x50 Whether we are in a specific recurse. */
+#define        DEFINEP                 81      /* 0x51 Never execute directly. */
+#define        ENDLIKE                 82      /* 0x52 Used only for the type field of verbs */
+#define        OPFAIL                  83      /* 0x53 Same as (?!) */
+#define        ACCEPT                  84      /* 0x54 Accepts the current matched string. */
+#define        VERB                    85      /* 0x55 Used only for the type field of verbs */
+#define        PRUNE                   86      /* 0x56 Pattern fails at this startpoint if no-backtracking through this */
+#define        MARKPOINT               87      /* 0x57 Push the current location for rollback by cut. */
+#define        SKIP                    88      /* 0x58 On failure skip forward (to the mark) before retrying */
+#define        COMMIT                  89      /* 0x59 Pattern fails outright if backtracking through this */
+#define        CUTGROUP                90      /* 0x5a On failure go to the next alternation in the group */
+#define        KEEPS                   91      /* 0x5b $& begins here. */
+#define        LNBREAK                 92      /* 0x5c generic newline pattern */
+#define        OPTIMIZED               93      /* 0x5d Placeholder for dump. */
+#define        PSEUDO                  94      /* 0x5e Pseudo opcode for internal use. */
        /* ------------ States ------------- */
 #define        TRIE_next               (REGNODE_MAX + 1)       /* state for TRIE */
 #define        TRIE_next_fail          (REGNODE_MAX + 2)       /* state for TRIE */
@@ -173,6 +174,7 @@ EXTCONST U8 PL_regkind[] = {
        REG_ANY,        /* SANY                   */
        REG_ANY,        /* CANY                   */
        ANYOF,          /* ANYOF                  */
+       ANYOF,          /* ANYOF_WARN_SUPER       */
        POSIXD,         /* POSIXD                 */
        POSIXD,         /* POSIXL                 */
        POSIXD,         /* POSIXU                 */
@@ -315,6 +317,7 @@ static const U8 regarglen[] = {
        0,                                      /* SANY         */
        0,                                      /* CANY         */
        0,                                      /* ANYOF        */
+       0,                                      /* ANYOF_WARN_SUPER */
        0,                                      /* POSIXD       */
        0,                                      /* POSIXL       */
        0,                                      /* POSIXU       */
@@ -414,6 +417,7 @@ static const char reg_off_by_arg[] = {
        0,      /* SANY         */
        0,      /* CANY         */
        0,      /* ANYOF        */
+       0,      /* ANYOF_WARN_SUPER */
        0,      /* POSIXD       */
        0,      /* POSIXL       */
        0,      /* POSIXU       */
@@ -518,78 +522,79 @@ EXTCONST char * const PL_reg_name[] = {
        "SANY",                         /* 0x13 */
        "CANY",                         /* 0x14 */
        "ANYOF",                        /* 0x15 */
-       "POSIXD",                       /* 0x16 */
-       "POSIXL",                       /* 0x17 */
-       "POSIXU",                       /* 0x18 */
-       "POSIXA",                       /* 0x19 */
-       "NPOSIXD",                      /* 0x1a */
-       "NPOSIXL",                      /* 0x1b */
-       "NPOSIXU",                      /* 0x1c */
-       "NPOSIXA",                      /* 0x1d */
-       "CLUMP",                        /* 0x1e */
-       "BRANCH",                       /* 0x1f */
-       "BACK",                         /* 0x20 */
-       "EXACT",                        /* 0x21 */
-       "EXACTF",                       /* 0x22 */
-       "EXACTFL",                      /* 0x23 */
-       "EXACTFU",                      /* 0x24 */
-       "EXACTFA",                      /* 0x25 */
-       "EXACTFU_SS",                   /* 0x26 */
-       "EXACTFU_TRICKYFOLD",           /* 0x27 */
-       "NOTHING",                      /* 0x28 */
-       "TAIL",                         /* 0x29 */
-       "STAR",                         /* 0x2a */
-       "PLUS",                         /* 0x2b */
-       "CURLY",                        /* 0x2c */
-       "CURLYN",                       /* 0x2d */
-       "CURLYM",                       /* 0x2e */
-       "CURLYX",                       /* 0x2f */
-       "WHILEM",                       /* 0x30 */
-       "OPEN",                         /* 0x31 */
-       "CLOSE",                        /* 0x32 */
-       "REF",                          /* 0x33 */
-       "REFF",                         /* 0x34 */
-       "REFFL",                        /* 0x35 */
-       "REFFU",                        /* 0x36 */
-       "REFFA",                        /* 0x37 */
-       "NREF",                         /* 0x38 */
-       "NREFF",                        /* 0x39 */
-       "NREFFL",                       /* 0x3a */
-       "NREFFU",                       /* 0x3b */
-       "NREFFA",                       /* 0x3c */
-       "IFMATCH",                      /* 0x3d */
-       "UNLESSM",                      /* 0x3e */
-       "SUSPEND",                      /* 0x3f */
-       "IFTHEN",                       /* 0x40 */
-       "GROUPP",                       /* 0x41 */
-       "LONGJMP",                      /* 0x42 */
-       "BRANCHJ",                      /* 0x43 */
-       "EVAL",                         /* 0x44 */
-       "MINMOD",                       /* 0x45 */
-       "LOGICAL",                      /* 0x46 */
-       "RENUM",                        /* 0x47 */
-       "TRIE",                         /* 0x48 */
-       "TRIEC",                        /* 0x49 */
-       "AHOCORASICK",                  /* 0x4a */
-       "AHOCORASICKC",                 /* 0x4b */
-       "GOSUB",                        /* 0x4c */
-       "GOSTART",                      /* 0x4d */
-       "NGROUPP",                      /* 0x4e */
-       "INSUBP",                       /* 0x4f */
-       "DEFINEP",                      /* 0x50 */
-       "ENDLIKE",                      /* 0x51 */
-       "OPFAIL",                       /* 0x52 */
-       "ACCEPT",                       /* 0x53 */
-       "VERB",                         /* 0x54 */
-       "PRUNE",                        /* 0x55 */
-       "MARKPOINT",                    /* 0x56 */
-       "SKIP",                         /* 0x57 */
-       "COMMIT",                       /* 0x58 */
-       "CUTGROUP",                     /* 0x59 */
-       "KEEPS",                        /* 0x5a */
-       "LNBREAK",                      /* 0x5b */
-       "OPTIMIZED",                    /* 0x5c */
-       "PSEUDO",                       /* 0x5d */
+       "ANYOF_WARN_SUPER",             /* 0x16 */
+       "POSIXD",                       /* 0x17 */
+       "POSIXL",                       /* 0x18 */
+       "POSIXU",                       /* 0x19 */
+       "POSIXA",                       /* 0x1a */
+       "NPOSIXD",                      /* 0x1b */
+       "NPOSIXL",                      /* 0x1c */
+       "NPOSIXU",                      /* 0x1d */
+       "NPOSIXA",                      /* 0x1e */
+       "CLUMP",                        /* 0x1f */
+       "BRANCH",                       /* 0x20 */
+       "BACK",                         /* 0x21 */
+       "EXACT",                        /* 0x22 */
+       "EXACTF",                       /* 0x23 */
+       "EXACTFL",                      /* 0x24 */
+       "EXACTFU",                      /* 0x25 */
+       "EXACTFA",                      /* 0x26 */
+       "EXACTFU_SS",                   /* 0x27 */
+       "EXACTFU_TRICKYFOLD",           /* 0x28 */
+       "NOTHING",                      /* 0x29 */
+       "TAIL",                         /* 0x2a */
+       "STAR",                         /* 0x2b */
+       "PLUS",                         /* 0x2c */
+       "CURLY",                        /* 0x2d */
+       "CURLYN",                       /* 0x2e */
+       "CURLYM",                       /* 0x2f */
+       "CURLYX",                       /* 0x30 */
+       "WHILEM",                       /* 0x31 */
+       "OPEN",                         /* 0x32 */
+       "CLOSE",                        /* 0x33 */
+       "REF",                          /* 0x34 */
+       "REFF",                         /* 0x35 */
+       "REFFL",                        /* 0x36 */
+       "REFFU",                        /* 0x37 */
+       "REFFA",                        /* 0x38 */
+       "NREF",                         /* 0x39 */
+       "NREFF",                        /* 0x3a */
+       "NREFFL",                       /* 0x3b */
+       "NREFFU",                       /* 0x3c */
+       "NREFFA",                       /* 0x3d */
+       "IFMATCH",                      /* 0x3e */
+       "UNLESSM",                      /* 0x3f */
+       "SUSPEND",                      /* 0x40 */
+       "IFTHEN",                       /* 0x41 */
+       "GROUPP",                       /* 0x42 */
+       "LONGJMP",                      /* 0x43 */
+       "BRANCHJ",                      /* 0x44 */
+       "EVAL",                         /* 0x45 */
+       "MINMOD",                       /* 0x46 */
+       "LOGICAL",                      /* 0x47 */
+       "RENUM",                        /* 0x48 */
+       "TRIE",                         /* 0x49 */
+       "TRIEC",                        /* 0x4a */
+       "AHOCORASICK",                  /* 0x4b */
+       "AHOCORASICKC",                 /* 0x4c */
+       "GOSUB",                        /* 0x4d */
+       "GOSTART",                      /* 0x4e */
+       "NGROUPP",                      /* 0x4f */
+       "INSUBP",                       /* 0x50 */
+       "DEFINEP",                      /* 0x51 */
+       "ENDLIKE",                      /* 0x52 */
+       "OPFAIL",                       /* 0x53 */
+       "ACCEPT",                       /* 0x54 */
+       "VERB",                         /* 0x55 */
+       "PRUNE",                        /* 0x56 */
+       "MARKPOINT",                    /* 0x57 */
+       "SKIP",                         /* 0x58 */
+       "COMMIT",                       /* 0x59 */
+       "CUTGROUP",                     /* 0x5a */
+       "KEEPS",                        /* 0x5b */
+       "LNBREAK",                      /* 0x5c */
+       "OPTIMIZED",                    /* 0x5d */
+       "PSEUDO",                       /* 0x5e */
        /* ------------ States ------------- */
        "TRIE_next",                    /* REGNODE_MAX +0x01 */
        "TRIE_next_fail",               /* REGNODE_MAX +0x02 */
@@ -694,7 +699,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = {
 EXTCONST U8 PL_varies_bitmask[];
 #else
 EXTCONST U8 PL_varies_bitmask[] = {
-    0x00, 0x00, 0x00, 0xC0, 0x01, 0xFC, 0xF9, 0x9F, 0x09, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x80, 0x03, 0xF8, 0xF3, 0x3F, 0x13, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */
 
@@ -706,8 +711,8 @@ EXTCONST U8 PL_varies_bitmask[] = {
 EXTCONST U8 PL_simple[] __attribute__deprecated__;
 #else
 EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
-    REG_ANY, SANY, CANY, ANYOF, POSIXD, POSIXL, POSIXU, POSIXA, NPOSIXD,
-    NPOSIXL, NPOSIXU, NPOSIXA,
+    REG_ANY, SANY, CANY, ANYOF, ANYOF_WARN_SUPER, POSIXD, POSIXL, POSIXU,
+    POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA,
     0
 };
 #endif /* DOINIT */
@@ -716,7 +721,7 @@ EXTCONST U8 PL_simple[] __attribute__deprecated__ = {
 EXTCONST U8 PL_simple_bitmask[];
 #else
 EXTCONST U8 PL_simple_bitmask[] = {
-    0x00, 0x00, 0xFC, 0x3F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+    0x00, 0x00, 0xFC, 0x7F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */