This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Free up bit for regex ANYOF nodes
authorKarl Williamson <public@khwilliamson.com>
Thu, 30 Jan 2014 03:42:33 +0000 (20:42 -0700)
committerKarl Williamson <public@khwilliamson.com>
Sun, 16 Feb 2014 04:55:32 +0000 (21:55 -0700)
This commit frees up a bit by using an extra regnode to pass the
information to the regex engine instead of the flag.  I originally
thought that if this was needed, it should be the ANYOF_ABOVE_LATIN1_ALL
bit, as that might speed some things up.  But if we need to do this
again by adding another node to get another bit, we want one that is
mutually exclusive of the first one we did, For otherwise we start
having to make 3 nodes instead of two to get the combinations:
 1 0
 0 1
 1 1

This combinatorial problem is avoided by using bits that are mutually
exclusive, which the ABOVE_LATIN1_ALL isn't, but the one freed by this
commit ANYOF_NON_UTF8_NON_ASCII_ALL is only set under /d matching, and
there are other bits that are set only under /l, so if we need to do
this again, we should use one of those.

I wrote this code when I thought I really needed a bit.  But since, I
have figured out a better way to get the bit needed now.  But I don't
want to lose this code to posterity, so this commit is being made long
enough to get the commit number, then it will be reverted, adding
comments referring to the commit number, so that it can easily be
reconstructed when necessary.

pod/perldebguts.pod
regcomp.c
regcomp.h
regcomp.sym
regexec.c
regnodes.h
t/porting/known_pod_issues.dat

index 526124e..60538df 100644 (file)
@@ -556,56 +556,72 @@ will be lost.
 
  # Exit points
 
- END             no         End of program.
- SUCCEED         no         Return from a subroutine, basically.
+ END                          no         End of program.
+ SUCCEED                      no         Return from a subroutine,
+                                         basically.
 
  # Anchors:
 
- BOL             no         Match "" at beginning of line.
- MBOL            no         Same, assuming multiline.
- SBOL            no         Same, assuming singleline.
- EOS             no         Match "" at end of string.
- EOL             no         Match "" at end of line.
- MEOL            no         Same, assuming multiline.
- SEOL            no         Same, assuming singleline.
- BOUND           no         Match "" at any word boundary using native
-                            charset semantics for non-utf8
- BOUNDL          no         Match "" at any locale word boundary
- BOUNDU          no         Match "" at any word boundary using Unicode
-                            semantics
- BOUNDA          no         Match "" at any word boundary using ASCII
-                            semantics
- NBOUND          no         Match "" at any word non-boundary using
-                            native charset semantics for non-utf8
- NBOUNDL         no         Match "" at any locale word non-boundary
- NBOUNDU         no         Match "" at any word non-boundary using
-                            Unicode semantics
- NBOUNDA         no         Match "" at any word non-boundary using
-                            ASCII semantics
- GPOS            no         Matches where last m//g left off.
+ BOL                          no         Match "" at beginning of line.
+ MBOL                         no         Same, assuming multiline.
+ SBOL                         no         Same, assuming singleline.
+ EOS                          no         Match "" at end of string.
+ EOL                          no         Match "" at end of line.
+ MEOL                         no         Same, assuming multiline.
+ SEOL                         no         Same, assuming singleline.
+ BOUND                        no         Match "" at any word boundary
+                                         using native charset semantics
+                                         for non-utf8
+ BOUNDL                       no         Match "" at any locale word
+                                         boundary
+ BOUNDU                       no         Match "" at any word boundary
+                                         using Unicode semantics
+ BOUNDA                       no         Match "" at any word boundary
+                                         using ASCII semantics
+ NBOUND                       no         Match "" at any word non-
+                                         boundary using native charset
+                                         semantics for non-utf8
+ NBOUNDL                      no         Match "" at any locale word non-
+                                         boundary
+ NBOUNDU                      no         Match "" at any word non-
+                                         boundary using Unicode
+                                         semantics
+ NBOUNDA                      no         Match "" at any word non-
+                                         boundary using ASCII semantics
+ GPOS                         no         Matches where last m//g left
+                                         off.
 
  # [Special] alternatives:
 
- REG_ANY         no         Match any one character (except newline).
- SANY            no         Match any one character.
- CANY            no         Match any one byte.
- ANYOF           sv         Match character in (or not in) this class,
-                            single char match only
-
- POSIXD          none       Some [[:class:]] under /d; the FLAGS field
-                            gives which one
- POSIXL          none       Some [[:class:]] under /l; the FLAGS field
-                            gives which one
- POSIXU          none       Some [[:class:]] under /u; the FLAGS field
-                            gives which one
- POSIXA          none       Some [[:class:]] under /a; the FLAGS field
-                            gives which one
- NPOSIXD         none       complement of POSIXD, [[:^class:]]
- NPOSIXL         none       complement of POSIXL, [[:^class:]]
- NPOSIXU         none       complement of POSIXU, [[:^class:]]
- NPOSIXA         none       complement of POSIXA, [[:^class:]]
-
- CLUMP           no         Match any extended grapheme cluster sequence
+ REG_ANY                      no         Match any one character (except
+                                         newline).
+ SANY                         no         Match any one character.
+ CANY                         no         Match any one byte.
+ ANYOF                        sv         Match character in (or not in)
+                                         this class, single char match
+                                         only
+ ANYOF_NON_UTF8_NON_ASCII_ALL sv         like ANYOF, also matches any
+                                         U+80 - U+FF when not in UTF-8
+
+ POSIXD                       none       Some [[:class:]] under /d; the
+                                         FLAGS field gives which one
+ POSIXL                       none       Some [[:class:]] under /l; the
+                                         FLAGS field gives which one
+ POSIXU                       none       Some [[:class:]] under /u; the
+                                         FLAGS field gives which one
+ POSIXA                       none       Some [[:class:]] under /a; the
+                                         FLAGS field gives which one
+ NPOSIXD                      none       complement of POSIXD,
+                                         [[:^class:]]
+ NPOSIXL                      none       complement of POSIXL,
+                                         [[:^class:]]
+ NPOSIXU                      none       complement of POSIXU,
+                                         [[:^class:]]
+ NPOSIXA                      none       complement of POSIXA,
+                                         [[:^class:]]
+
+ CLUMP                        no         Match any extended grapheme
+                                         cluster sequence
 
  # Alternation
 
@@ -618,40 +634,49 @@ will be lost.
  #               pointer of each individual branch points; each branch
  #               starts with the operand node of a BRANCH node.
  #
- BRANCH          node       Match this alternative, or the next...
+ BRANCH                       node       Match this alternative, or the
+                                         next...
 
  # Back pointer
 
  # BACK          Normal "next" pointers all implicitly point forward;
  #               BACK exists to make loop structures possible.
  # not used
- BACK            no         Match "", "next" ptr points backward.
+ BACK                         no         Match "", "next" ptr points
+                                         backward.
 
  # Literals
 
- EXACT           str        Match this string (preceded by length).
- EXACTF          str        Match this non-UTF-8 string (not guaranteed
-                            to be folded) using /id rules (w/len).
- EXACTFL         str        Match this string (not guaranteed to be
-                            folded) using /il rules (w/len).
- EXACTFU         str        Match this string (folded iff in UTF-8,
-                            length in folding doesn't change if not in
-                            UTF-8) using /iu rules (w/len).
- EXACTFA         str        Match this string (not guaranteed to be
-                            folded) using /iaa rules (w/len).
- EXACTFU_SS      str        Match this string (folded iff in UTF-8,
-                            length in folding may change even if not in
-                            UTF-8) using /iu rules (w/len).
- EXACTFA_NO_TRIE str        Match this string (which is not trie-able;
-                            not guaranteed to be folded) using /iaa
-                            rules (w/len).
+ EXACT                        str        Match this string (preceded by
+                                         length).
+ EXACTF                       str        Match this non-UTF-8 string
+                                         (not guaranteed to be folded)
+                                         using /id rules (w/len).
+ EXACTFL                      str        Match this string (not
+                                         guaranteed to be folded) using
+                                         /il rules (w/len).
+ EXACTFU                      str        Match this string (folded iff
+                                         in UTF-8, length in folding
+                                         doesn't change if not in UTF-8)
+                                         using /iu rules (w/len).
+ EXACTFA                      str        Match this string (not
+                                         guaranteed to be folded) using
+                                         /iaa rules (w/len).
+ EXACTFU_SS                   str        Match this string (folded iff
+                                         in UTF-8, length in folding may
+                                         change even if not in UTF-8)
+                                         using /iu rules (w/len).
+ EXACTFA_NO_TRIE              str        Match this string (which is not
+                                         trie-able; not guaranteed to be
+                                         folded) using /iaa rules
+                                         (w/len).
 
  # Do nothing types
 
- NOTHING         no         Match empty string.
+ NOTHING                      no         Match empty string.
  # A variant of above which delimits a group, thus stops optimizations
- TAIL            no         Match empty string. Can jump here from
-                            outside.
+ TAIL                         no         Match empty string. Can jump
+                                         here from outside.
 
  # Loops
 
@@ -660,68 +685,89 @@ will be lost.
  #               (one character per match) are implemented with STAR
  #               and PLUS for speed and to minimize recursive plunges.
  #
- STAR            node       Match this (simple) thing 0 or more times.
- PLUS            node       Match this (simple) thing 1 or more times.
-
- CURLY           sv 2       Match this simple thing {n,m} times.
- CURLYN          no 2       Capture next-after-this simple thing
- CURLYM          no 2       Capture this medium-complex thing {n,m}
-                            times.
- CURLYX          sv 2       Match this complex thing {n,m} times.
+ STAR                         node       Match this (simple) thing 0 or
+                                         more times.
+ PLUS                         node       Match this (simple) thing 1 or
+                                         more times.
+
+ CURLY                        sv 2       Match this simple thing {n,m}
+                                         times.
+ CURLYN                       no 2       Capture next-after-this simple
+                                         thing
+ CURLYM                       no 2       Capture this medium-complex
+                                         thing {n,m} times.
+ CURLYX                       sv 2       Match this complex thing {n,m}
+                                         times.
 
  # This terminator creates a loop structure for CURLYX
- WHILEM          no         Do curly processing and see if rest matches.
+ WHILEM                       no         Do curly processing and see if
+                                         rest matches.
 
  # Buffer related
 
  # OPEN,CLOSE,GROUPP     ...are numbered at compile time.
- OPEN            num 1      Mark this point in input as start of #n.
- CLOSE           num 1      Analogous to OPEN.
-
- REF             num 1      Match some already matched string
- REFF            num 1      Match already matched string, folded using
-                            native charset semantics for non-utf8
- REFFL           num 1      Match already matched string, folded in loc.
- REFFU           num 1      Match already matched string, folded using
-                            unicode semantics for non-utf8
- REFFA           num 1      Match already matched string, folded using
-                            unicode semantics for non-utf8, no mixing
-                            ASCII, non-ASCII
+ OPEN                         num 1      Mark this point in input as
+                                         start of #n.
+ CLOSE                        num 1      Analogous to OPEN.
+
+ REF                          num 1      Match some already matched
+                                         string
+ REFF                         num 1      Match already matched string,
+                                         folded using native charset
+                                         semantics for non-utf8
+ REFFL                        num 1      Match already matched string,
+                                         folded in loc.
+ REFFU                        num 1      Match already matched string,
+                                         folded using unicode semantics
+                                         for non-utf8
+ REFFA                        num 1      Match already matched string,
+                                         folded using unicode semantics
+                                         for non-utf8, no mixing ASCII,
+                                         non-ASCII
 
  # Named references.  Code in regcomp.c assumes that these all are after
  # the numbered references
- NREF            no-sv 1    Match some already matched string
- NREFF           no-sv 1    Match already matched string, folded using
-                            native charset semantics for non-utf8
- NREFFL          no-sv 1    Match already matched string, folded in loc.
- NREFFU          num 1      Match already matched string, folded using
-                            unicode semantics for non-utf8
- NREFFA          num 1      Match already matched string, folded using
-                            unicode semantics for non-utf8, no mixing
-                            ASCII, non-ASCII
-
- IFMATCH         off 1 2    Succeeds if the following matches.
- UNLESSM         off 1 2    Fails if the following matches.
- SUSPEND         off 1 1    "Independent" sub-RE.
- IFTHEN          off 1 1    Switch, should be preceded by switcher.
- GROUPP          num 1      Whether the group matched.
+ NREF                         no-sv 1    Match some already matched
+                                         string
+ NREFF                        no-sv 1    Match already matched string,
+                                         folded using native charset
+                                         semantics for non-utf8
+ NREFFL                       no-sv 1    Match already matched string,
+                                         folded in loc.
+ NREFFU                       num 1      Match already matched string,
+                                         folded using unicode semantics
+                                         for non-utf8
+ NREFFA                       num 1      Match already matched string,
+                                         folded using unicode semantics
+                                         for non-utf8, no mixing ASCII,
+                                         non-ASCII
+
+ IFMATCH                      off 1 2    Succeeds if the following
+                                         matches.
+ UNLESSM                      off 1 2    Fails if the following matches.
+ SUSPEND                      off 1 1    "Independent" sub-RE.
+ IFTHEN                       off 1 1    Switch, should be preceded by
+                                         switcher.
+ GROUPP                       num 1      Whether the group matched.
 
  # Support for long RE
 
- LONGJMP         off 1 1    Jump far away.
- BRANCHJ         off 1 1    BRANCH with long offset.
+ LONGJMP                      off 1 1    Jump far away.
+ BRANCHJ                      off 1 1    BRANCH with long offset.
 
  # The heavy worker
 
- EVAL            evl 1      Execute some Perl code.
+ EVAL                         evl 1      Execute some Perl code.
 
  # Modifiers
 
- MINMOD          no         Next operator is not greedy.
- LOGICAL         no         Next opcode should set the flag only.
+ MINMOD                       no         Next operator is not greedy.
+ LOGICAL                      no         Next opcode should set the flag
+                                         only.
 
  # This is not used yet
- RENUM           off 1 1    Group with independently numbered parens.
+ RENUM                        off 1 1    Group with independently
+                                         numbered parens.
 
  # Trie Related
 
@@ -729,60 +775,67 @@ will be lost.
  # have inline charclass data (ascii only), the 'C' store it in the
  # structure.
 
- TRIE            trie 1     Match many EXACT(F[ALU]?)? at once.
-                            flags==type
- TRIEC           trie       Same as TRIE, but with embedded charclass
-                 charclass  data
+ TRIE                         trie 1     Match many EXACT(F[ALU]?)? at
+                                         once. flags==type
+ TRIEC                        trie       Same as TRIE, but with embedded
+                              charclass  charclass data
 
- AHOCORASICK     trie 1     Aho Corasick stclass. flags==type
- AHOCORASICKC    trie       Same as AHOCORASICK, but with embedded
-                 charclass  charclass data
+ AHOCORASICK                  trie 1     Aho Corasick stclass.
+                                         flags==type
+ AHOCORASICKC                 trie       Same as AHOCORASICK, but with
+                              charclass  embedded charclass data
 
  # Regex Subroutines
- GOSUB           num/ofs 2L recurse to paren arg1 at (signed) ofs arg2
- GOSTART         no         recurse to start of pattern
+ GOSUB                        num/ofs 2L recurse to paren arg1 at
+                                         (signed) ofs arg2
+ GOSTART                      no         recurse to start of pattern
 
  # Special conditionals
- NGROUPP         no-sv 1    Whether the group matched.
- INSUBP          num 1      Whether we are in a specific recurse.
- DEFINEP         none 1     Never execute directly.
+ NGROUPP                      no-sv 1    Whether the group matched.
+ INSUBP                       num 1      Whether we are in a specific
+                                         recurse.
+ DEFINEP                      none 1     Never execute directly.
 
  # Backtracking Verbs
- ENDLIKE         none       Used only for the type field of verbs
- OPFAIL          none       Same as (?!)
- ACCEPT          parno 1    Accepts the current matched string.
+ ENDLIKE                      none       Used only for the type field of
+                                         verbs
+ OPFAIL                       none       Same as (?!)
+ ACCEPT                       parno 1    Accepts the current matched
+                                         string.
 
  # Verbs With Arguments
- VERB            no-sv 1    Used only for the type field of verbs
- PRUNE           no-sv 1    Pattern fails at this startpoint if no-
-                            backtracking through this
- MARKPOINT       no-sv 1    Push the current location for rollback by
-                            cut.
- SKIP            no-sv 1    On failure skip forward (to the mark) before
-                            retrying
- COMMIT          no-sv 1    Pattern fails outright if backtracking
-                            through this
- CUTGROUP        no-sv 1    On failure go to the next alternation in the
-                            group
+ VERB                         no-sv 1    Used only for the type field of
+                                         verbs
+ PRUNE                        no-sv 1    Pattern fails at this
+                                         startpoint if no-backtracking
+                                         through this
+ MARKPOINT                    no-sv 1    Push the current location for
+                                         rollback by cut.
+ SKIP                         no-sv 1    On failure skip forward (to the
+                                         mark) before retrying
+ COMMIT                       no-sv 1    Pattern fails outright if
+                                         backtracking through this
+ CUTGROUP                     no-sv 1    On failure go to the next
+                                         alternation in the group
 
  # Control what to keep in $&.
- KEEPS           no         $& begins here.
+ KEEPS                        no         $& begins here.
 
  # New charclass like patterns
- LNBREAK         none       generic newline pattern
+ LNBREAK                      none       generic newline pattern
 
  # SPECIAL  REGOPS
 
  # This is not really a node, but an optimized away piece of a "long"
  # node.  To simplify debugging output, we mark it as if it were a node
- OPTIMIZED       off        Placeholder for dump.
+ OPTIMIZED                    off        Placeholder for dump.
 
  # Special opcode with the property that no opcode in a compiled program
  # will ever be of this type. Thus it can be used as a flag value that
  # no other opcode has been seen. END is used similarly, in that an END
  # node cant be optimized. So END implies "unoptimizable" and PSEUDO
  # mean "not seen anything to optimize yet".
- PSEUDO          off        Pseudo opcode for internal use.
+ PSEUDO                       off        Pseudo opcode for internal use.
 
 =for regcomp.pl end
 
index a82171a..96bf775 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -1068,7 +1068,7 @@ S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state,
 
     /* If this can match all upper Latin1 code points, have to add them
      * as well */
-    if (ANYOF_FLAGS(node) & ANYOF_NON_UTF8_NON_ASCII_ALL) {
+    if (OP(node) == ANYOF_NON_UTF8_NON_ASCII_ALL) {
         _invlist_union(invlist, PL_UpperLatin1, &invlist);
     }
 
@@ -4840,6 +4840,7 @@ PerlIO_printf(Perl_debug_log, "LHS=%"UVdf" RHS=%"UVdf"\n",
                    }
                    break;
 
+                case ANYOF_NON_UTF8_NON_ASCII_ALL:
                 case ANYOF:
                    if (flags & SCF_DO_STCLASS_AND)
                        ssc_and(pRExC_state, data->start_class,
@@ -14471,7 +14472,7 @@ parseit:
             if (DEPENDS_SEMANTICS) {
                 /* Under /d, everything in the upper half of the Latin1 range
                  * matches these complements */
-                ANYOF_FLAGS(ret) |= ANYOF_NON_UTF8_NON_ASCII_ALL;
+                OP(ret) = ANYOF_NON_UTF8_NON_ASCII_ALL;
             }
             else if (AT_LEAST_ASCII_RESTRICTED) {
                 /* Under /a and /aa, everything above ASCII matches these
@@ -15657,7 +15658,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o)
                     sv_catpvs(sv, "^");
             }
 
-            if (flags & ANYOF_NON_UTF8_NON_ASCII_ALL) {
+            if (OP(o) == ANYOF_NON_UTF8_NON_ASCII_ALL) {
                 sv_catpvs(sv, "{non-utf8-latin1-all}");
             }
 
index 84aa85d..69bd852 100644 (file)
--- a/regcomp.h
+++ b/regcomp.h
@@ -358,17 +358,15 @@ struct regnode_ssc {
  * ANYOF_NONBITMAP_NON_UTF8 bit is also set. */
 #define ANYOF_NONBITMAP(node)  (ARG(node) != ANYOF_NONBITMAP_EMPTY)
 
-/* Flags for node->flags of ANYOF.  These are in short supply, with none
- * currently available.  If more are needed, the ANYOF_LOCALE and
- * ANYOF_POSIXL bits could be shared, making a space penalty for all locale
- * nodes.  Also, the ABOVE_LATIN1_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 improve performance a bit by allowing regexec.c to test
- * for a UTF-8 character being above 255 without having to call a function nor
- * calculate its code point value.  Several flags are not used in synthetic
- * start class (SSC) nodes, so could be shared should new flags be needed for
- * SSCs. */
+/* Flags for node->flags of ANYOF.  These are in short supply, with one
+ * currently available.  If more are needed, the ABOVE_LATIN1_ALL bit could be
+ * freed up by resorting to creating a swash containing everything above 255.
+ * This introduces a performance penalty.  An option that wouldn't slow things
+ * down would be to split one of the LOC flags out into a separate node, like
+ * what has been done with ANYOF_NON_UTF8_NON_ASCII_ALL.  One of these is only
+ * for /l nodes; the other only for /d, so there are no combinatorial issues.
+ * Several flags are not used in synthetic start class (SSC) nodes, so could be
+ * shared should new flags be needed for SSCs, like ANYOF_EMPTY_STRING now. */
 
 /* regexec.c is expecting this to be in the low bit */
 #define ANYOF_INVERT            0x01
@@ -406,11 +404,7 @@ struct regnode_ssc {
 #define ANYOF_ABOVE_LATIN1_ALL  0x40
 #define ANYOF_UNICODE_ALL       ANYOF_ABOVE_LATIN1_ALL
 
-/* Match all Latin1 characters that aren't ASCII when the target string is not
- * in utf8. */
-#define ANYOF_NON_UTF8_NON_ASCII_ALL 0x80
-
-#define ANYOF_FLAGS_ALL                (0xff)
+#define ANYOF_FLAGS_ALL                (0x7F)
 
 #define ANYOF_LOCALE_FLAGS (ANYOF_LOCALE                        \
                            |ANYOF_LOC_FOLD                      \
index a198186..4764d0e 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_NON_UTF8_NON_ASCII_ALL ANYOF, sv 0 S ; like ANYOF, also matches any U+80 - U+FF when not in UTF-8
 
 # 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 a2928ce..235a3fb 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -1619,6 +1619,14 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
 
     /* We know what class it must start with. */
     switch (OP(c)) {
+    case ANYOF_NON_UTF8_NON_ASCII_ALL:
+        if (! utf8_target && ! ANYOF_FLAGS(c)) {
+            REXEC_FBC_CLASS_SCAN(! isASCII((U8) *s)
+                                 || REGINCLASS(prog, c, (U8*)s));
+            break;
+        }
+
+       /* FALL THROUGH */
     case ANYOF:
         if (utf8_target) {
             REXEC_FBC_UTF8_CLASS_SCAN(
@@ -4576,6 +4584,17 @@ S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
                    sayNO;
            break;
 
+        case ANYOF_NON_UTF8_NON_ASCII_ALL:
+            if (! NEXTCHR_IS_EOS && ! utf8_target && ! ANYOF_FLAGS(scan)) {
+               if ((isASCII((U8)(*locinput))
+                    && ! REGINCLASS(rex, scan, (U8*)locinput)))
+                {
+                   sayNO;
+                }
+               locinput++;
+                break;
+            }
+            /* FALLTHROUGH */
        case ANYOF:  /*  /[abc]/       */
             if (NEXTCHR_IS_EOS)
                 sayNO;
@@ -7203,6 +7222,17 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
        }
        break;
     }
+    case ANYOF_NON_UTF8_NON_ASCII_ALL:
+        if (! utf8_target && ! ANYOF_FLAGS(p)) {
+           while (scan < loceol
+                   && (! isASCII((U8) *scan)
+                       || REGINCLASS(prog, p, (U8*)scan)))
+            {
+               scan++;
+            }
+            break;
+        }
+        /* FALLTHROUGH */
     case ANYOF:
        if (utf8_target) {
            while (hardcount < max
@@ -7646,7 +7676,7 @@ S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8* const
     if (c < 256) {
        if (ANYOF_BITMAP_TEST(n, c))
            match = TRUE;
-       else if (flags & ANYOF_NON_UTF8_NON_ASCII_ALL
+       else if (OP(n) == ANYOF_NON_UTF8_NON_ASCII_ALL
                && ! utf8_target
                && ! isASCII(c))
        {
index f9d4fc0..f9de6c3 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        EXACTFA_NO_TRIE         39      /* 0x27 Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
-#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_NON_UTF8_NON_ASCII_ALL    22      /* 0x16 like ANYOF, also matches any U+80 - U+FF when not in UTF-8 */
+#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        EXACTFA_NO_TRIE         40      /* 0x28 Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
+#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_NON_UTF8_NON_ASCII_ALL */
        POSIXD,         /* POSIXD                 */
        POSIXD,         /* POSIXL                 */
        POSIXD,         /* POSIXU                 */
@@ -315,6 +317,7 @@ static const U8 regarglen[] = {
        0,                                      /* SANY         */
        0,                                      /* CANY         */
        0,                                      /* ANYOF        */
+       0,                                      /* ANYOF_NON_UTF8_NON_ASCII_ALL */
        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_NON_UTF8_NON_ASCII_ALL */
        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 */
-       "EXACTFA_NO_TRIE",              /* 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_NON_UTF8_NON_ASCII_ALL", /* 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 */
+       "EXACTFA_NO_TRIE",              /* 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 */
@@ -717,7 +722,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 */
 
@@ -729,8 +734,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_NON_UTF8_NON_ASCII_ALL, POSIXD,
+    POSIXL, POSIXU, POSIXA, NPOSIXD, NPOSIXL, NPOSIXU, NPOSIXA,
     0
 };
 #endif /* DOINIT */
@@ -739,7 +744,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 */
 
index c31cb38..75af59a 100644 (file)
@@ -231,7 +231,7 @@ pod/perlbook.pod    Verbatim line length including indents exceeds 79 by    1
 pod/perlcall.pod       Verbatim line length including indents exceeds 79 by    2
 pod/perlce.pod Verbatim line length including indents exceeds 79 by    3
 pod/perlcygwin.pod     Verbatim line length including indents exceeds 79 by    25
-pod/perldebguts.pod    Verbatim line length including indents exceeds 79 by    34
+pod/perldebguts.pod    Verbatim line length including indents exceeds 79 by    35
 pod/perldebtut.pod     Verbatim line length including indents exceeds 79 by    22
 pod/perldebug.pod      Verbatim line length including indents exceeds 79 by    3
 pod/perldelta.pod      Apparent broken link    1