This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Change name of regnode for clarity
authorKarl Williamson <khw@cpan.org>
Sat, 17 Feb 2018 04:33:24 +0000 (21:33 -0700)
committerKarl Williamson <khw@cpan.org>
Sat, 17 Feb 2018 05:18:14 +0000 (22:18 -0700)
The EXACTFA nodes are in fact not generated by /a, but by /aa.  Change
the name to EXACTFAA to correspond.

I found myself getting confused by this.

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

index b1c01ca..a80f4a1 100644 (file)
@@ -565,67 +565,68 @@ 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.
 
  # Line Start Anchors:
- SBOL            no         Match "" at beginning of line: /^/, /\A/
- MBOL            no         Same, assuming multiline: /^/m
+ SBOL             no         Match "" at beginning of line: /^/, /\A/
+ MBOL             no         Same, assuming multiline: /^/m
 
  # Line End Anchors:
- SEOL            no         Match "" at end of line: /$/
- MEOL            no         Same, assuming multiline: /$/m
- EOS             no         Match "" at end of string: /\z/
+ SEOL             no         Match "" at end of line: /$/
+ MEOL             no         Same, assuming multiline: /$/m
+ EOS              no         Match "" at end of string: /\z/
 
  # Match Start Anchors:
- GPOS            no         Matches where last m//g left off.
+ GPOS             no         Matches where last m//g left off.
 
  # Word Boundary Opcodes:
- BOUND           no         Like BOUNDA for non-utf8, otherwise match ""
-                            between any Unicode \w\W or \W\w
- BOUNDL          no         Like BOUND/BOUNDU, but \w and \W are defined
-                            by current locale
- BOUNDU          no         Match "" at any boundary of a given type
-                            using Unicode rules
- BOUNDA          no         Match "" at any boundary between \w\W or
-                            \W\w, where \w is [_a-zA-Z0-9]
- NBOUND          no         Like NBOUNDA for non-utf8, otherwise match
-                            "" between any Unicode \w\w or \W\W
- NBOUNDL         no         Like NBOUND/NBOUNDU, but \w and \W are
-                            defined by current locale
- NBOUNDU         no         Match "" at any non-boundary of a given type
-                            using using Unicode rules
- NBOUNDA         no         Match "" betweeen any \w\w or \W\W, where \w
-                            is [_a-zA-Z0-9]
+ BOUND            no         Like BOUNDA for non-utf8, otherwise match
+                             "" between any Unicode \w\W or \W\w
+ BOUNDL           no         Like BOUND/BOUNDU, but \w and \W are
+                             defined by current locale
+ BOUNDU           no         Match "" at any boundary of a given type
+                             using Unicode rules
+ BOUNDA           no         Match "" at any boundary between \w\W or
+                             \W\w, where \w is [_a-zA-Z0-9]
+ NBOUND           no         Like NBOUNDA for non-utf8, otherwise match
+                             "" between any Unicode \w\w or \W\W
+ NBOUNDL          no         Like NBOUND/NBOUNDU, but \w and \W are
+                             defined by current locale
+ NBOUNDU          no         Match "" at any non-boundary of a given
+                             type using using Unicode rules
+ NBOUNDA          no         Match "" betweeen any \w\w or \W\W, where
+                             \w is [_a-zA-Z0-9]
 
  # [Special] alternatives:
- REG_ANY         no         Match any one character (except newline).
- SANY            no         Match any one character.
- ANYOF           sv 1       Match character in (or not in) this class,
-                            single char match only
- ANYOFD          sv 1       Like ANYOF, but /d is in effect
- ANYOFL          sv 1       Like ANYOF, but /l is in effect
- ANYOFM          byte 1     Like ANYOF, but matches an invariant byte as
-                            determined by the mask and arg
+ REG_ANY          no         Match any one character (except newline).
+ SANY             no         Match any one character.
+ ANYOF            sv 1       Match character in (or not in) this class,
+                             single char match only
+ ANYOFD           sv 1       Like ANYOF, but /d is in effect
+ ANYOFL           sv 1       Like ANYOF, but /l is in effect
+ ANYOFM           byte 1     Like ANYOF, but matches an invariant byte
+                             as determined by the mask and arg
 
  # POSIX Character Classes:
- 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:]]
-
- ASCII           none       [[:ascii:]]
- NASCII          none       [[:^ascii:]]
-
- CLUMP           no         Match any extended grapheme cluster sequence
+ 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:]]
+
+ ASCII            none       [[:ascii:]]
+ NASCII           none       [[:^ascii:]]
+
+ CLUMP            no         Match any extended grapheme cluster
+                             sequence
 
  # Alternation
 
@@ -638,39 +639,40 @@ 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...
 
  # Literals
 
- EXACT           str        Match this string (preceded by length).
- EXACTL          str        Like EXACT, but /l is in effect (used so
-                            locale-related warnings can be checked for).
- 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).
- EXACTFLU8       str        Rare cirucmstances: like EXACTFU, but is
-                            under /l, UTF-8, folded, and everything in
-                            it is above 255.
- 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).
+ EXACTL           str        Like EXACT, but /l is in effect (used so
+                             locale-related warnings can be checked
+                             for).
+ 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).
+ EXACTFAA         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).
+ EXACTFLU8        str        Rare cirucmstances: like EXACTFU, but is
+                             under /l, UTF-8, folded, and everything in
+                             it is above 255.
+ EXACTFAA_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
 
@@ -679,71 +681,74 @@ 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      Close corresponding OPEN of #n.
- SROPEN          none       Same as OPEN, but for script run
- SRCLOSE         none       Close preceding SROPEN
-
- REF             num 1      Match some already matched string
- REFF            num 1      Match already matched string, folded using
-                            native charset rules for non-utf8
- REFFL           num 1      Match already matched string, folded in loc.
- REFFU           num 1      Match already matched string, folded using
-                            unicode rules for non-utf8
- REFFA           num 1      Match already matched string, folded using
-                            unicode rules for non-utf8, no mixing ASCII,
-                            non-ASCII
+ OPEN             num 1      Mark this point in input as start of #n.
+ CLOSE            num 1      Close corresponding OPEN of #n.
+ SROPEN           none       Same as OPEN, but for script run
+ SRCLOSE          none       Close preceding SROPEN
+
+ REF              num 1      Match some already matched string
+ REFF             num 1      Match already matched string, folded using
+                             native charset rules for non-utf8
+ REFFL            num 1      Match already matched string, folded in
+                             loc.
+ REFFU            num 1      Match already matched string, folded using
+                             unicode rules for non-utf8
+ REFFA            num 1      Match already matched string, folded using
+                             unicode rules 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 rules for non-utf8
- NREFFL          no-sv 1    Match already matched string, folded in loc.
- NREFFU          num 1      Match already matched string, folded using
-                            unicode rules for non-utf8
- NREFFA          num 1      Match already matched string, folded using
-                            unicode rules for non-utf8, no mixing ASCII,
-                            non-ASCII
+ NREF             no-sv 1    Match some already matched string
+ NREFF            no-sv 1    Match already matched string, folded using
+                             native charset rules for non-utf8
+ NREFFL           no-sv 1    Match already matched string, folded in
+                             loc.
+ NREFFU           num 1      Match already matched string, folded using
+                             unicode rules for non-utf8
+ NREFFA           num 1      Match already matched string, folded using
+                             unicode rules for non-utf8, no mixing
+                             ASCII, non-ASCII
 
  # 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.
 
  # Special Case Regops
- 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.
+ 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.
 
  # The heavy worker
 
- EVAL            evl/flags  Execute some Perl code.
-                 2L
+ EVAL             evl/flags  Execute some Perl code.
+                  2L
 
  # 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
 
@@ -751,60 +756,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
+ GOSUB            num/ofs 2L recurse to paren arg1 at (signed) ofs arg2
 
  # 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          no-sv 1    Same as (?!), but with verb arg
- ACCEPT          no-sv/num  Accepts the current matched string, with
-                 2L         verbar
+ ENDLIKE          none       Used only for the type field of verbs
+ OPFAIL           no-sv 1    Same as (?!), but with verb arg
+ ACCEPT           no-sv/num  Accepts the current matched string, with
+                  2L         verbar
 
  # 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 9d19d3e..c08da2f 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -2546,7 +2546,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch,
 
     switch (flags) {
         case EXACT: case EXACTL: break;
-       case EXACTFA:
+       case EXACTFAA:
         case EXACTFU_SS:
        case EXACTFU:
        case EXACTFLU8: folder = PL_fold_latin1; break;
@@ -3762,7 +3762,7 @@ S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *sour
  *      described in the next item.
  * 3)   A problem remains for unfolded multi-char folds. (These occur when the
  *      validity of the fold won't be known until runtime, and so must remain
- *      unfolded for now.  This happens for the sharp s in EXACTF and EXACTFA
+ *      unfolded for now.  This happens for the sharp s in EXACTF and EXACTFAA
  *      nodes when the pattern isn't in UTF-8.  (Note, BTW, that there cannot
  *      be an EXACTF node with a UTF-8 pattern.)  They also occur for various
  *      folds in EXACTFL nodes, regardless of the UTF-ness of the pattern.)
@@ -3772,28 +3772,28 @@ S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *sour
  *      character in the target string.  (And I do mean character, and not byte
  *      here, unlike other parts of the documentation that have never been
  *      updated to account for multibyte Unicode.)  sharp s in EXACTF and
- *      EXACTFL nodes can match the two character string 'ss'; in EXACTFA nodes
- *      it can match "\x{17F}\x{17F}".  These, along with other ones in EXACTFL
- *      nodes, violate the assumption, and they are the only instances where it
- *      is violated.  I'm reluctant to try to change the assumption, as the
- *      code involved is impenetrable to me (khw), so instead the code here
- *      punts.  This routine examines EXACTFL nodes, and (when the pattern
- *      isn't UTF-8) EXACTF and EXACTFA for such unfolded folds, and returns a
+ *      EXACTFL nodes can match the two character string 'ss'; in EXACTFAA
+ *      nodes it can match "\x{17F}\x{17F}".  These, along with other ones in
+ *      EXACTFL nodes, violate the assumption, and they are the only instances
+ *      where it is violated.  I'm reluctant to try to change the assumption,
+ *      as the code involved is impenetrable to me (khw), so instead the code
+ *      here punts.  This routine examines EXACTFL nodes, and (when the pattern
+ *      isn't UTF-8) EXACTF and EXACTFAA for such unfolded folds, and returns a
  *      boolean indicating whether or not the node contains such a fold.  When
  *      it is true, the caller sets a flag that later causes the optimizer in
  *      this file to not set values for the floating and fixed string lengths,
  *      and thus avoids the optimizer code in regexec.c that makes the invalid
  *      assumption.  Thus, there is no optimization based on string lengths for
  *      EXACTFL nodes that contain these few folds, nor for non-UTF8-pattern
- *      EXACTF and EXACTFA nodes that contain the sharp s.  (The reason the
+ *      EXACTF and EXACTFAA nodes that contain the sharp s.  (The reason the
  *      assumption is wrong only in these cases is that all other non-UTF-8
  *      folds are 1-1; and, for UTF-8 patterns, we pre-fold all other folds to
  *      their expanded versions.  (Again, we can't prefold sharp s to 'ss' in
  *      EXACTF nodes because we don't know at compile time if it actually
  *      matches 'ss' or not.  For EXACTF nodes it will match iff the target
  *      string is in UTF-8.  This is in contrast to EXACTFU nodes, where it
- *      always matches; and EXACTFA where it never does.  In an EXACTFA node in
- *      a UTF-8 pattern, sharp s is folded to "\x{17F}\x{17F}, avoiding the
+ *      always matches; and EXACTFAA where it never does.  In an EXACTFAA node
+ *      in a UTF-8 pattern, sharp s is folded to "\x{17F}\x{17F}, avoiding the
  *      problem; but in a non-UTF8 pattern, folding it to that above-Latin1
  *      string would require the pattern to be forced into UTF-8, the overhead
  *      of which we want to avoid.  Similarly the unfolded multi-char folds in
@@ -3802,9 +3802,9 @@ S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *sour
  *
  *      Similarly, the code that generates tries doesn't currently handle
  *      not-already-folded multi-char folds, and it looks like a pain to change
- *      that.  Therefore, trie generation of EXACTFA nodes with the sharp s
- *      doesn't work.  Instead, such an EXACTFA is turned into a new regnode,
- *      EXACTFA_NO_TRIE, which the trie code knows not to handle.  Most people
+ *      that.  Therefore, trie generation of EXACTFAA nodes with the sharp s
+ *      doesn't work.  Instead, such an EXACTFAA is turned into a new regnode,
+ *      EXACTFAA_NO_TRIE, which the trie code knows not to handle.  Most people
  *      using /iaa matching will be doing so almost entirely with ASCII
  *      strings, so this should rarely be encountered in practice */
 
@@ -3984,10 +3984,10 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
                 }
 
                 /* Nodes with 'ss' require special handling, except for
-                 * EXACTFA-ish for which there is no multi-char fold to this */
+                 * EXACTFAA-ish for which there is no multi-char fold to this */
                 if (len == 2 && *s == 's' && *(s+1) == 's'
-                    && OP(scan) != EXACTFA
-                    && OP(scan) != EXACTFA_NO_TRIE)
+                    && OP(scan) != EXACTFAA
+                    && OP(scan) != EXACTFAA_NO_TRIE)
                 {
                     count = 2;
                     if (OP(scan) != EXACTFL) {
@@ -4001,7 +4001,7 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
                     /* Count how many characters are in it.  In the case of
                      * /aa, no folds which contain ASCII code points are
                      * allowed, so check for those, and skip if found. */
-                    if (OP(scan) != EXACTFA && OP(scan) != EXACTFA_NO_TRIE) {
+                    if (OP(scan) != EXACTFAA && OP(scan) != EXACTFAA_NO_TRIE) {
                         count = utf8_length(s, multi_end);
                         s = multi_end;
                     }
@@ -4039,9 +4039,9 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
             *min_subtract += total_count_delta;
             Safefree(folded);
        }
-       else if (OP(scan) == EXACTFA) {
+       else if (OP(scan) == EXACTFAA) {
 
-            /* Non-UTF-8 pattern, EXACTFA node.  There can't be a multi-char
+            /* Non-UTF-8 pattern, EXACTFAA node.  There can't be a multi-char
              * fold to the ASCII range (and there are no existing ones in the
              * upper latin1 range).  But, as outlined in the comments preceding
              * this function, we need to flag any occurrences of the sharp s.
@@ -4052,7 +4052,7 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
                                       || UNICODE_DOT_DOT_VERSION > 0)
            while (s < s_end) {
                 if (*s == LATIN_SMALL_LETTER_SHARP_S) {
-                    OP(scan) = EXACTFA_NO_TRIE;
+                    OP(scan) = EXACTFAA_NO_TRIE;
                     *unfolded_multi_char = TRUE;
                     break;
                 }
@@ -4061,7 +4061,7 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan,
         }
        else {
 
-            /* Non-UTF-8 pattern, not EXACTFA node.  Look for the multi-char
+            /* Non-UTF-8 pattern, not EXACTFAA node.  Look for the multi-char
              * folds that are all Latin1.  As explained in the comments
              * preceding this function, we look also for the sharp s in EXACTF
              * and EXACTFL nodes; it can be in the final position.  Otherwise
@@ -4561,7 +4561,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                                 EXACT           | EXACT
                                 EXACTFU         | EXACTFU
                                 EXACTFU_SS      | EXACTFU
-                                EXACTFA         | EXACTFA
+                                EXACTFAA         | EXACTFAA
                                 EXACTL          | EXACTL
                                 EXACTFLU8       | EXACTFLU8
 
@@ -4573,8 +4573,8 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp,
                          ? EXACT                                            \
                          : ( EXACTFU == (X) || EXACTFU_SS == (X) )          \
                            ? EXACTFU                                        \
-                           : ( EXACTFA == (X) )                             \
-                             ? EXACTFA                                      \
+                           : ( EXACTFAA == (X) )                             \
+                             ? EXACTFAA                                      \
                              : ( EXACTL == (X) )                            \
                                ? EXACTL                                     \
                                : ( EXACTFLU8 == (X) )                        \
@@ -10271,8 +10271,8 @@ S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
             /* Some characters match above-Latin1 ones under /i.  This
              * is true of EXACTFL ones when the locale is UTF-8 */
             if (HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE(uc)
-                && (! isASCII(uc) || (OP(node) != EXACTFA
-                                    && OP(node) != EXACTFA_NO_TRIE)))
+                && (! isASCII(uc) || (OP(node) != EXACTFAA
+                                    && OP(node) != EXACTFAA_NO_TRIE)))
             {
                 add_above_Latin1_folds(pRExC_state, (U8) uc, &invlist);
             }
@@ -10352,7 +10352,7 @@ S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
                     c = SvUV(*c_p);
 
                     /* /aa doesn't allow folds between ASCII and non- */
-                    if ((OP(node) == EXACTFA || OP(node) == EXACTFA_NO_TRIE)
+                    if ((OP(node) == EXACTFAA || OP(node) == EXACTFAA_NO_TRIE)
                         && isASCII(c) != isASCII(uc))
                     {
                         continue;
@@ -19163,8 +19163,8 @@ S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p,
                 case EXACT:
                 case EXACTL:
                 case EXACTF:
-                case EXACTFA_NO_TRIE:
-                case EXACTFA:
+                case EXACTFAA_NO_TRIE:
+                case EXACTFAA:
                 case EXACTFU:
                 case EXACTFLU8:
                 case EXACTFU_SS:
index 14840b5..96fe46e 100644 (file)
@@ -99,13 +99,13 @@ EXACTL      EXACT,      str       ; Like EXACT, but /l is in effect (used so loc
 EXACTF      EXACT,      str       ; Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len).
 EXACTFL     EXACT,      str       ; Match this string (not guaranteed to be folded) using /il rules (w/len).
 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).
+EXACTFAA    EXACT,      str      ; Match this string (not guaranteed to be folded) using /iaa rules (w/len).
 
 # End of important relative ordering.
 
 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).
 EXACTFLU8   EXACT,      str      ; Rare cirucmstances: like EXACTFU, but is under /l, UTF-8, folded, and everything in it is above 255.
-EXACTFA_NO_TRIE  EXACT, str      ; Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len).
+EXACTFAA_NO_TRIE  EXACT, str     ; Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len).
 
 #*Do nothing types
 
index cd83715..1cda2e8 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -238,13 +238,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.  XXX These are now out-of-sync*/
 #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)==EXACTFA || OP(rn)==EXACTFA_NO_TRIE || OP(rn)==EXACTF || OP(rn)==REFF  || OP(rn)==NREFF )
+#define IS_TEXTF(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFU_SS || OP(rn)==EXACTFAA || OP(rn)==EXACTFAA_NO_TRIE || 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 || OP(rn)==EXACTL )
-#define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFLU8 || OP(rn)==EXACTFU_SS || OP(rn) == EXACTFA || OP(rn) == EXACTFA_NO_TRIE)
+#define IS_TEXTFU(rn)  ( OP(rn)==EXACTFU || OP(rn)==EXACTFLU8 || OP(rn)==EXACTFU_SS || OP(rn) == EXACTFAA || OP(rn) == EXACTFAA_NO_TRIE)
 #define IS_TEXTF(rn)  ( OP(rn)==EXACTF  )
 #define IS_TEXTFL(rn) ( OP(rn)==EXACTFL )
 
@@ -1812,7 +1812,7 @@ Perl_re_intuit_start(pTHX_
                                  ? (utf8_target ? trie_utf8 : trie_plain)           \
                                  : (scan->flags == EXACTL)                          \
                                     ? (utf8_target ? trie_utf8l : trie_plain)       \
-                                    : (scan->flags == EXACTFA                     \
+                                    : (scan->flags == EXACTFAA)                     \
                                       ? (utf8_target                                \
                                          ? trie_utf8_exactfa_fold                   \
                                          : trie_latin_utf8_exactfa_fold)            \
@@ -2253,10 +2253,10 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
                                  find_next_masked(s, strend, ARG(c), FLAGS(c)));
         break;
 
-    case EXACTFA_NO_TRIE:   /* This node only generated for non-utf8 patterns */
+    case EXACTFAA_NO_TRIE: /* This node only generated for non-utf8 patterns */
         assert(! is_utf8_pat);
        /* FALLTHROUGH */
-    case EXACTFA:
+    case EXACTFAA:
         if (is_utf8_pat || utf8_target) {
             utf8_fold_flags = FOLDEQ_UTF8_NOMIX_ASCII;
             goto do_exactf_utf8;
@@ -4621,7 +4621,7 @@ S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
                         c2 = SvUV(*c_p);
 
                         /* Folds that cross the 255/256 boundary are forbidden
-                         * if EXACTFL (and isnt a UTF8 locale), or EXACTFA and
+                         * if EXACTFL (and isnt a UTF8 locale), or EXACTFAA and
                          * one is ASCIII.  Since the pattern character is above
                          * 255, and its only other match is below 256, the only
                          * legal match will be to itself.  We have thrown away
@@ -4630,8 +4630,8 @@ S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
                         if ((c1 < 256) != (c2 < 256)) {
                             if ((OP(text_node) == EXACTFL
                                  && ! IN_UTF8_CTYPE_LOCALE)
-                                || ((OP(text_node) == EXACTFA
-                                    || OP(text_node) == EXACTFA_NO_TRIE)
+                                || ((OP(text_node) == EXACTFAA
+                                    || OP(text_node) == EXACTFAA_NO_TRIE)
                                     && (isASCII(c1) || isASCII(c2))))
                             {
                                 if (c1 < 256) {
@@ -4649,8 +4649,8 @@ S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
                 if (utf8_target
                     && HAS_NONLATIN1_FOLD_CLOSURE(c1)
                     && ( ! (OP(text_node) == EXACTFL && ! IN_UTF8_CTYPE_LOCALE))
-                    && ((OP(text_node) != EXACTFA
-                        && OP(text_node) != EXACTFA_NO_TRIE)
+                    && ((OP(text_node) != EXACTFAA
+                        && OP(text_node) != EXACTFAA_NO_TRIE)
                         || ! isASCII(c1)))
             {
                 /* Here, there could be something above Latin1 in the target
@@ -4682,12 +4682,12 @@ S_setup_EXACTISH_ST_c1_c2(pTHX_ const regnode * const text_node, int *c1p,
                         }
                         /* FALLTHROUGH */
                         /* /u rules for all these.  This happens to work for
-                        * EXACTFA as nothing in Latin1 folds to ASCII */
-                    case EXACTFA_NO_TRIE:   /* This node only generated for
-                                            non-utf8 patterns */
+                        * EXACTFAA as nothing in Latin1 folds to ASCII */
+                    case EXACTFAA_NO_TRIE:   /* This node only generated for
+                                                non-utf8 patterns */
                         assert(! is_utf8_pat);
                         /* FALLTHROUGH */
-                    case EXACTFA:
+                    case EXACTFAA:
                     case EXACTFU_SS:
                     case EXACTFU:
                         c2 = PL_fold_latin1[c1];
@@ -6418,11 +6418,11 @@ S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
            fold_utf8_flags = is_utf8_pat ? FOLDEQ_S1_ALREADY_FOLDED : 0;
            goto do_exactf;
 
-        case EXACTFA_NO_TRIE:   /* This node only generated for non-utf8
+        case EXACTFAA_NO_TRIE:   /* This node only generated for non-utf8
                                    patterns */
             assert(! is_utf8_pat);
             /* FALLTHROUGH */
-       case EXACTFA:            /*  /abc/iaa     */
+       case EXACTFAA:            /*  /abc/iaa     */
            folder = foldEQ_latin1;
            fold_array = PL_fold_latin1;
            fold_utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
@@ -9331,10 +9331,10 @@ S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p,
        }
        break;
 
-    case EXACTFA_NO_TRIE:   /* This node only generated for non-utf8 patterns */
+    case EXACTFAA_NO_TRIE: /* This node only generated for non-utf8 patterns */
         assert(! reginfo->is_utf8_pat);
         /* FALLTHROUGH */
-    case EXACTFA:
+    case EXACTFAA:
         utf8_flags = FOLDEQ_UTF8_NOMIX_ASCII;
        goto do_exactf;
 
index 855a215..185c842 100644 (file)
 #define        EXACTF                  36      /* 0x24 Match this non-UTF-8 string (not guaranteed to be folded) using /id rules (w/len). */
 #define        EXACTFL                 37      /* 0x25 Match this string (not guaranteed to be folded) using /il rules (w/len). */
 #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        EXACTFAA                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        EXACTFLU8               41      /* 0x29 Rare cirucmstances: like EXACTFU, but is under /l, UTF-8, folded, and everything in it is above 255. */
-#define        EXACTFA_NO_TRIE         42      /* 0x2a Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
+#define        EXACTFAA_NO_TRIE        42      /* 0x2a Match this string (which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). */
 #define        NOTHING                 43      /* 0x2b Match empty string. */
 #define        TAIL                    44      /* 0x2c Match empty string. Can jump here from outside. */
 #define        STAR                    45      /* 0x2d Match this (simple) thing 0 or more times. */
@@ -198,10 +198,10 @@ EXTCONST U8 PL_regkind[] = {
        EXACT,          /* EXACTF                 */
        EXACT,          /* EXACTFL                */
        EXACT,          /* EXACTFU                */
-       EXACT,          /* EXACTFA                */
+       EXACT,          /* EXACTFAA               */
        EXACT,          /* EXACTFU_SS             */
        EXACT,          /* EXACTFLU8              */
-       EXACT,          /* EXACTFA_NO_TRIE        */
+       EXACT,          /* EXACTFAA_NO_TRIE       */
        NOTHING,        /* NOTHING                */
        NOTHING,        /* TAIL                   */
        STAR,           /* STAR                   */
@@ -347,10 +347,10 @@ static const U8 regarglen[] = {
        0,                                      /* EXACTF       */
        0,                                      /* EXACTFL      */
        0,                                      /* EXACTFU      */
-       0,                                      /* EXACTFA      */
+       0,                                      /* EXACTFAA     */
        0,                                      /* EXACTFU_SS   */
        0,                                      /* EXACTFLU8    */
-       0,                                      /* EXACTFA_NO_TRIE */
+       0,                                      /* EXACTFAA_NO_TRIE */
        0,                                      /* NOTHING      */
        0,                                      /* TAIL         */
        0,                                      /* STAR         */
@@ -450,10 +450,10 @@ static const char reg_off_by_arg[] = {
        0,      /* EXACTF       */
        0,      /* EXACTFL      */
        0,      /* EXACTFU      */
-       0,      /* EXACTFA      */
+       0,      /* EXACTFAA     */
        0,      /* EXACTFU_SS   */
        0,      /* EXACTFLU8    */
-       0,      /* EXACTFA_NO_TRIE */
+       0,      /* EXACTFAA_NO_TRIE */
        0,      /* NOTHING      */
        0,      /* TAIL         */
        0,      /* STAR         */
@@ -559,10 +559,10 @@ EXTCONST char * const PL_reg_name[] = {
        "EXACTF",                       /* 0x24 */
        "EXACTFL",                      /* 0x25 */
        "EXACTFU",                      /* 0x26 */
-       "EXACTFA",                      /* 0x27 */
+       "EXACTFAA",                     /* 0x27 */
        "EXACTFU_SS",                   /* 0x28 */
        "EXACTFLU8",                    /* 0x29 */
-       "EXACTFA_NO_TRIE",              /* 0x2a */
+       "EXACTFAA_NO_TRIE",             /* 0x2a */
        "NOTHING",                      /* 0x2b */
        "TAIL",                         /* 0x2c */
        "STAR",                         /* 0x2d */