This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regcomp.sym Update and improve descriptions of some nodes
authorKarl Williamson <khw@cpan.org>
Sun, 22 Sep 2019 21:09:05 +0000 (15:09 -0600)
committerKarl Williamson <khw@cpan.org>
Fri, 27 Sep 2019 17:20:34 +0000 (11:20 -0600)
EXACTFU nodes always now fold their strings; the information here had
not been updated to reflect that change.

And the descriptions of several EXACTish nodes are now changed to be
slightly shorter and to remove mention of the string length, which is
problematic, and is covered in the description for EXACT

pod/perldebguts.pod
regcomp.sym
regnodes.h

index 002c73f..1e23b84 100644 (file)
@@ -663,25 +663,25 @@ 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 string using /id rules (w/len);
+ EXACTF           str        Like EXACT, but match using /id rules;
                              (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).
-
- EXACTFUP         str        Match this string using /iu rules (w/len);
+ EXACTFL          str        Like EXACT, but match using /il rules;
+                             (string not likely to be folded).
+ EXACTFU          str        Like EXACT, but match using /iu rules;
+                             (string folded).
+ EXACTFAA         str        Like EXACT, but match using /iaa rules;
+                             (string folded iff pattern is UTF8; folded
+                             length <= unfolded).
+
+ EXACTFUP         str        Like EXACT, but match using /iu rules;
                              (string not UTF-8, not guaranteed to be
-                             folded; and its Problematic).
+                             folded; and it is Problematic).
 
- 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)
+ EXACTFLU8        str        Like EXACTFU, but use /il, UTF-8, (string
+                             is folded, and everything in it is above
+                             255.
+ EXACTFAA_NO_TRIE str        Like EXACT, but match using /iaa rules
                              (string not UTF-8, not guaranteed to be
                              folded, not currently trie-able).
 
index 31beb19..8a2fb24 100644 (file)
@@ -118,22 +118,22 @@ BRANCH      BRANCH,     node 0 V  ; Match this alternative, or the next...
 
 EXACT       EXACT,      str       ; Match this string (flags field is the 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 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).
+EXACTF      EXACT,      str       ; Like EXACT, but match using /id rules; (string not UTF-8, not guaranteed to be folded).
+EXACTFL     EXACT,      str       ; Like EXACT, but match using /il rules; (string not likely to be folded).
+EXACTFU     EXACT,      str      ; Like EXACT, but match using /iu rules; (string folded).
+EXACTFAA    EXACT,      str      ; Like EXACT, but match using /iaa rules; (string folded iff pattern is UTF8; folded length <= unfolded).
 
 # End of important relative ordering.
 
-EXACTFUP    EXACT,      str      ; Match this string using /iu rules (w/len); (string not UTF-8, not guaranteed to be folded; and its Problematic).
+EXACTFUP    EXACT,      str      ; Like EXACT, but match using /iu rules; (string not UTF-8, not guaranteed to be folded; and it is Problematic).
 # In order for a non-UTF-8 EXACTFAA to think the pattern is pre-folded when
 # matching a UTF-8 target string, there would have to be something like an
 # EXACTFAA_MICRO which would not be considered pre-folded for UTF-8 targets,
 # since the fold of the MICRO SIGN would not be done, and would be
 # representable in the UTF-8 target string.
 
-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).
+EXACTFLU8   EXACT,      str      ; Like EXACTFU, but use /il, UTF-8, (string is folded, and everything in it is above 255.
+EXACTFAA_NO_TRIE  EXACT, str     ; Like EXACT, but match using /iaa rules (string not UTF-8, not guaranteed to be folded, not currently trie-able).
 
 
 EXACT_ONLY8 EXACT,      str       ; Like EXACT, but only UTF-8 encoded targets can match
index 3b93b85..a1929b8 100644 (file)
 #define        BRANCH                  36      /* 0x24 Match this alternative, or the next... */
 #define        EXACT                   37      /* 0x25 Match this string (flags field is the length). */
 #define        EXACTL                  38      /* 0x26 Like EXACT, but /l is in effect (used so locale-related warnings can be checked for). */
-#define        EXACTF                  39      /* 0x27 Match this string using /id rules (w/len); (string not UTF-8, not guaranteed to be folded). */
-#define        EXACTFL                 40      /* 0x28 Match this string using /il rules (w/len); (string not guaranteed to be folded). */
-#define        EXACTFU                 41      /* 0x29 Match this string using /iu rules (w/len); (string folded iff in UTF-8; non-UTF8 folded length <= unfolded). */
-#define        EXACTFAA                42      /* 0x2a Match this string using /iaa rules (w/len) (string folded iff in UTF-8; non-UTF8 folded length <= unfolded). */
-#define        EXACTFUP                43      /* 0x2b Match this string using /iu rules (w/len); (string not UTF-8, not guaranteed to be folded; and its Problematic). */
-#define        EXACTFLU8               44      /* 0x2c Like EXACTFU, but use /il, UTF-8, folded, and everything in it is above 255. */
-#define        EXACTFAA_NO_TRIE        45      /* 0x2d Match this string using /iaa rules (w/len) (string not UTF-8, not guaranteed to be folded, not currently trie-able). */
+#define        EXACTF                  39      /* 0x27 Like EXACT, but match using /id rules; (string not UTF-8, not guaranteed to be folded). */
+#define        EXACTFL                 40      /* 0x28 Like EXACT, but match using /il rules; (string not likely to be folded). */
+#define        EXACTFU                 41      /* 0x29 Like EXACT, but match using /iu rules; (string folded). */
+#define        EXACTFAA                42      /* 0x2a Like EXACT, but match using /iaa rules; (string folded iff pattern is UTF8; folded length <= unfolded). */
+#define        EXACTFUP                43      /* 0x2b Like EXACT, but match using /iu rules; (string not UTF-8, not guaranteed to be folded; and it is Problematic). */
+#define        EXACTFLU8               44      /* 0x2c Like EXACTFU, but use /il, UTF-8, (string is folded, and everything in it is above 255. */
+#define        EXACTFAA_NO_TRIE        45      /* 0x2d Like EXACT, but match using /iaa rules (string not UTF-8, not guaranteed to be folded, not currently trie-able). */
 #define        EXACT_ONLY8             46      /* 0x2e Like EXACT, but only UTF-8 encoded targets can match */
 #define        EXACTFU_ONLY8           47      /* 0x2f Like EXACTFU, but only UTF-8 encoded targets can match */
 #define        EXACTFU_S_EDGE          48      /* 0x30 /di rules, but nothing in it precludes /ui, except begins and/or ends with [Ss]; (string not UTF-8; compile-time only). */