This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Remove newly unnecessary regnode, code
authorKarl Williamson <public@khwilliamson.com>
Wed, 21 Aug 2013 03:23:59 +0000 (21:23 -0600)
committerKarl Williamson <public@khwilliamson.com>
Thu, 29 Aug 2013 16:56:59 +0000 (10:56 -0600)
The previous commit fixed things up so that this work-around regnode
doesn't have to exist; nor the work around for the EXACTFU_SS regnode

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

index a17a6b4..49238b2 100644 (file)
@@ -545,61 +545,61 @@ 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
- ANYOF_WARN_SUPER   sv         Match character in (or not in) this
-                               class, warn (if enabled) upon matching a
-                               char above Unicode max;
- ANYOF_SYNTHETIC    sv         Synthetic start class
-
- 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_WARN_SUPER sv         Match character in (or not in) this class,
+                             warn (if enabled) upon matching a char
+                             above Unicode max;
+ ANYOF_SYNTHETIC  sv         Synthetic start class
+
+ 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
 
@@ -612,40 +612,37 @@ 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).
- EXACTFU_TRICKYFOLD str        Match this folded UTF-8 string using /iu
-                               rules
+ 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).
 
  # 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
 
@@ -654,75 +651,71 @@ 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.
+ 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.
+ 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
 
@@ -730,61 +723,60 @@ 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 embedded
+                  charclass  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 cc9dd02..51141c0 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -1607,7 +1607,6 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
         case EXACT: break;
        case EXACTFA:
         case EXACTFU_SS:
-        case EXACTFU_TRICKYFOLD:
        case EXACTFU: folder = PL_fold_latin1; break;
        case EXACTF:  folder = PL_fold; break;
        case EXACTFL: folder = PL_fold_locale; break;
@@ -1810,18 +1809,6 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
         } else if (maxbytes > trie->maxlen) {
             trie->maxlen = maxbytes;
         }
-        if (OP( noper ) == EXACTFU_SS) {
-            /* XXX: workaround - 'ss' could match "\x{DF}" so minlen could be 1 and not 2*/
-           if (trie->minlen > 1)
-                trie->minlen= 1;
-        }
-       if (OP( noper ) == EXACTFU_TRICKYFOLD) {
-           /* XXX: workround - things like "\x{1FBE}\x{0308}\x{0301}" can match "\x{0390}" 
-            *                - We assume that any such sequence might match a 2 byte string */
-            if (trie->minlen > 2 )
-                trie->minlen= 2;
-        }
-
     } /* end first pass */
     DEBUG_TRIE_COMPILE_r(
         PerlIO_printf( Perl_debug_log, "%*sTRIE(%s): W:%d C:%d Uq:%d Min:%d Max:%d\n",
@@ -2715,8 +2702,8 @@ S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source,  regnode
  * that is "sss".
  *
  * It turns out that there are problems with all multi-character folds, and not
- * just these three.  Now the code is general, for all such cases, but the
- * three still have some special handling.  The approach taken is:
+ * just these three.  Now the code is general, for all such cases.  The
+ * approach taken is:
  * 1)   This routine examines each EXACTFish node that could contain multi-
  *      character fold sequences.  It returns in *min_subtract how much to
  *      subtract from the the actual length of the string to get a real minimum
@@ -2724,10 +2711,7 @@ S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source,  regnode
  *      used by the caller to adjust the min length of the match, and the delta
  *      between min and max, so that the optimizer doesn't reject these
  *      possibilities based on size constraints.
- * 2)   Certain of these sequences require special handling by the trie code,
- *      so, if found, this code changes the joined node type to special ops:
- *      EXACTFU_TRICKYFOLD and EXACTFU_SS.
- * 3)   For the sequence involving the Sharp s (\xDF), the node type EXACTFU_SS
+ * 2)   For the sequence involving the Sharp s (\xDF), the node type EXACTFU_SS
  *      is used for an EXACTFU node that contains at least one "ss" sequence in
  *      it.  For non-UTF-8 patterns and strings, this is the only case where
  *      there is a possible fold length change.  That means that a regular
@@ -2906,31 +2890,6 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, b
                     OP(scan) = EXACTFU_SS;
                     s += 2;
                 }
-                else if (len == 6   /* len is the same in both ASCII and EBCDIC
-                                       for these */
-                         && (memEQ(s, GREEK_SMALL_LETTER_IOTA_UTF8
-                                      COMBINING_DIAERESIS_UTF8
-                                      COMBINING_ACUTE_ACCENT_UTF8,
-                                   6)
-                             || memEQ(s, GREEK_SMALL_LETTER_UPSILON_UTF8
-                                         COMBINING_DIAERESIS_UTF8
-                                         COMBINING_ACUTE_ACCENT_UTF8,
-                                     6)))
-                {
-                    count = 3;
-
-                    /* These two folds require special handling by trie's, so
-                     * change the node type to indicate this.  If EXACTFA and
-                     * EXACTFL were ever to be handled by trie's, this would
-                     * have to be changed.  If this node has already been
-                     * changed to EXACTFU_SS in this loop, leave it as is.  (I
-                     * (khw) think it doesn't matter in regexec.c for UTF
-                     * patterns, but no need to change it */
-                    if (OP(scan) == EXACTFU) {
-                        OP(scan) = EXACTFU_TRICKYFOLD;
-                    }
-                    s += 6;
-                }
                 else { /* Here is a generic multi-char fold. */
                     const U8* multi_end  = s + len;
 
@@ -3394,14 +3353,13 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                                 EXACT           | EXACT
                                 EXACTFU         | EXACTFU
                                 EXACTFU_SS      | EXACTFU
-                                EXACTFU_TRICKYFOLD | EXACTFU
                                 EXACTFA         | 0
 
 
                         */
 #define TRIE_TYPE(X) ( ( NOTHING == (X) ) ? NOTHING :   \
                        ( EXACT == (X) )   ? EXACT :        \
-                       ( EXACTFU == (X) || EXACTFU_SS == (X) || EXACTFU_TRICKYFOLD == (X) ) ? EXACTFU :        \
+                       ( EXACTFU == (X) || EXACTFU_SS == (X) ) ? EXACTFU :        \
                        0 )
 
                         /* dont use tail as the end marker for this traverse */
@@ -14480,7 +14438,6 @@ S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val,
                 case EXACTFA:
                 case EXACTFU:
                 case EXACTFU_SS:
-                case EXACTFU_TRICKYFOLD:
                 case EXACTFL:
                         if( exact == PSEUDO )
                             exact= OP(scan);
index 4de5d79..8b19bff 100644 (file)
@@ -100,7 +100,6 @@ EXACTFL     EXACT,      str       ; Match this string (not guaranteed to be fold
 EXACTFU     EXACT,      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     EXACT,      str      ; Match this string (not guaranteed to be folded) using /iaa rules (w/len).
 EXACTFU_SS  EXACT,      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).
-EXACTFU_TRICKYFOLD EXACT,  str   ; Match this folded UTF-8 string using /iu rules
 
 #*Do nothing types
 
index 095a0f4..c417e50 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -207,13 +207,13 @@ static const char* const non_utf8_target_but_utf8_required
 /* Currently these are only used when PL_regkind[OP(rn)] == EXACT so
    we don't need this definition. */
 #define IS_TEXT(rn)   ( OP(rn)==EXACT   || OP(rn)==REF   || OP(rn)==NREF   )
-#define IS_TEXTF(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn)==EXACTFA || OP(rn)==EXACTF || OP(rn)==REFF  || OP(rn)==NREFF )
+#define IS_TEXTF(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFA || OP(rn)==EXACTF || OP(rn)==REFF  || OP(rn)==NREFF )
 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL || OP(rn)==REFFL || OP(rn)==NREFFL )
 
 #else
 /* ... so we use this as its faster. */
 #define IS_TEXT(rn)   ( OP(rn)==EXACT   )
-#define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFU_TRICKYFOLD || OP(rn) == EXACTFA)
+#define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn) == EXACTFA)
 #define IS_TEXTF(rn)  ( OP(rn)==EXACTF  )
 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
 
@@ -1521,7 +1521,6 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
         }
         goto do_exactf_utf8;
 
-    case EXACTFU_TRICKYFOLD:
     case EXACTFU:
         if (is_utf8_pat || utf8_target) {
             utf8_fold_flags = is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
@@ -3536,7 +3535,6 @@ S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
                     /* /u rules for all these.  This happens to work for
                      * EXACTFA as nothing in Latin1 folds to ASCII */
                 case EXACTFA:
-                case EXACTFU_TRICKYFOLD:
                 case EXACTFU_SS:
                 case EXACTFU:
                     c2 = PL_fold_latin1[c1];
@@ -4217,7 +4215,6 @@ S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
            goto do_exactf;
 
        case EXACTFU_SS:         /*  /\x{df}/iu   */
-       case EXACTFU_TRICKYFOLD: /*  /\x{390}/iu  */
        case EXACTFU:            /*  /abc/iu      */
            folder = foldEQ_latin1;
            fold_array = PL_fold_latin1;
@@ -6908,7 +6905,6 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
            goto do_exactf;
 
     case EXACTFU_SS:
-    case EXACTFU_TRICKYFOLD:
     case EXACTFU:
        utf8_flags = reginfo->is_utf8_pat ? FOLDEQ_S2_ALREADY_FOLDED : 0;
 
index b302f5d..0da6757 100644 (file)
@@ -6,8 +6,8 @@
 
 /* Regops and State definitions */
 
-#define REGNODE_MAX            95
-#define REGMATCH_STATE_MAX     135
+#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        EXACTFU                 38      /* 0x26 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                 39      /* 0x27 Match this string (not guaranteed to be folded) using /iaa rules (w/len). */
 #define        EXACTFU_SS              40      /* 0x28 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      41      /* 0x29 Match this folded UTF-8 string using /iu rules */
-#define        NOTHING                 42      /* 0x2a Match empty string. */
-#define        TAIL                    43      /* 0x2b Match empty string. Can jump here from outside. */
-#define        STAR                    44      /* 0x2c Match this (simple) thing 0 or more times. */
-#define        PLUS                    45      /* 0x2d Match this (simple) thing 1 or more times. */
-#define        CURLY                   46      /* 0x2e Match this simple thing {n,m} times. */
-#define        CURLYN                  47      /* 0x2f Capture next-after-this simple thing */
-#define        CURLYM                  48      /* 0x30 Capture this medium-complex thing {n,m} times. */
-#define        CURLYX                  49      /* 0x31 Match this complex thing {n,m} times. */
-#define        WHILEM                  50      /* 0x32 Do curly processing and see if rest matches. */
-#define        OPEN                    51      /* 0x33 Mark this point in input as start of #n. */
-#define        CLOSE                   52      /* 0x34 Analogous to OPEN. */
-#define        REF                     53      /* 0x35 Match some already matched string */
-#define        REFF                    54      /* 0x36 Match already matched string, folded using native charset semantics for non-utf8 */
-#define        REFFL                   55      /* 0x37 Match already matched string, folded in loc. */
-#define        REFFU                   56      /* 0x38 Match already matched string, folded using unicode semantics for non-utf8 */
-#define        REFFA                   57      /* 0x39 Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define        NREF                    58      /* 0x3a Match some already matched string */
-#define        NREFF                   59      /* 0x3b Match already matched string, folded using native charset semantics for non-utf8 */
-#define        NREFFL                  60      /* 0x3c Match already matched string, folded in loc. */
-#define        NREFFU                  61      /* 0x3d Match already matched string, folded using unicode semantics for non-utf8 */
-#define        NREFFA                  62      /* 0x3e Match already matched string, folded using unicode semantics for non-utf8, no mixing ASCII, non-ASCII */
-#define        IFMATCH                 63      /* 0x3f Succeeds if the following matches. */
-#define        UNLESSM                 64      /* 0x40 Fails if the following matches. */
-#define        SUSPEND                 65      /* 0x41 "Independent" sub-RE. */
-#define        IFTHEN                  66      /* 0x42 Switch, should be preceded by switcher. */
-#define        GROUPP                  67      /* 0x43 Whether the group matched. */
-#define        LONGJMP                 68      /* 0x44 Jump far away. */
-#define        BRANCHJ                 69      /* 0x45 BRANCH with long offset. */
-#define        EVAL                    70      /* 0x46 Execute some Perl code. */
-#define        MINMOD                  71      /* 0x47 Next operator is not greedy. */
-#define        LOGICAL                 72      /* 0x48 Next opcode should set the flag only. */
-#define        RENUM                   73      /* 0x49 Group with independently numbered parens. */
-#define        TRIE                    74      /* 0x4a Match many EXACT(F[ALU]?)? at once. flags==type */
-#define        TRIEC                   75      /* 0x4b Same as TRIE, but with embedded charclass data */
-#define        AHOCORASICK             76      /* 0x4c Aho Corasick stclass. flags==type */
-#define        AHOCORASICKC            77      /* 0x4d Same as AHOCORASICK, but with embedded charclass data */
-#define        GOSUB                   78      /* 0x4e recurse to paren arg1 at (signed) ofs arg2 */
-#define        GOSTART                 79      /* 0x4f recurse to start of pattern */
-#define        NGROUPP                 80      /* 0x50 Whether the group matched. */
-#define        INSUBP                  81      /* 0x51 Whether we are in a specific recurse. */
-#define        DEFINEP                 82      /* 0x52 Never execute directly. */
-#define        ENDLIKE                 83      /* 0x53 Used only for the type field of verbs */
-#define        OPFAIL                  84      /* 0x54 Same as (?!) */
-#define        ACCEPT                  85      /* 0x55 Accepts the current matched string. */
-#define        VERB                    86      /* 0x56 Used only for the type field of verbs */
-#define        PRUNE                   87      /* 0x57 Pattern fails at this startpoint if no-backtracking through this */
-#define        MARKPOINT               88      /* 0x58 Push the current location for rollback by cut. */
-#define        SKIP                    89      /* 0x59 On failure skip forward (to the mark) before retrying */
-#define        COMMIT                  90      /* 0x5a Pattern fails outright if backtracking through this */
-#define        CUTGROUP                91      /* 0x5b On failure go to the next alternation in the group */
-#define        KEEPS                   92      /* 0x5c $& begins here. */
-#define        LNBREAK                 93      /* 0x5d generic newline pattern */
-#define        OPTIMIZED               94      /* 0x5e Placeholder for dump. */
-#define        PSEUDO                  95      /* 0x5f Pseudo opcode for internal use. */
+#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 */
@@ -194,7 +193,6 @@ EXTCONST U8 PL_regkind[] = {
        EXACT,          /* EXACTFU                */
        EXACT,          /* EXACTFA                */
        EXACT,          /* EXACTFU_SS             */
-       EXACT,          /* EXACTFU_TRICKYFOLD     */
        NOTHING,        /* NOTHING                */
        NOTHING,        /* TAIL                   */
        STAR,           /* STAR                   */
@@ -338,7 +336,6 @@ static const U8 regarglen[] = {
        0,                                      /* EXACTFU      */
        0,                                      /* EXACTFA      */
        0,                                      /* EXACTFU_SS   */
-       0,                                      /* EXACTFU_TRICKYFOLD */
        0,                                      /* NOTHING      */
        0,                                      /* TAIL         */
        0,                                      /* STAR         */
@@ -439,7 +436,6 @@ static const char reg_off_by_arg[] = {
        0,      /* EXACTFU      */
        0,      /* EXACTFA      */
        0,      /* EXACTFU_SS   */
-       0,      /* EXACTFU_TRICKYFOLD */
        0,      /* NOTHING      */
        0,      /* TAIL         */
        0,      /* STAR         */
@@ -545,61 +541,60 @@ EXTCONST char * const PL_reg_name[] = {
        "EXACTFU",                      /* 0x26 */
        "EXACTFA",                      /* 0x27 */
        "EXACTFU_SS",                   /* 0x28 */
-       "EXACTFU_TRICKYFOLD",           /* 0x29 */
-       "NOTHING",                      /* 0x2a */
-       "TAIL",                         /* 0x2b */
-       "STAR",                         /* 0x2c */
-       "PLUS",                         /* 0x2d */
-       "CURLY",                        /* 0x2e */
-       "CURLYN",                       /* 0x2f */
-       "CURLYM",                       /* 0x30 */
-       "CURLYX",                       /* 0x31 */
-       "WHILEM",                       /* 0x32 */
-       "OPEN",                         /* 0x33 */
-       "CLOSE",                        /* 0x34 */
-       "REF",                          /* 0x35 */
-       "REFF",                         /* 0x36 */
-       "REFFL",                        /* 0x37 */
-       "REFFU",                        /* 0x38 */
-       "REFFA",                        /* 0x39 */
-       "NREF",                         /* 0x3a */
-       "NREFF",                        /* 0x3b */
-       "NREFFL",                       /* 0x3c */
-       "NREFFU",                       /* 0x3d */
-       "NREFFA",                       /* 0x3e */
-       "IFMATCH",                      /* 0x3f */
-       "UNLESSM",                      /* 0x40 */
-       "SUSPEND",                      /* 0x41 */
-       "IFTHEN",                       /* 0x42 */
-       "GROUPP",                       /* 0x43 */
-       "LONGJMP",                      /* 0x44 */
-       "BRANCHJ",                      /* 0x45 */
-       "EVAL",                         /* 0x46 */
-       "MINMOD",                       /* 0x47 */
-       "LOGICAL",                      /* 0x48 */
-       "RENUM",                        /* 0x49 */
-       "TRIE",                         /* 0x4a */
-       "TRIEC",                        /* 0x4b */
-       "AHOCORASICK",                  /* 0x4c */
-       "AHOCORASICKC",                 /* 0x4d */
-       "GOSUB",                        /* 0x4e */
-       "GOSTART",                      /* 0x4f */
-       "NGROUPP",                      /* 0x50 */
-       "INSUBP",                       /* 0x51 */
-       "DEFINEP",                      /* 0x52 */
-       "ENDLIKE",                      /* 0x53 */
-       "OPFAIL",                       /* 0x54 */
-       "ACCEPT",                       /* 0x55 */
-       "VERB",                         /* 0x56 */
-       "PRUNE",                        /* 0x57 */
-       "MARKPOINT",                    /* 0x58 */
-       "SKIP",                         /* 0x59 */
-       "COMMIT",                       /* 0x5a */
-       "CUTGROUP",                     /* 0x5b */
-       "KEEPS",                        /* 0x5c */
-       "LNBREAK",                      /* 0x5d */
-       "OPTIMIZED",                    /* 0x5e */
-       "PSEUDO",                       /* 0x5f */
+       "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 */
@@ -719,7 +714,7 @@ EXTCONST U8 PL_varies[] __attribute__deprecated__ = {
 EXTCONST U8 PL_varies_bitmask[];
 #else
 EXTCONST U8 PL_varies_bitmask[] = {
-    0x00, 0x00, 0x00, 0x00, 0x07, 0xF0, 0xE7, 0x7F, 0x26, 0x00, 0x00, 0x00
+    0x00, 0x00, 0x00, 0x00, 0x07, 0xF8, 0xF3, 0x3F, 0x13, 0x00, 0x00, 0x00
 };
 #endif /* DOINIT */