regen/regcharclass.pl: Change name of generated macro

This changes the macro isMULTI_CHAR_FOLD() (non-utf8 version) from just
generating ascii-range code points to generating the full Latin1 range.
However there are no such non-ASCII values, so the macro expansion is
unchanged.  By changing the name, it becomes clearer in future commits
that we aren't excluding things that we should be considering.

diff --git a/regcharclass.h b/regcharclass.h
index 37f57ba..b631cd1 100644 (file)
--- a/regcharclass.h
+++ b/regcharclass.h
@@ -694,12 +694,12 @@
 : 0 )
 
 /*
-       MULTI_CHAR_FOLD: multi-char ascii strings that are folded to by a single character
+       MULTI_CHAR_FOLD: multi-char strings that are folded to by a single character
 
        &regcharclass_multi_char_folds::multi_char_folds(0)
 */
 /*** GENERATED CODE ***/
-#define is_MULTI_CHAR_FOLD_low_safe(s,e)                                    \
+#define is_MULTI_CHAR_FOLD_latin1_safe(s,e)                                 \
 ( ((e)-(s) > 2) ?                                                           \
     ( ( ( ((U8*)s)[0] & 0xDF ) == 0x46 ) ?                                  \
        ( ( ( ((U8*)s)[1] & 0xDF ) == 0x46 ) ?                              \

diff --git a/regcomp.c b/regcomp.c
index bf2be2d..4e42b52 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -2883,7 +2883,7 @@ S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, b
             const U8 s_masked = 's' & S_or_s_mask;
 
            while (s < upper) {
-                int len = is_MULTI_CHAR_FOLD_low_safe(s, s_end);
+                int len = is_MULTI_CHAR_FOLD_latin1_safe(s, s_end);
                 if (! len) {    /* Not a multi-char fold. */
                     if (*s == LATIN_SMALL_LETTER_SHARP_S && OP(scan) == EXACTF)
                     {

diff --git a/regen/regcharclass.pl b/regen/regcharclass.pl
index 37a8682..461192b 100755 (executable)
--- a/regen/regcharclass.pl
+++ b/regen/regcharclass.pl
@@ -1253,8 +1253,8 @@ do regen/regcharclass_multi_char_folds.pl
 # 1 => All folds
 &regcharclass_multi_char_folds::multi_char_folds(1)
 
-MULTI_CHAR_FOLD: multi-char ascii strings that are folded to by a single character
-=> low : safe
+MULTI_CHAR_FOLD: multi-char strings that are folded to by a single character
+=> LATIN1 :safe
 
-# 0 => ASCII-only
 &regcharclass_multi_char_folds::multi_char_folds(0)
+# 0 => Latin1-only

diff --git a/regen/regcharclass_multi_char_folds.pl b/regen/regcharclass_multi_char_folds.pl
index ce2d781..f0fd6b3 100644 (file)
--- a/regen/regcharclass_multi_char_folds.pl
+++ b/regen/regcharclass_multi_char_folds.pl
@@ -9,15 +9,19 @@ use Unicode::UCD "prop_invmap";
 # of the sequences of code points that are multi-character folds in the
 # current Unicode version.  If the parameter is 1, all such folds are
 # returned.  If the parameters is 0, only the ones containing exclusively
-# ASCII characters are returned.  In the latter case all combinations of ASCII
-# characters that can fold to the base one are returned.  Thus for 'ss', it
-# would return in addition, 'Ss', 'sS', and 'SS'.  This is because this code
-# is designed to help regcomp.c, and EXACTFish regnodes.  For non-UTF-8
-# patterns, the strings are not folded, so we need to check for the upper and
-# lower case versions.  For UTF-8 patterns, the strings are folded, so we only
-# need to worry about the fold version.  There are no non-ASCII Latin1
-# multi-char folds currently, and none likely to be ever added, so this
-# doesn't worry about that case, except to croak should it happen.
+# Latin1 characters are returned.  In the latter case all combinations of
+# Latin1 characters that can fold to the base one are returned.  Thus for
+# 'ss', it would return in addition, 'Ss', 'sS', and 'SS'.  This is because
+# this code is designed to help regcomp.c, and EXACTFish regnodes.  For
+# non-UTF-8 patterns, the strings are not folded, so we need to check for the
+# upper and lower case versions.  For UTF-8 patterns, the strings are folded,
+# so we only need to worry about the fold version.  There are no non-ASCII
+# Latin1 multi-char folds currently, and none likely to be ever added.  Thus
+# the output is the same as if it were just asking for ASCII characters, not
+# full Latin1.  Hence, it is suitable for generating things that match
+# EXACTFA.  It does check for and croak if there ever were to be an upper
+# Latin1 range multi-character fold.
+#
 # This is designed for input to regen/regcharlass.pl.
 
 sub gen_combinations ($;) {