In perl.git, the branch blead has been updated

<https://perl5.git.perl.org/perl.git/commitdiff/4f4c2c242927ac05bf7ded20acfc757c13fb39c0?hp=79a1fabd70e45bd58552df04d427f86fd6533356>

- Log -----------------------------------------------------------------
commit 4f4c2c242927ac05bf7ded20acfc757c13fb39c0
Author: Karl Williamson <k...@cpan.org>
Date:   Tue Dec 4 17:59:31 2018 -0700

    regcomp.sym: Clarify descriptions of EXACTish regnodes

-----------------------------------------------------------------------

Summary of changes:
 pod/perldebguts.pod | 49 +++++++++++++++++++++++++------------------------
 regcomp.sym         | 19 ++++++++++---------
 regnodes.h          | 18 +++++++++---------
 3 files changed, 44 insertions(+), 42 deletions(-)

diff --git a/pod/perldebguts.pod b/pod/perldebguts.pod
index 191c875aa2..a826d9d237 100644
--- a/pod/perldebguts.pod
+++ b/pod/perldebguts.pod
@@ -654,30 +654,31 @@ will be lost.
  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 circumstances: 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).
-
- EXACT_ONLY8      str        Like EXACT, but no strings that aren't in
-                             UTF-8 can match
- EXACTFU_ONLY8    str        Like EXACTFU, but no strings that aren't in
-                             UTF-8 can match
+ EXACTF           str        Match this string using /id rules (w/len);
+                             (string not UTF-8, not guaranteed to be
+                             folded).
+ EXACTFL          str        Match this string using /il rules (w/len);
+                             (string not guaranteed to be folded).
+ EXACTFU          str        Match this string using /iu rules (w/len);
+                             (string folded iff in UTF-8; non-UTF8
+                             folded length <= unfolded).
+ EXACTFAA         str        Match this string using /iaa rules (w/len)
+                             (string folded iff in UTF-8; non-UTF8
+                             folded length <= unfolded).
+
+ EXACTFU_SS       str        Match this string using /iu rules (w/len);
+                             (string folded iff in UTF-8; non-UTF8
+                             folded length > unfolded).
+ EXACTFLU8        str        Like EXACTFU, but use /il, UTF-8, folded,
+                             and everything in it is above 255.
+ EXACTFAA_NO_TRIE str        Match this string using /iaa rules (w/len)
+                             (string not UTF-8, not guaranteed to be
+                             folded, not currently trie-able).
+
+ EXACT_ONLY8      str        Like EXACT, but only UTF-8 encoded targets
+                             can match
+ EXACTFU_ONLY8    str        Like EXACTFU, but only UTF-8 encoded
+                             targets can match
 
  # Do nothing types
 
diff --git a/regcomp.sym b/regcomp.sym
index f5450786c4..dffc03b1a0 100644
--- a/regcomp.sym
+++ b/regcomp.sym
@@ -100,19 +100,20 @@ BRANCH      BRANCH,     node 0 V  ; Match this 
alternative, or the next...
 
 EXACT       EXACT,      str       ; Match this string (preceded by length).
 EXACTL      EXACT,      str       ; Like EXACT, but /l is in effect (used so 
locale-related warnings can be checked for).
-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).
-EXACTFAA    EXACT,      str      ; Match this string (not guaranteed to be 
folded) using /iaa rules (w/len).
+EXACTF      EXACT,      str       ; Match this string using /id rules (w/len); 
(string not UTF-8, not guaranteed to be folded).
+EXACTFL     EXACT,      str       ; Match this string using /il rules (w/len); 
(string not guaranteed to be folded).
+EXACTFU     EXACT,      str      ; Match this string using /iu rules (w/len); 
(string folded iff in UTF-8; non-UTF8 folded length <= unfolded).
+EXACTFAA    EXACT,      str      ; Match this string using /iaa rules (w/len) 
(string folded iff in UTF-8; non-UTF8 folded length <= unfolded).
 
 # 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 circumstances: like EXACTFU, but is 
under /l, UTF-8, folded, and everything in it is above 255.
-EXACTFAA_NO_TRIE  EXACT, str     ; Match this string (which is not trie-able; 
not guaranteed to be folded) using /iaa rules (w/len).
+EXACTFU_SS  EXACT,      str      ; Match this string using /iu rules (w/len); 
(string folded iff in UTF-8; non-UTF8 folded length > unfolded).
+EXACTFLU8   EXACT,      str      ; Like EXACTFU, but use /il, UTF-8, folded, 
and everything in it is above 255.
+EXACTFAA_NO_TRIE  EXACT, str     ; Match this string using /iaa rules (w/len) 
(string not UTF-8, not guaranteed to be folded, not currently trie-able).
 
-EXACT_ONLY8 EXACT,      str       ; Like EXACT, but no strings that aren't in 
UTF-8 can match
-EXACTFU_ONLY8 EXACT,    str       ; Like EXACTFU, but no strings that aren't 
in UTF-8 can match
+
+EXACT_ONLY8 EXACT,      str       ; Like EXACT, but only UTF-8 encoded targets 
can match
+EXACTFU_ONLY8 EXACT,    str       ; Like EXACTFU, but only UTF-8 encoded 
targets can match
 # One could add EXACTFAA8 and and something that has the same effect for /l,
 # but these would be extremely uncommon
 
diff --git a/regnodes.h b/regnodes.h
index 9cddfd3f49..7c12d1f4d9 100644
--- a/regnodes.h
+++ b/regnodes.h
@@ -49,15 +49,15 @@
 #define        BRANCH                  35      /* 0x23 Match this alternative, 
or the next... */
 #define        EXACT                   36      /* 0x24 Match this string 
(preceded by length). */
 #define        EXACTL                  37      /* 0x25 Like EXACT, but /l is 
in effect (used so locale-related warnings can be checked for). */
-#define        EXACTF                  38      /* 0x26 Match this non-UTF-8 
string (not guaranteed to be folded) using /id rules (w/len). */
-#define        EXACTFL                 39      /* 0x27 Match this string (not 
guaranteed to be folded) using /il rules (w/len). */
-#define        EXACTFU                 40      /* 0x28 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        EXACTFAA                41      /* 0x29 Match this string (not 
guaranteed to be folded) using /iaa rules (w/len). */
-#define        EXACTFU_SS              42      /* 0x2a 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               43      /* 0x2b Rare circumstances: 
like EXACTFU, but is under /l, UTF-8, folded, and everything in it is above 
255. */
-#define        EXACTFAA_NO_TRIE        44      /* 0x2c Match this string 
(which is not trie-able; not guaranteed to be folded) using /iaa rules (w/len). 
*/
-#define        EXACT_ONLY8             45      /* 0x2d Like EXACT, but no 
strings that aren't in UTF-8 can match */
-#define        EXACTFU_ONLY8           46      /* 0x2e Like EXACTFU, but no 
strings that aren't in UTF-8 can match */
+#define        EXACTF                  38      /* 0x26 Match this string using 
/id rules (w/len); (string not UTF-8, not guaranteed to be folded). */
+#define        EXACTFL                 39      /* 0x27 Match this string using 
/il rules (w/len); (string not guaranteed to be folded). */
+#define        EXACTFU                 40      /* 0x28 Match this string using 
/iu rules (w/len); (string folded iff in UTF-8; non-UTF8 folded length <= 
unfolded). */
+#define        EXACTFAA                41      /* 0x29 Match this string using 
/iaa rules (w/len) (string folded iff in UTF-8; non-UTF8 folded length <= 
unfolded). */
+#define        EXACTFU_SS              42      /* 0x2a Match this string using 
/iu rules (w/len); (string folded iff in UTF-8; non-UTF8 folded length > 
unfolded). */
+#define        EXACTFLU8               43      /* 0x2b Like EXACTFU, but use 
/il, UTF-8, folded, and everything in it is above 255. */
+#define        EXACTFAA_NO_TRIE        44      /* 0x2c Match this string using 
/iaa rules (w/len) (string not UTF-8, not guaranteed to be folded, not 
currently trie-able). */
+#define        EXACT_ONLY8             45      /* 0x2d Like EXACT, but only 
UTF-8 encoded targets can match */
+#define        EXACTFU_ONLY8           46      /* 0x2e Like EXACTFU, but only 
UTF-8 encoded targets can match */
 #define        NOTHING                 47      /* 0x2f Match empty string. */
 #define        TAIL                    48      /* 0x30 Match empty string. Can 
jump here from outside. */
 #define        STAR                    49      /* 0x31 Match this (simple) 
thing 0 or more times. */

-- 
Perl5 Master Repository

Reply via email to