develooper Front page | perl.perl5.changes | Postings from September 2019

[perl.git] branch blead updated. v5.31.4-270-g059703b088

From:
Karl Williamson
Date:
September 29, 2019 22:15
Subject:
[perl.git] branch blead updated. v5.31.4-270-g059703b088
Message ID:
E1iEhTC-0005s4-2u@git.dc.perl.space
In perl.git, the branch blead has been updated

<https://perl5.git.perl.org/perl.git/commitdiff/059703b088f44d5665f67fba0b9d80cad89085fd?hp=830b3eb245d5dbcf095fbd4b5d59764c697c20df>

- Log -----------------------------------------------------------------
commit 059703b088f44d5665f67fba0b9d80cad89085fd
Author: Karl Williamson <khw@cpan.org>
Date:   Sun Sep 29 15:16:24 2019 -0600

    Remove deprecated character classification/case changing macros
    
    It has been deprecated since 5.26 to use various macros that deal with
    UTF-8 inputs but don't have a parameter indicating the maximum length
    beyond which we should not look.  This commit changes all such macros,
    as threatened in existing documentation and warning messages, to have an
    extra parameter giving the length.
    
    This was originally scheduled to happen in 5.30, but was delayed because
    it broke some CPAN modules, and there wasn't really a good way around
    it.  But now that Devel::PPPort 3.54 is out, ppport.h has new facilities
    for getting modules making these changes to work with older Perl
    releases.

commit c81b356276ad1b4b6fb656acd9ab9b8797afd694
Author: Karl Williamson <khw@cpan.org>
Date:   Sun May 20 13:11:02 2018 -0600

    APItest: Remove use of macros about to be removed
    
    The next commit removes some macros that this uses.  They have been
    deprecated, and the uses here were to test those deprecations.

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

Summary of changes:
 embed.fnc                      |  53 +-----
 embed.h                        |  85 +--------
 ext/XS-APItest/APItest.xs      | 166 ++++++++----------
 ext/XS-APItest/t/handy_base.pl |   5 -
 handy.h                        | 388 ++++++++++++++++-------------------------
 mathoms.c                      | 305 --------------------------------
 pod/perldelta.pod              |   8 +
 pod/perldeprecation.pod        |  21 ++-
 proto.h                        | 246 ++------------------------
 utf8.c                         | 217 +----------------------
 utf8.h                         |   9 -
 11 files changed, 282 insertions(+), 1221 deletions(-)

diff --git a/embed.fnc b/embed.fnc
index 8c346c5eab..bd71550518 100644
--- a/embed.fnc
+++ b/embed.fnc
@@ -1004,8 +1004,6 @@ CbDpR	|bool	|is_uni_punct	|UV c
 CbDpPR	|bool	|is_uni_xdigit	|UV c
 Cp	|UV	|to_uni_upper	|UV c|NN U8 *p|NN STRLEN *lenp
 Cp	|UV	|to_uni_title	|UV c|NN U8 *p|NN STRLEN *lenp
-CbDpR	|bool	|isIDFIRST_lazy	|NN const char* p
-CbDpR	|bool	|isALNUM_lazy	|NN const char* p
 p	|void	|init_uniprops
 #ifdef PERL_IN_UTF8_C
 STR	|U8	|to_lower_latin1|const U8 c|NULLOK U8 *p|NULLOK STRLEN *lenp  \
@@ -1107,17 +1105,8 @@ AmTdP	|bool	|is_utf8_valid_partial_char				    \
 ATidRp	|bool	|is_utf8_valid_partial_char_flags			    \
 		|NN const U8 * const s|NN const U8 * const e|const U32 flags
 CpR	|bool	|_is_uni_FOO|const U8 classnum|const UV c
-CpR	|bool	|_is_utf8_FOO|U8 classnum|NN const U8 * const p		    \
-		|NN const char * const name				    \
-		|NN const char * const alternative			    \
-		|const bool use_utf8|const bool use_locale		    \
-		|NN const char * const file|const unsigned line
 CpR	|bool	|_is_utf8_FOO_with_len|const U8 classnum|NN const U8 *p	    \
 		|NN const U8 * const e
-CbDpR	|bool	|is_utf8_alnum	|NN const U8 *p
-CbDpR	|bool	|is_utf8_alnumc	|NN const U8 *p
-CbDpR	|bool	|is_utf8_idfirst|NN const U8 *p
-CbDpR	|bool	|is_utf8_xidfirst|NN const U8 *p
 CpR	|bool	|_is_utf8_idcont|NN const U8 *p
 CpR	|bool	|_is_utf8_idstart|NN const U8 *p
 CpR	|bool	|_is_utf8_xidcont|NN const U8 *p
@@ -1126,23 +1115,6 @@ CpR	|bool	|_is_utf8_perl_idcont_with_len|NN const U8 *p		    \
 		|NN const U8 * const e
 CpR	|bool	|_is_utf8_perl_idstart_with_len|NN const U8 *p		    \
 		|NN const U8 * const e
-CbDpR	|bool	|is_utf8_idcont	|NN const U8 *p
-CbDpR	|bool	|is_utf8_xidcont	|NN const U8 *p
-CbDpR	|bool	|is_utf8_alpha	|NN const U8 *p
-CbDpR	|bool	|is_utf8_ascii	|NN const U8 *p
-CbDpR	|bool	|is_utf8_blank	|NN const U8 *p
-CbDpR	|bool	|is_utf8_space	|NN const U8 *p
-CbDpR	|bool	|is_utf8_perl_space	|NN const U8 *p
-CbDpR	|bool	|is_utf8_perl_word	|NN const U8 *p
-CbDpR	|bool	|is_utf8_cntrl	|NN const U8 *p
-CbDpR	|bool	|is_utf8_digit	|NN const U8 *p
-CbDpR	|bool	|is_utf8_posix_digit	|NN const U8 *p
-CbDpR	|bool	|is_utf8_graph	|NN const U8 *p
-CbDpR	|bool	|is_utf8_upper	|NN const U8 *p
-CbDpR	|bool	|is_utf8_lower	|NN const U8 *p
-CbDpR	|bool	|is_utf8_print	|NN const U8 *p
-CbDpR	|bool	|is_utf8_punct	|NN const U8 *p
-CbDpR	|bool	|is_utf8_xdigit	|NN const U8 *p
 CpR	|bool	|_is_utf8_mark	|NN const U8 *p
 AbDxpR	|bool	|is_utf8_mark	|NN const U8 *p
 #if defined(PERL_CORE) || defined(PERL_EXT)
@@ -2024,19 +1996,14 @@ SR	|char *	|unexpected_non_continuation_text			\
 		|STRLEN print_len					\
 		|const STRLEN non_cont_byte_pos				\
 		|const STRLEN expect_len
+#if 0	/* Not currently used, but may be needed in the future */
 S	|void	|warn_on_first_deprecated_use				    \
 				|NN const char * const name		    \
 				|NN const char * const alternative	    \
 				|const bool use_locale			    \
 				|NN const char * const file		    \
 				|const unsigned line
-S	|U32	|check_and_deprecate					    \
-				|NN const U8 * p			    \
-				|NN const U8 ** e			    \
-				|const unsigned type			    \
-				|const bool use_locale			    \
-				|NN const char * const file		    \
-				|const unsigned line
+#endif
 S	|UV	|_to_utf8_case  |const UV uv1					\
 				|NULLOK const U8 *p				\
 				|NN U8* ustrp					\
@@ -2050,22 +2017,14 @@ S	|UV	|turkic_fc	|NN const U8 * const p |NN const U8 * const e|NN U8* ustrp|NN S
 S	|UV	|turkic_lc	|NN const U8 * const p0|NN const U8 * const e|NN U8* ustrp|NN STRLEN *lenp
 S	|UV	|turkic_uc	|NN const U8 * const p |NN const U8 * const e|NN U8* ustrp|NN STRLEN *lenp
 #endif
-ApbMdD	|UV	|to_utf8_lower	|NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
 Cp	|UV	|_to_utf8_lower_flags|NN const U8 *p|NULLOK const U8* e		\
-				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags	\
-				|NN const char * const file|const int line
-ApbMdD	|UV	|to_utf8_upper	|NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
+				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags
 Cp	|UV	|_to_utf8_upper_flags	|NN const U8 *p|NULLOK const U8 *e	\
-				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags	\
-				|NN const char * const file|const int line
-ApbMdD	|UV	|to_utf8_title	|NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
+				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags
 Cp	|UV	|_to_utf8_title_flags	|NN const U8 *p|NULLOK const U8* e	\
-				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags	\
-				|NN const char * const file|const int line
-ApbMdD	|UV	|to_utf8_fold	|NN const U8 *p|NN U8* ustrp|NULLOK STRLEN *lenp
+				|NN U8* ustrp|NULLOK STRLEN *lenp|bool flags
 Cp	|UV	|_to_utf8_fold_flags|NN const U8 *p|NULLOK const U8 *e		\
-				|NN U8* ustrp|NULLOK STRLEN *lenp|U8 flags  \
-				|NN const char * const file|const int line
+				|NN U8* ustrp|NULLOK STRLEN *lenp|U8 flags
 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
 pT	|bool	|translate_substr_offsets|STRLEN curlen|IV pos1_iv \
 					 |bool pos1_is_uv|IV len_iv \
diff --git a/embed.h b/embed.h
index 53dd870983..b19ec308bf 100644
--- a/embed.h
+++ b/embed.h
@@ -33,7 +33,6 @@
 #define _is_uni_FOO(a,b)	Perl__is_uni_FOO(aTHX_ a,b)
 #define _is_uni_perl_idcont(a)	Perl__is_uni_perl_idcont(aTHX_ a)
 #define _is_uni_perl_idstart(a)	Perl__is_uni_perl_idstart(aTHX_ a)
-#define _is_utf8_FOO(a,b,c,d,e,f,g,h)	Perl__is_utf8_FOO(aTHX_ a,b,c,d,e,f,g,h)
 #define _is_utf8_FOO_with_len(a,b,c)	Perl__is_utf8_FOO_with_len(aTHX_ a,b,c)
 #define _is_utf8_idcont(a)	Perl__is_utf8_idcont(aTHX_ a)
 #define _is_utf8_idstart(a)	Perl__is_utf8_idstart(aTHX_ a)
@@ -43,10 +42,10 @@
 #define _is_utf8_xidcont(a)	Perl__is_utf8_xidcont(aTHX_ a)
 #define _is_utf8_xidstart(a)	Perl__is_utf8_xidstart(aTHX_ a)
 #define _to_uni_fold_flags(a,b,c,d)	Perl__to_uni_fold_flags(aTHX_ a,b,c,d)
-#define _to_utf8_fold_flags(a,b,c,d,e,f,g)	Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e,f,g)
-#define _to_utf8_lower_flags(a,b,c,d,e,f,g)	Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e,f,g)
-#define _to_utf8_title_flags(a,b,c,d,e,f,g)	Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e,f,g)
-#define _to_utf8_upper_flags(a,b,c,d,e,f,g)	Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e,f,g)
+#define _to_utf8_fold_flags(a,b,c,d,e)	Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e)
+#define _to_utf8_lower_flags(a,b,c,d,e)	Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e)
+#define _to_utf8_title_flags(a,b,c,d,e)	Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e)
+#define _to_utf8_upper_flags(a,b,c,d,e)	Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e)
 #define _utf8n_to_uvchr_msgs_helper	Perl__utf8n_to_uvchr_msgs_helper
 #define amagic_call(a,b,c,d)	Perl_amagic_call(aTHX_ a,b,c,d)
 #define amagic_deref_call(a,b)	Perl_amagic_deref_call(aTHX_ a,b)
@@ -262,13 +261,7 @@
 #define init_stacks()		Perl_init_stacks(aTHX)
 #define init_tm(a)		Perl_init_tm(aTHX_ a)
 #define intro_my()		Perl_intro_my(aTHX)
-#ifndef NO_MATHOMS
-#define isALNUM_lazy(a)		Perl_isALNUM_lazy(aTHX_ a)
-#endif
 #define isC9_STRICT_UTF8_CHAR	Perl_isC9_STRICT_UTF8_CHAR
-#ifndef NO_MATHOMS
-#define isIDFIRST_lazy(a)	Perl_isIDFIRST_lazy(aTHX_ a)
-#endif
 #define isSTRICT_UTF8_CHAR	Perl_isSTRICT_UTF8_CHAR
 #define isUTF8_CHAR		Perl_isUTF8_CHAR
 #define is_c9strict_utf8_string_loclen	Perl_is_c9strict_utf8_string_loclen
@@ -366,81 +359,18 @@
 #define is_uni_xdigit_lc(a)	Perl_is_uni_xdigit_lc(aTHX_ a)
 #endif
 #ifndef NO_MATHOMS
-#define is_utf8_alnum(a)	Perl_is_utf8_alnum(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_alnumc(a)	Perl_is_utf8_alnumc(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_alpha(a)	Perl_is_utf8_alpha(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_ascii(a)	Perl_is_utf8_ascii(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_blank(a)	Perl_is_utf8_blank(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
 #define is_utf8_char		Perl_is_utf8_char
 #endif
 #define is_utf8_char_helper	Perl_is_utf8_char_helper
-#ifndef NO_MATHOMS
-#define is_utf8_cntrl(a)	Perl_is_utf8_cntrl(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_digit(a)	Perl_is_utf8_digit(aTHX_ a)
-#endif
 #define is_utf8_fixed_width_buf_loclen_flags	Perl_is_utf8_fixed_width_buf_loclen_flags
-#ifndef NO_MATHOMS
-#define is_utf8_graph(a)	Perl_is_utf8_graph(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_idcont(a)	Perl_is_utf8_idcont(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_idfirst(a)	Perl_is_utf8_idfirst(aTHX_ a)
-#endif
 #define is_utf8_invariant_string_loc	Perl_is_utf8_invariant_string_loc
 #ifndef NO_MATHOMS
-#define is_utf8_lower(a)	Perl_is_utf8_lower(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
 #define is_utf8_mark(a)		Perl_is_utf8_mark(aTHX_ a)
 #endif
-#ifndef NO_MATHOMS
-#define is_utf8_perl_space(a)	Perl_is_utf8_perl_space(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_perl_word(a)	Perl_is_utf8_perl_word(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_posix_digit(a)	Perl_is_utf8_posix_digit(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_print(a)	Perl_is_utf8_print(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_punct(a)	Perl_is_utf8_punct(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_space(a)	Perl_is_utf8_space(aTHX_ a)
-#endif
 #define is_utf8_string_flags	Perl_is_utf8_string_flags
 #define is_utf8_string_loclen	Perl_is_utf8_string_loclen
 #define is_utf8_string_loclen_flags	Perl_is_utf8_string_loclen_flags
-#ifndef NO_MATHOMS
-#define is_utf8_upper(a)	Perl_is_utf8_upper(aTHX_ a)
-#endif
 #define is_utf8_valid_partial_char_flags	Perl_is_utf8_valid_partial_char_flags
-#ifndef NO_MATHOMS
-#define is_utf8_xdigit(a)	Perl_is_utf8_xdigit(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_xidcont(a)	Perl_is_utf8_xidcont(aTHX_ a)
-#endif
-#ifndef NO_MATHOMS
-#define is_utf8_xidfirst(a)	Perl_is_utf8_xidfirst(aTHX_ a)
-#endif
 #define isinfnan		Perl_isinfnan
 #define leave_adjust_stacks(a,b,c,d)	Perl_leave_adjust_stacks(aTHX_ a,b,c,d)
 #define leave_scope(a)		Perl_leave_scope(aTHX_ a)
@@ -1679,6 +1609,11 @@
 #  if !defined(WIN32)
 #define do_exec3(a,b,c)		Perl_do_exec3(aTHX_ a,b,c)
 #  endif
+#  if 0	/* Not currently used, but may be needed in the future */
+#    if defined(PERL_IN_UTF8_C)
+#define warn_on_first_deprecated_use(a,b,c,d,e)	S_warn_on_first_deprecated_use(aTHX_ a,b,c,d,e)
+#    endif
+#  endif
 #  if defined (HAS_SOCKETPAIR) ||     (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && 	defined(AF_INET) && defined(PF_INET))
 #define PerlSock_socketpair_cloexec(a,b,c,d)	Perl_PerlSock_socketpair_cloexec(aTHX_ a,b,c,d)
 #  endif
@@ -2085,7 +2020,6 @@
 #  endif
 #  if defined(PERL_IN_UTF8_C)
 #define _to_utf8_case(a,b,c,d,e,f,g,h,i)	S__to_utf8_case(aTHX_ a,b,c,d,e,f,g,h,i)
-#define check_and_deprecate(a,b,c,d,e,f)	S_check_and_deprecate(aTHX_ a,b,c,d,e,f)
 #define check_locale_boundary_crossing(a,b,c,d)	S_check_locale_boundary_crossing(aTHX_ a,b,c,d)
 #define does_utf8_overflow	S_does_utf8_overflow
 #define isFF_OVERLONG		S_isFF_OVERLONG
@@ -2100,7 +2034,6 @@
 #define turkic_lc(a,b,c,d)	S_turkic_lc(aTHX_ a,b,c,d)
 #define turkic_uc(a,b,c,d)	S_turkic_uc(aTHX_ a,b,c,d)
 #define unexpected_non_continuation_text(a,b,c,d)	S_unexpected_non_continuation_text(aTHX_ a,b,c,d)
-#define warn_on_first_deprecated_use(a,b,c,d,e)	S_warn_on_first_deprecated_use(aTHX_ a,b,c,d,e)
 #  endif
 #  if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C)
 #define _to_upper_title_latin1(a,b,c,d)	Perl__to_upper_title_latin1(aTHX_ a,b,c,d)
diff --git a/ext/XS-APItest/APItest.xs b/ext/XS-APItest/APItest.xs
index 777add5ba3..34c602fa11 100644
--- a/ext/XS-APItest/APItest.xs
+++ b/ext/XS-APItest/APItest.xs
@@ -4674,7 +4674,7 @@ test_isBLANK_utf8(U8 * p, int type)
             RETVAL = isBLANK_utf8_safe(p, e);
         }
         else {
-            RETVAL = isBLANK_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4689,7 +4689,7 @@ test_isBLANK_LC_utf8(U8 * p, int type)
             RETVAL = isBLANK_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isBLANK_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4718,7 +4718,7 @@ test_isVERTWS_utf8(U8 * p, int type)
             RETVAL = isVERTWS_utf8_safe(p, e);
         }
         else {
-            RETVAL = isVERTWS_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4782,7 +4782,7 @@ test_isUPPER_utf8(U8 * p, int type)
             RETVAL = isUPPER_utf8_safe(p, e);
         }
         else {
-            RETVAL = isUPPER_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4797,7 +4797,7 @@ test_isUPPER_LC_utf8(U8 * p, int type)
             RETVAL = isUPPER_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isUPPER_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4861,7 +4861,7 @@ test_isLOWER_utf8(U8 * p, int type)
             RETVAL = isLOWER_utf8_safe(p, e);
         }
         else {
-            RETVAL = isLOWER_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4876,7 +4876,7 @@ test_isLOWER_LC_utf8(U8 * p, int type)
             RETVAL = isLOWER_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isLOWER_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4940,7 +4940,7 @@ test_isALPHA_utf8(U8 * p, int type)
             RETVAL = isALPHA_utf8_safe(p, e);
         }
         else {
-            RETVAL = isALPHA_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -4955,7 +4955,7 @@ test_isALPHA_LC_utf8(U8 * p, int type)
             RETVAL = isALPHA_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isALPHA_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5019,7 +5019,7 @@ test_isWORDCHAR_utf8(U8 * p, int type)
             RETVAL = isWORDCHAR_utf8_safe(p, e);
         }
         else {
-            RETVAL = isWORDCHAR_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5034,7 +5034,7 @@ test_isWORDCHAR_LC_utf8(U8 * p, int type)
             RETVAL = isWORDCHAR_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isWORDCHAR_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5098,7 +5098,7 @@ test_isALPHANUMERIC_utf8(U8 * p, int type)
             RETVAL = isALPHANUMERIC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isALPHANUMERIC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5113,7 +5113,7 @@ test_isALPHANUMERIC_LC_utf8(U8 * p, int type)
             RETVAL = isALPHANUMERIC_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isALPHANUMERIC_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5156,7 +5156,7 @@ test_isALNUM_utf8(U8 * p, int type)
             RETVAL = isWORDCHAR_utf8_safe(p, e);
         }
         else {
-            RETVAL = isWORDCHAR_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5171,7 +5171,7 @@ test_isALNUM_LC_utf8(U8 * p, int type)
             RETVAL = isWORDCHAR_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isWORDCHAR_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5207,7 +5207,7 @@ test_isDIGIT_utf8(U8 * p, int type)
             RETVAL = isDIGIT_utf8_safe(p, e);
         }
         else {
-            RETVAL = isDIGIT_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5222,7 +5222,7 @@ test_isDIGIT_LC_utf8(U8 * p, int type)
             RETVAL = isDIGIT_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isDIGIT_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5335,7 +5335,7 @@ test_isIDFIRST_utf8(U8 * p, int type)
             RETVAL = isIDFIRST_utf8_safe(p, e);
         }
         else {
-            RETVAL = isIDFIRST_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5350,7 +5350,7 @@ test_isIDFIRST_LC_utf8(U8 * p, int type)
             RETVAL = isIDFIRST_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isIDFIRST_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5414,7 +5414,7 @@ test_isIDCONT_utf8(U8 * p, int type)
             RETVAL = isIDCONT_utf8_safe(p, e);
         }
         else {
-            RETVAL = isIDCONT_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5429,7 +5429,7 @@ test_isIDCONT_LC_utf8(U8 * p, int type)
             RETVAL = isIDCONT_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isIDCONT_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5493,7 +5493,7 @@ test_isSPACE_utf8(U8 * p, int type)
             RETVAL = isSPACE_utf8_safe(p, e);
         }
         else {
-            RETVAL = isSPACE_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5508,7 +5508,7 @@ test_isSPACE_LC_utf8(U8 * p, int type)
             RETVAL = isSPACE_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isSPACE_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5575,7 +5575,7 @@ test_isASCII_utf8(U8 * p, int type)
             RETVAL = isASCII_utf8_safe(p, e);
         }
         else {
-            RETVAL = isASCII_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5593,7 +5593,7 @@ test_isASCII_LC_utf8(U8 * p, int type)
             RETVAL = isASCII_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isASCII_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5657,7 +5657,7 @@ test_isCNTRL_utf8(U8 * p, int type)
             RETVAL = isCNTRL_utf8_safe(p, e);
         }
         else {
-            RETVAL = isCNTRL_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5672,7 +5672,7 @@ test_isCNTRL_LC_utf8(U8 * p, int type)
             RETVAL = isCNTRL_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isCNTRL_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5736,7 +5736,7 @@ test_isPRINT_utf8(U8 * p, int type)
             RETVAL = isPRINT_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPRINT_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5751,7 +5751,7 @@ test_isPRINT_LC_utf8(U8 * p, int type)
             RETVAL = isPRINT_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPRINT_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5815,7 +5815,7 @@ test_isGRAPH_utf8(U8 * p, int type)
             RETVAL = isGRAPH_utf8_safe(p, e);
         }
         else {
-            RETVAL = isGRAPH_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5830,7 +5830,7 @@ test_isGRAPH_LC_utf8(U8 * p, int type)
             RETVAL = isGRAPH_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isGRAPH_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5894,7 +5894,7 @@ test_isPUNCT_utf8(U8 * p, int type)
             RETVAL = isPUNCT_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPUNCT_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5909,7 +5909,7 @@ test_isPUNCT_LC_utf8(U8 * p, int type)
             RETVAL = isPUNCT_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPUNCT_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5973,7 +5973,7 @@ test_isXDIGIT_utf8(U8 * p, int type)
             RETVAL = isXDIGIT_utf8_safe(p, e);
         }
         else {
-            RETVAL = isXDIGIT_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -5988,7 +5988,7 @@ test_isXDIGIT_LC_utf8(U8 * p, int type)
             RETVAL = isXDIGIT_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isXDIGIT_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -6052,7 +6052,7 @@ test_isPSXSPC_utf8(U8 * p, int type)
             RETVAL = isPSXSPC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPSXSPC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -6067,7 +6067,7 @@ test_isPSXSPC_LC_utf8(U8 * p, int type)
             RETVAL = isPSXSPC_LC_utf8_safe(p, e);
         }
         else {
-            RETVAL = isPSXSPC_LC_utf8(p);
+            RETVAL = 0;
         }
     OUTPUT:
         RETVAL
@@ -6507,23 +6507,18 @@ test_toLOWER_utf8(SV * p, int type)
         if (type >= 0) {
             e = input + UTF8SKIP(input) - type;
             resultant_cp = toLOWER_utf8_safe(input, e, s, &len);
+            av_push(av, newSVuv(resultant_cp));
+
+            utf8 = newSVpvn((char *) s, len);
+            SvUTF8_on(utf8);
+            av_push(av, utf8);
+
+            av_push(av, newSVuv(len));
+            RETVAL = av;
         }
-        else if (type == -1) {
-            resultant_cp = toLOWER_utf8(input, s, &len);
-        }
-#ifndef NO_MATHOMS
         else {
-            resultant_cp = Perl_to_utf8_lower(aTHX_ input, s, &len);
+            RETVAL = 0;
         }
-#endif
-        av_push(av, newSVuv(resultant_cp));
-
-        utf8 = newSVpvn((char *) s, len);
-        SvUTF8_on(utf8);
-        av_push(av, utf8);
-
-        av_push(av, newSVuv(len));
-        RETVAL = av;
     OUTPUT:
         RETVAL
 
@@ -6597,23 +6592,18 @@ test_toFOLD_utf8(SV * p, int type)
         if (type >= 0) {
             e = input + UTF8SKIP(input) - type;
             resultant_cp = toFOLD_utf8_safe(input, e, s, &len);
+            av_push(av, newSVuv(resultant_cp));
+
+            utf8 = newSVpvn((char *) s, len);
+            SvUTF8_on(utf8);
+            av_push(av, utf8);
+
+            av_push(av, newSVuv(len));
+            RETVAL = av;
         }
-        else if (type == -1) {
-            resultant_cp = toFOLD_utf8(input, s, &len);
-        }
-#ifndef NO_MATHOMS
         else {
-            resultant_cp = Perl_to_utf8_fold(aTHX_ input, s, &len);
+            RETVAL = 0;
         }
-#endif
-        av_push(av, newSVuv(resultant_cp));
-
-        utf8 = newSVpvn((char *) s, len);
-        SvUTF8_on(utf8);
-        av_push(av, utf8);
-
-        av_push(av, newSVuv(len));
-        RETVAL = av;
     OUTPUT:
         RETVAL
 
@@ -6687,23 +6677,18 @@ test_toUPPER_utf8(SV * p, int type)
         if (type >= 0) {
             e = input + UTF8SKIP(input) - type;
             resultant_cp = toUPPER_utf8_safe(input, e, s, &len);
+            av_push(av, newSVuv(resultant_cp));
+
+            utf8 = newSVpvn((char *) s, len);
+            SvUTF8_on(utf8);
+            av_push(av, utf8);
+
+            av_push(av, newSVuv(len));
+            RETVAL = av;
         }
-        else if (type == -1) {
-            resultant_cp = toUPPER_utf8(input, s, &len);
-        }
-#ifndef NO_MATHOMS
         else {
-            resultant_cp = Perl_to_utf8_upper(aTHX_ input, s, &len);
+            RETVAL = 0;
         }
-#endif
-        av_push(av, newSVuv(resultant_cp));
-
-        utf8 = newSVpvn((char *) s, len);
-        SvUTF8_on(utf8);
-        av_push(av, utf8);
-
-        av_push(av, newSVuv(len));
-        RETVAL = av;
     OUTPUT:
         RETVAL
 
@@ -6770,23 +6755,18 @@ test_toTITLE_utf8(SV * p, int type)
         if (type >= 0) {
             e = input + UTF8SKIP(input) - type;
             resultant_cp = toTITLE_utf8_safe(input, e, s, &len);
+            av_push(av, newSVuv(resultant_cp));
+
+            utf8 = newSVpvn((char *) s, len);
+            SvUTF8_on(utf8);
+            av_push(av, utf8);
+
+            av_push(av, newSVuv(len));
+            RETVAL = av;
         }
-        else if (type == -1) {
-            resultant_cp = toTITLE_utf8(input, s, &len);
-        }
-#ifndef NO_MATHOMS
         else {
-            resultant_cp = Perl_to_utf8_title(aTHX_ input, s, &len);
+            RETVAL = 0;
         }
-#endif
-        av_push(av, newSVuv(resultant_cp));
-
-        utf8 = newSVpvn((char *) s, len);
-        SvUTF8_on(utf8);
-        av_push(av, utf8);
-
-        av_push(av, newSVuv(len));
-        RETVAL = av;
     OUTPUT:
         RETVAL
 
diff --git a/ext/XS-APItest/t/handy_base.pl b/ext/XS-APItest/t/handy_base.pl
index 7e8194e643..a85bf23452 100644
--- a/ext/XS-APItest/t/handy_base.pl
+++ b/ext/XS-APItest/t/handy_base.pl
@@ -162,8 +162,6 @@ local $SIG{__WARN__} = sub { push @warnings, @_ };
 my %utf8_param_code = (
                         "_safe"                 =>  0,
                         "_safe, malformed"      =>  1,
-                        "deprecated unsafe"     => -1,
-                        "deprecated mathoms"    => -2,
                       );
 
 # This test is split into this number of files.
@@ -330,7 +328,6 @@ foreach my $name (sort keys %properties, 'octal') {
 
                     foreach my $utf8_param("_safe",
                                            "_safe, malformed",
-                                           "deprecated unsafe"
                                           )
                     {
                         my $utf8_param_code = $utf8_param_code{$utf8_param};
@@ -555,8 +552,6 @@ foreach my $name (sort keys %to_properties) {
         $char = quotemeta $char if $char eq '\\' || $char eq "'";
         foreach my $utf8_param("_safe",
                                 "_safe, malformed",
-                                "deprecated unsafe",
-                                "deprecated mathoms",
                                 )
         {
             use Config;
diff --git a/handy.h b/handy.h
index 26547fbd1d..8349fd1699 100644
--- a/handy.h
+++ b/handy.h
@@ -625,31 +625,17 @@ used to determine if it is in the character class.  For example,
 C<isWORDCHAR_uvchr(0x100)> returns TRUE, since 0x100 is LATIN CAPITAL LETTER A
 WITH MACRON in Unicode, and is a word character.
 
-Variant C<isI<FOO>_utf8_safe> is like C<isI<FOO>_uvchr>, but is used for UTF-8
-encoded strings.  Each call classifies the first character of the string.  This
-variant takes two parameters.  The first, C<p>, is a
-pointer to the first byte of the character to be classified.  (Recall that it
-may take more than one byte to represent a character in UTF-8 strings.)  The
-second parameter, C<e>, points to anywhere in the string beyond the first
-character, up to one byte past the end of the entire string.  The suffix
-C<_safe> in the function's name indicates that it will not attempt to read
-beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is true (this
-is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the input
-character is malformed in some way, the program may croak, or the function may
-return FALSE, at the discretion of the implementation, and subject to change in
-future releases.
-
-Variant C<isI<FOO>_utf8> is like C<isI<FOO>_utf8_safe>, but takes just a single
-parameter, C<p>, which has the same meaning as the corresponding parameter does
-in C<isI<FOO>_utf8_safe>.  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take a second
-parameter, becoming a synonym for C<isI<FOO>_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<isI<FOO>_utf8> from each call point in the
-program will raise a deprecation warning, enabled by default.  You can convert
-your program now to use C<isI<FOO>_utf8_safe>, and avoid the warnings, and get an
-extra measure of protection, or you can wait until v5.32, when you'll be forced
-to add the C<e> parameter.
+Variants C<isI<FOO>_utf8> and C<isI<FOO>_utf8_safe> are like C<isI<FOO>_uvchr>,
+but are used for UTF-8 encoded strings.  The two forms are different names for
+the same thing.  Each call to one of these classifies the first character of
+the string starting at C<p>.  The second parameter, C<e>, points to anywhere in
+the string beyond the first character, up to one byte past the end of the
+entire string.  Although both variants are identical, the suffix C<_safe> in
+one name emphasizes that it will not attempt to read beyond S<C<e - 1>>,
+provided that the constraint S<C<s E<lt> e>> is true (this is asserted for in
+C<-DDEBUGGING> builds).  If the UTF-8 for the input character is malformed in
+some way, the program may croak, or the function may return FALSE, at the
+discretion of the implementation, and subject to change in future releases.
 
 Variant C<isI<FOO>_LC> is like the C<isI<FOO>_A> and C<isI<FOO>_L1> variants,
 but the result is based on the current locale, which is what C<LC> in the name
@@ -665,38 +651,27 @@ Variant C<isI<FOO>_LC_uvchr> acts exactly like C<isI<FOO>_LC> for inputs less
 than 256, but for larger ones it returns the Unicode classification of the code
 point.
 
-Variant C<isI<FOO>_LC_utf8_safe> is like C<isI<FOO>_LC_uvchr>, but is used for UTF-8
-encoded strings.  Each call classifies the first character of the string.  This
-variant takes two parameters.  The first, C<p>, is a pointer to the first byte
-of the character to be classified.  (Recall that it may take more than one byte
-to represent a character in UTF-8 strings.) The second parameter, C<e>,
-points to anywhere in the string beyond the first character, up to one byte
-past the end of the entire string.  The suffix C<_safe> in the function's name
-indicates that it will not attempt to read beyond S<C<e - 1>>, provided that
-the constraint S<C<s E<lt> e>> is true (this is asserted for in C<-DDEBUGGING>
-builds).  If the UTF-8 for the input character is malformed in some way, the
-program may croak, or the function may return FALSE, at the discretion of the
-implementation, and subject to change in future releases.
-
-Variant C<isI<FOO>_LC_utf8> is like C<isI<FOO>_LC_utf8_safe>, but takes just a single
-parameter, C<p>, which has the same meaning as the corresponding parameter does
-in C<isI<FOO>_LC_utf8_safe>.  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take a second
-parameter, becoming a synonym for C<isI<FOO>_LC_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<isI<FOO>_LC_utf8> from each call point in
-the program will raise a deprecation warning, enabled by default.  You can
-convert your program now to use C<isI<FOO>_LC_utf8_safe>, and avoid the warnings,
-and get an extra measure of protection, or you can wait until v5.32, when
-you'll be forced to add the C<e> parameter.
+Variants C<isI<FOO>_LC_utf8> and C<isI<FOO>_LC_utf8_safe> are like
+C<isI<FOO>_LC_uvchr>, but are used for UTF-8 encoded strings.  The two forms
+are different names for the same thing.  Each call to one of these classifies
+the first character of the string starting at C<p>.  The second parameter,
+C<e>, points to anywhere in the string beyond the first character, up to one
+byte past the end of the entire string.  Although both variants are identical,
+the suffix C<_safe> in one name emphasizes that it will not attempt to read
+beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is true (this
+is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the input
+character is malformed in some way, the program may croak, or the function may
+return FALSE, at the discretion of the implementation, and subject to change in
+future releases.
 
 =for apidoc Am|bool|isALPHA|int ch
 Returns a boolean indicating whether the specified input is one of C<[A-Za-z]>,
 analogous to C<m/[[:alpha:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isALPHA_A>, C<isALPHA_L1>, C<isALPHA_uvchr>, C<isALPHA_utf8_safe>,
-C<isALPHA_LC>, C<isALPHA_LC_uvchr>, and C<isALPHA_LC_utf8_safe>.
+C<isALPHA_A>, C<isALPHA_L1>, C<isALPHA_uvchr>, C<isALPHA_utf8>,
+C<isALPHA_utf8_safe>, C<isALPHA_LC>, C<isALPHA_LC_uvchr>, C<isALPHA_LC_utf8>,
+and C<isALPHA_LC_utf8_safe>.
 
 =cut
 
@@ -718,8 +693,9 @@ C<[A-Za-z0-9]>, analogous to C<m/[[:alnum:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
 C<isALPHANUMERIC_A>, C<isALPHANUMERIC_L1>, C<isALPHANUMERIC_uvchr>,
-C<isALPHANUMERIC_utf8_safe>, C<isALPHANUMERIC_LC>, C<isALPHANUMERIC_LC_uvchr>,
-and C<isALPHANUMERIC_LC_utf8_safe>.
+C<isALPHANUMERIC_utf8>, C<isALPHANUMERIC_utf8_safe>, C<isALPHANUMERIC_LC>,
+C<isALPHANUMERIC_LC_uvchr>, C<isALPHANUMERIC_LC_utf8>, and
+C<isALPHANUMERIC_LC_utf8_safe>.
 
 A (discouraged from use) synonym is C<isALNUMC> (where the C<C> suffix means
 this corresponds to the C language alphanumeric definition).  Also
@@ -749,10 +725,11 @@ character corresponds to an ASCII character.  Variants C<isASCII_A()> and
 C<isASCII_L1()> are identical to C<isASCII()>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isASCII_uvchr>, C<isASCII_utf8_safe>, C<isASCII_LC>, C<isASCII_LC_uvchr>, and
-C<isASCII_LC_utf8_safe>.  Note, however, that some platforms do not have the C
-library routine C<isascii()>.  In these cases, the variants whose names contain
-C<LC> are the same as the corresponding ones without.
+C<isASCII_uvchr>, C<isASCII_utf8>, C<isASCII_utf8_safe>, C<isASCII_LC>,
+C<isASCII_LC_uvchr>, C<isASCII_LC_utf8>, and C<isASCII_LC_utf8_safe>.
+Note, however, that some platforms do not have the C library routine
+C<isascii()>.  In these cases, the variants whose names contain C<LC> are the
+same as the corresponding ones without.
 
 =for apidoc Amh|bool|isASCII_A|int ch
 =for apidoc Amh|bool|isASCII_L1|int ch
@@ -766,16 +743,17 @@ C<LC> are the same as the corresponding ones without.
 Also note, that because all ASCII characters are UTF-8 invariant (meaning they
 have the exact same representation (always a single byte) whether encoded in
 UTF-8 or not), C<isASCII> will give the correct results when called with any
-byte in any string encoded or not in UTF-8.  And similarly C<isASCII_utf8_safe>
-will work properly on any string encoded or not in UTF-8.
+byte in any string encoded or not in UTF-8.  And similarly C<isASCII_utf8> and
+C<isASCII_utf8_safe> will work properly on any string encoded or not in UTF-8.
 
 =for apidoc Am|bool|isBLANK|char ch
 Returns a boolean indicating whether the specified character is a
 character considered to be a blank, analogous to C<m/[[:blank:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isBLANK_A>, C<isBLANK_L1>, C<isBLANK_uvchr>, C<isBLANK_utf8_safe>,
-C<isBLANK_LC>, C<isBLANK_LC_uvchr>, and C<isBLANK_LC_utf8_safe>.  Note,
+C<isBLANK_A>, C<isBLANK_L1>, C<isBLANK_uvchr>, C<isBLANK_utf8>,
+C<isBLANK_utf8_safe>, C<isBLANK_LC>, C<isBLANK_LC_uvchr>, C<isBLANK_LC_utf8>,
+and C<isBLANK_LC_utf8_safe>.  Note,
 however, that some platforms do not have the C library routine
 C<isblank()>.  In these cases, the variants whose names contain C<LC> are
 the same as the corresponding ones without.
@@ -794,8 +772,9 @@ Returns a boolean indicating whether the specified character is a
 control character, analogous to C<m/[[:cntrl:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isCNTRL_A>, C<isCNTRL_L1>, C<isCNTRL_uvchr>, C<isCNTRL_utf8_safe>,
-C<isCNTRL_LC>, C<isCNTRL_LC_uvchr>, and C<isCNTRL_LC_utf8_safe> On EBCDIC
+C<isCNTRL_A>, C<isCNTRL_L1>, C<isCNTRL_uvchr>, C<isCNTRL_utf8>,
+C<isCNTRL_utf8_safe>, C<isCNTRL_LC>, C<isCNTRL_LC_uvchr>, C<isCNTRL_LC_utf8>
+and C<isCNTRL_LC_utf8_safe>.  On EBCDIC
 platforms, you almost always want to use the C<isCNTRL_L1> variant.
 
 =for apidoc Amh|bool|isCNTRL_A|int ch
@@ -813,8 +792,8 @@ digit, analogous to C<m/[[:digit:]]/>.
 Variants C<isDIGIT_A> and C<isDIGIT_L1> are identical to C<isDIGIT>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isDIGIT_uvchr>, C<isDIGIT_utf8_safe>, C<isDIGIT_LC>, C<isDIGIT_LC_uvchr>, and
-C<isDIGIT_LC_utf8_safe>.
+C<isDIGIT_uvchr>, C<isDIGIT_utf8>, C<isDIGIT_utf8_safe>, C<isDIGIT_LC>,
+C<isDIGIT_LC_uvchr>, C<isDIGIT_LC_utf8>, and C<isDIGIT_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isDIGIT_A|int ch
 =for apidoc Amh|bool|isDIGIT_L1|int ch
@@ -829,8 +808,9 @@ C<isDIGIT_LC_utf8_safe>.
 Returns a boolean indicating whether the specified character is a
 graphic character, analogous to C<m/[[:graph:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
-variants C<isGRAPH_A>, C<isGRAPH_L1>, C<isGRAPH_uvchr>, C<isGRAPH_utf8_safe>,
-C<isGRAPH_LC>, C<isGRAPH_LC_uvchr>, and C<isGRAPH_LC_utf8_safe>.
+variants C<isGRAPH_A>, C<isGRAPH_L1>, C<isGRAPH_uvchr>, C<isGRAPH_utf8>,
+C<isGRAPH_utf8_safe>, C<isGRAPH_LC>, C<isGRAPH_LC_uvchr>,
+C<isGRAPH_LC_utf8_safe>, and C<isGRAPH_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isGRAPH_A|int ch
 =for apidoc Amh|bool|isGRAPH_L1|int ch
@@ -846,8 +826,9 @@ Returns a boolean indicating whether the specified character is a
 lowercase character, analogous to C<m/[[:lower:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isLOWER_A>, C<isLOWER_L1>, C<isLOWER_uvchr>, C<isLOWER_utf8_safe>,
-C<isLOWER_LC>, C<isLOWER_LC_uvchr>, and C<isLOWER_LC_utf8_safe>.
+C<isLOWER_A>, C<isLOWER_L1>, C<isLOWER_uvchr>, C<isLOWER_utf8>,
+C<isLOWER_utf8_safe>, C<isLOWER_LC>, C<isLOWER_LC_uvchr>, C<isLOWER_LC_utf8>,
+and C<isLOWER_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isLOWER_A|int ch
 =for apidoc Amh|bool|isLOWER_L1|int ch
@@ -874,8 +855,9 @@ Note that the definition of what is punctuation isn't as
 straightforward as one might desire.  See L<perlrecharclass/POSIX Character
 Classes> for details.
 See the L<top of this section|/Character classification> for an explanation of
-variants C<isPUNCT_A>, C<isPUNCT_L1>, C<isPUNCT_uvchr>, C<isPUNCT_utf8_safe>,
-C<isPUNCT_LC>, C<isPUNCT_LC_uvchr>, and C<isPUNCT_LC_utf8_safe>.
+variants C<isPUNCT_A>, C<isPUNCT_L1>, C<isPUNCT_uvchr>, C<isPUNCT_utf8>,
+C<isPUNCT_utf8_safe>, C<isPUNCT_LC>, C<isPUNCT_LC_uvchr>, C<isPUNCT_LC_utf8>,
+and C<isPUNCT_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isPUNCT_A|int ch
 =for apidoc Amh|bool|isPUNCT_L1|int ch
@@ -897,8 +879,9 @@ in the non-locale variants, was that C<isSPACE()> did not match a vertical tab.
 (See L</isPSXSPC> for a macro that matches a vertical tab in all releases.)
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isSPACE_A>, C<isSPACE_L1>, C<isSPACE_uvchr>, C<isSPACE_utf8_safe>,
-C<isSPACE_LC>, C<isSPACE_LC_uvchr>, and C<isSPACE_LC_utf8_safe>.
+C<isSPACE_A>, C<isSPACE_L1>, C<isSPACE_uvchr>, C<isSPACE_utf8>,
+C<isSPACE_utf8_safe>, C<isSPACE_LC>, C<isSPACE_LC_uvchr>, C<isSPACE_LC_utf8>,
+and C<isSPACE_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isSPACE_A|int ch
 =for apidoc Amh|bool|isSPACE_L1|int ch
@@ -920,8 +903,9 @@ C<isSPACE()> forms don't match a Vertical Tab, and the C<isPSXSPC()> forms do.
 Otherwise they are identical.  Thus this macro is analogous to what
 C<m/[[:space:]]/> matches in a regular expression.
 See the L<top of this section|/Character classification> for an explanation of
-variants C<isPSXSPC_A>, C<isPSXSPC_L1>, C<isPSXSPC_uvchr>, C<isPSXSPC_utf8_safe>,
-C<isPSXSPC_LC>, C<isPSXSPC_LC_uvchr>, and C<isPSXSPC_LC_utf8_safe>.
+variants C<isPSXSPC_A>, C<isPSXSPC_L1>, C<isPSXSPC_uvchr>, C<isPSXSPC_utf8>,
+C<isPSXSPC_utf8_safe>, C<isPSXSPC_LC>, C<isPSXSPC_LC_uvchr>,
+C<isPSXSPC_LC_utf8>, and C<isPSXSPC_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isPSXSPC_A|int ch
 =for apidoc Amh|bool|isPSXSPC_L1|int ch
@@ -936,8 +920,9 @@ C<isPSXSPC_LC>, C<isPSXSPC_LC_uvchr>, and C<isPSXSPC_LC_utf8_safe>.
 Returns a boolean indicating whether the specified character is an
 uppercase character, analogous to C<m/[[:upper:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
-variants C<isUPPER_A>, C<isUPPER_L1>, C<isUPPER_uvchr>, C<isUPPER_utf8_safe>,
-C<isUPPER_LC>, C<isUPPER_LC_uvchr>, and C<isUPPER_LC_utf8_safe>.
+variants C<isUPPER_A>, C<isUPPER_L1>, C<isUPPER_uvchr>, C<isUPPER_utf8>,
+C<isUPPER_utf8_safe>, C<isUPPER_LC>, C<isUPPER_LC_uvchr>, C<isUPPER_LC_utf8>,
+and C<isUPPER_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isUPPER_A|int ch
 =for apidoc Amh|bool|isUPPER_L1|int ch
@@ -953,8 +938,9 @@ Returns a boolean indicating whether the specified character is a
 printable character, analogous to C<m/[[:print:]]/>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isPRINT_A>, C<isPRINT_L1>, C<isPRINT_uvchr>, C<isPRINT_utf8_safe>,
-C<isPRINT_LC>, C<isPRINT_LC_uvchr>, and C<isPRINT_LC_utf8_safe>.
+C<isPRINT_A>, C<isPRINT_L1>, C<isPRINT_uvchr>, C<isPRINT_utf8>,
+C<isPRINT_utf8_safe>, C<isPRINT_LC>, C<isPRINT_LC_uvchr>, C<isPRINT_LC_utf8>,
+and C<isPRINT_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isPRINT_A|int ch
 =for apidoc Amh|bool|isPRINT_L1|int ch
@@ -975,10 +961,11 @@ C<isALNUM()> is a synonym provided for backward compatibility, even though a
 word character includes more than the standard C language meaning of
 alphanumeric.
 See the L<top of this section|/Character classification> for an explanation of
-variants C<isWORDCHAR_A>, C<isWORDCHAR_L1>, C<isWORDCHAR_uvchr>, and
-C<isWORDCHAR_utf8_safe>.  C<isWORDCHAR_LC>, C<isWORDCHAR_LC_uvchr>, and
-C<isWORDCHAR_LC_utf8_safe> are also as described there, but additionally
-include the platform's native underscore.
+variants C<isWORDCHAR_A>, C<isWORDCHAR_L1>, C<isWORDCHAR_uvchr>,
+C<isWORDCHAR_utf8>, and C<isWORDCHAR_utf8_safe>.  C<isWORDCHAR_LC>,
+C<isWORDCHAR_LC_uvchr>, C<isWORDCHAR_LC_utf8>, and C<isWORDCHAR_LC_utf8_safe>
+are also as described there, but additionally include the platform's native
+underscore.
 
 =for apidoc Amh|bool|isWORDCHAR_A|int ch
 =for apidoc Amh|bool|isWORDCHAR_L1|int ch
@@ -999,8 +986,8 @@ digit.  In the ASCII range these are C<[0-9A-Fa-f]>.  Variants C<isXDIGIT_A()>
 and C<isXDIGIT_L1()> are identical to C<isXDIGIT()>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isXDIGIT_uvchr>, C<isXDIGIT_utf8_safe>, C<isXDIGIT_LC>, C<isXDIGIT_LC_uvchr>,
-and C<isXDIGIT_LC_utf8_safe>.
+C<isXDIGIT_uvchr>, C<isXDIGIT_utf8>, C<isXDIGIT_utf8_safe>, C<isXDIGIT_LC>,
+C<isXDIGIT_LC_uvchr>, C<isXDIGIT_LC_utf8>, and C<isXDIGIT_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isXDIGIT_A|int ch
 =for apidoc Amh|bool|isXDIGIT_L1|int ch
@@ -1018,8 +1005,9 @@ the official Unicode property C<XID_Start>.  The difference is that this
 returns true only if the input character also matches L</isWORDCHAR>.
 See the L<top of this section|/Character classification> for an explanation of
 variants
-C<isIDFIRST_A>, C<isIDFIRST_L1>, C<isIDFIRST_uvchr>, C<isIDFIRST_utf8_safe>,
-C<isIDFIRST_LC>, C<isIDFIRST_LC_uvchr>, and C<isIDFIRST_LC_utf8_safe>.
+C<isIDFIRST_A>, C<isIDFIRST_L1>, C<isIDFIRST_uvchr>, C<isIDFIRST_utf8>,
+C<isIDFIRST_utf8_safe>, C<isIDFIRST_LC>, C<isIDFIRST_LC_uvchr>,
+C<isIDFIRST_LC_utf8>, and C<isIDFIRST_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isIDFIRST_A|int ch
 =for apidoc Amh|bool|isIDFIRST_L1|int ch
@@ -1036,10 +1024,9 @@ second or succeeding character of an identifier.  This is very close to, but
 not quite the same as the official Unicode property C<XID_Continue>.  The
 difference is that this returns true only if the input character also matches
 L</isWORDCHAR>.  See the L<top of this section|/Character classification> for
-an
-explanation of variants C<isIDCONT_A>, C<isIDCONT_L1>, C<isIDCONT_uvchr>,
-C<isIDCONT_utf8_safe>, C<isIDCONT_LC>, C<isIDCONT_LC_uvchr>, and
-C<isIDCONT_LC_utf8_safe>.
+an explanation of variants C<isIDCONT_A>, C<isIDCONT_L1>, C<isIDCONT_uvchr>,
+C<isIDCONT_utf8>, C<isIDCONT_utf8_safe>, C<isIDCONT_LC>, C<isIDCONT_LC_uvchr>,
+C<isIDCONT_LC_utf8>, and C<isIDCONT_LC_utf8_safe>.
 
 =for apidoc Amh|bool|isIDCONT_A|int ch
 =for apidoc Amh|bool|isIDCONT_L1|int ch
@@ -1084,7 +1071,7 @@ The first code point of the uppercased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more.)
 
-=for apidoc Am|UV|toUPPER_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+=for apidoc Am|UV|toUPPER_utf8|U8* p|U8* e|U8* s|STRLEN* lenp
 Converts the first UTF-8 encoded character in the sequence starting at C<p> and
 extending no further than S<C<e - 1>> to its uppercase version, and
 stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>.  Note
@@ -1095,24 +1082,14 @@ The first code point of the uppercased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-The suffix C<_safe> in the function's name indicates that it will not attempt
-to read beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is
-true (this is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the
-input character is malformed in some way, the program may croak, or the
-function may return the REPLACEMENT CHARACTER, at the discretion of the
-implementation, and subject to change in future releases.
+It will not attempt to read beyond S<C<e - 1>>, provided that the constraint
+S<C<s E<lt> e>> is true (this is asserted for in C<-DDEBUGGING> builds).  If
+the UTF-8 for the input character is malformed in some way, the program may
+croak, or the function may return the REPLACEMENT CHARACTER, at the discretion
+of the implementation, and subject to change in future releases.
 
-=for apidoc Am|UV|toUPPER_utf8|U8* p|U8* s|STRLEN* lenp
-This is like C<L</toUPPER_utf8_safe>>, but doesn't have the C<e>
-parameter  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take the C<e>
-parameter, becoming a synonym for C<toUPPER_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<toUPPER_utf8> from each call point in the
-program will raise a deprecation warning, enabled by default.  You can convert
-your program now to use C<toUPPER_utf8_safe>, and avoid the warnings, and get an
-extra measure of protection, or you can wait until v5.32, when you'll be forced
-to add the C<e> parameter.
+=for apidoc Am|UV|toUPPER_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+Same as L</toUPPER_utf8>.
 
 =for apidoc Am|U8|toFOLD|U8 ch
 Converts the specified character to foldcase.  If the input is anything but an
@@ -1131,7 +1108,7 @@ The first code point of the foldcased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-=for apidoc Am|UV|toFOLD_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+=for apidoc Am|UV|toFOLD_utf8|U8* p|U8* e|U8* s|STRLEN* lenp
 Converts the first UTF-8 encoded character in the sequence starting at C<p> and
 extending no further than S<C<e - 1>> to its foldcase version, and
 stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>.  Note
@@ -1142,24 +1119,15 @@ The first code point of the foldcased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-The suffix C<_safe> in the function's name indicates that it will not attempt
+It will not attempt
 to read beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is
 true (this is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the
 input character is malformed in some way, the program may croak, or the
 function may return the REPLACEMENT CHARACTER, at the discretion of the
 implementation, and subject to change in future releases.
 
-=for apidoc Am|UV|toFOLD_utf8|U8* p|U8* s|STRLEN* lenp
-This is like C<L</toFOLD_utf8_safe>>, but doesn't have the C<e>
-parameter  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take the C<e>
-parameter, becoming a synonym for C<toFOLD_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<toFOLD_utf8> from each call point in the
-program will raise a deprecation warning, enabled by default.  You can convert
-your program now to use C<toFOLD_utf8_safe>, and avoid the warnings, and get an
-extra measure of protection, or you can wait until v5.32, when you'll be forced
-to add the C<e> parameter.
+=for apidoc Am|UV|toFOLD_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+Same as L</toFOLD_utf8>.
 
 =for apidoc Am|U8|toLOWER|U8 ch
 Converts the specified character to lowercase.  If the input is anything but an
@@ -1185,8 +1153,7 @@ The first code point of the lowercased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-
-=for apidoc Am|UV|toLOWER_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+=for apidoc Am|UV|toLOWER_utf8|U8* p|U8* s|STRLEN* lenp
 Converts the first UTF-8 encoded character in the sequence starting at C<p> and
 extending no further than S<C<e - 1>> to its lowercase version, and
 stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>.  Note
@@ -1196,25 +1163,14 @@ bytes since the lowercase version may be longer than the original character.
 The first code point of the lowercased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
+It will not attempt to read beyond S<C<e - 1>>, provided that the constraint
+S<C<s E<lt> e>> is true (this is asserted for in C<-DDEBUGGING> builds).  If
+the UTF-8 for the input character is malformed in some way, the program may
+croak, or the function may return the REPLACEMENT CHARACTER, at the discretion
+of the implementation, and subject to change in future releases.
 
-The suffix C<_safe> in the function's name indicates that it will not attempt
-to read beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is
-true (this is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the
-input character is malformed in some way, the program may croak, or the
-function may return the REPLACEMENT CHARACTER, at the discretion of the
-implementation, and subject to change in future releases.
-
-=for apidoc Am|UV|toLOWER_utf8|U8* p|U8* s|STRLEN* lenp
-This is like C<L</toLOWER_utf8_safe>>, but doesn't have the C<e>
-parameter  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take the C<e>
-parameter, becoming a synonym for C<toLOWER_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<toLOWER_utf8> from each call point in the
-program will raise a deprecation warning, enabled by default.  You can convert
-your program now to use C<toLOWER_utf8_safe>, and avoid the warnings, and get an
-extra measure of protection, or you can wait until v5.32, when you'll be forced
-to add the C<e> parameter.
+=for apidoc Am|UV|toLOWER_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+Same as L</toLOWER_utf8>.
 
 =for apidoc Am|U8|toTITLE|U8 ch
 Converts the specified character to titlecase.  If the input is anything but an
@@ -1234,7 +1190,7 @@ The first code point of the titlecased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-=for apidoc Am|UV|toTITLE_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+=for apidoc Am|UV|toTITLE_utf8|U8* p|U8* e|U8* s|STRLEN* lenp
 Converts the first UTF-8 encoded character in the sequence starting at C<p> and
 extending no further than S<C<e - 1>> to its titlecase version, and
 stores that in UTF-8 in C<s>, and its length in bytes in C<lenp>.  Note
@@ -1245,24 +1201,15 @@ The first code point of the titlecased version is returned
 (but note, as explained at L<the top of this section|/Character case
 changing>, that there may be more).
 
-The suffix C<_safe> in the function's name indicates that it will not attempt
+It will not attempt
 to read beyond S<C<e - 1>>, provided that the constraint S<C<s E<lt> e>> is
 true (this is asserted for in C<-DDEBUGGING> builds).  If the UTF-8 for the
 input character is malformed in some way, the program may croak, or the
 function may return the REPLACEMENT CHARACTER, at the discretion of the
 implementation, and subject to change in future releases.
 
-=for apidoc Am|UV|toTITLE_utf8|U8* p|U8* s|STRLEN* lenp
-This is like C<L</toLOWER_utf8_safe>>, but doesn't have the C<e>
-parameter  The function therefore can't check if it is reading
-beyond the end of the string.  Starting in Perl v5.32, it will take the C<e>
-parameter, becoming a synonym for C<toTITLE_utf8_safe>.  At that time every
-program that uses it will have to be changed to successfully compile.  In the
-meantime, the first runtime call to C<toTITLE_utf8> from each call point in the
-program will raise a deprecation warning, enabled by default.  You can convert
-your program now to use C<toTITLE_utf8_safe>, and avoid the warnings, and get an
-extra measure of protection, or you can wait until v5.32, when you'll be forced
-to add the C<e> parameter.
+=for apidoc Am|UV|toTITLE_utf8_safe|U8* p|U8* e|U8* s|STRLEN* lenp
+Same as L</toTITLE_utf8>.
 
 =cut
 
@@ -1393,9 +1340,6 @@ or casts
 #  define _CC_GRAPH              8      /* [:graph:] */
 #  define _CC_CASED              9      /* [:lower:] or [:upper:] under /i */
 #  define _CC_SPACE             10      /* \s, [:space:] */
-#  define _CC_PSXSPC            _CC_SPACE   /* XXX Temporary, can be removed
-                                               when the deprecated isFOO_utf8()
-                                               functions are removed */
 #  define _CC_BLANK             11      /* [:blank:] */
 #  define _CC_XDIGIT            12      /* [:xdigit:] */
 #  define _CC_CNTRL             13      /* [:cntrl:] */
@@ -1415,9 +1359,6 @@ or casts
 #  define _CC_IS_IN_SOME_FOLD          22
 #  define _CC_MNEMONIC_CNTRL           23
 
-#  define _CC_IDCONT 24 /* XXX Temporary, can be removed when the deprecated
-                           isFOO_utf8() functions are removed */
-
 /* This next group is only used on EBCDIC platforms, so theoretically could be
  * shared with something entirely different that's only on ASCII platforms */
 #  define _CC_UTF8_START_BYTE_IS_FOR_AT_LEAST_SURROGATE 28
@@ -2042,22 +1983,6 @@ END_EXTERN_C
 
 #define isBLANK_LC_uni(c)    isBLANK_LC_uvchr(UNI_TO_NATIVE(c))
 
-/* For internal core Perl use only: the base macros for defining macros like
- * isALPHA_utf8.  These are like the earlier defined macros, but take an input
- * UTF-8 encoded string 'p'. If the input is in the Latin1 range, use
- * the Latin1 macro 'classnum' on 'p'.  Otherwise use the value given by the
- * 'utf8' parameter.  This relies on the fact that ASCII characters have the
- * same representation whether utf8 or not.  Note that it assumes that the utf8
- * has been validated, and ignores 'use bytes' */
-#define _base_generic_utf8(enum_name, name, p, use_locale )                 \
-    _is_utf8_FOO(CAT2(_CC_, enum_name),                                     \
-                 (const U8 *) p,                                            \
-                 "is" STRINGIFY(name) "_utf8",                              \
-                 "is" STRINGIFY(name) "_utf8_safe",                         \
-                 1, use_locale, __FILE__,__LINE__)
-
-#define _generic_utf8(name, p) _base_generic_utf8(name, name, p, 0)
-
 /* The "_safe" macros make sure that we don't attempt to read beyond 'e', but
  * they don't otherwise go out of their way to look for malformed UTF-8.  If
  * they can return accurate results without knowing if the input is otherwise
@@ -2082,8 +2007,9 @@ END_EXTERN_C
 #endif
 
 #define _generic_utf8_safe(classnum, p, e, above_latin1)                    \
-         (__ASSERT_(_utf8_safe_assert(p, e))                                \
-         (UTF8_IS_INVARIANT(*(p)))                                          \
+    ((! _utf8_safe_assert(p, e))                                            \
+      ? (_force_out_malformed_utf8_message((U8 *) (p), (U8 *) (e), 0, 1), 0)\
+      : (UTF8_IS_INVARIANT(*(p)))                                           \
           ? _generic_isCC(*(p), classnum)                                   \
           : (UTF8_IS_DOWNGRADEABLE_START(*(p))                              \
              ? ((LIKELY((e) - (p) > 1 && UTF8_IS_CONTINUATION(*((p)+1))))   \
@@ -2102,8 +2028,8 @@ END_EXTERN_C
                               ? (_force_out_malformed_utf8_message(         \
                                       (U8 *) (p), (U8 *) (e), 0, 1), 0)     \
                               : above_latin1(p)))
-/* Like the above, but passes classnum to _isFOO_utf8(), instead of having an
- * 'above_latin1' parameter */
+/* Like the above, but passes classnum to _isFOO_utf8_with_len(), instead of
+ * having an 'above_latin1' parameter */
 #define _generic_swash_utf8_safe(classnum, p, e)                            \
 _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
 
@@ -2120,24 +2046,24 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
              : above_latin1)
 
 
-#define isALPHA_utf8(p)         _generic_utf8(ALPHA, p)
-#define isALPHANUMERIC_utf8(p)  _generic_utf8(ALPHANUMERIC, p)
-#define isASCII_utf8(p)         _generic_utf8(ASCII, p)
-#define isBLANK_utf8(p)         _generic_utf8(BLANK, p)
-#define isCNTRL_utf8(p)         _generic_utf8(CNTRL, p)
-#define isDIGIT_utf8(p)         _generic_utf8(DIGIT, p)
-#define isGRAPH_utf8(p)         _generic_utf8(GRAPH, p)
-#define isIDCONT_utf8(p)        _generic_utf8(IDCONT, p)
-#define isIDFIRST_utf8(p)       _generic_utf8(IDFIRST, p)
-#define isLOWER_utf8(p)         _generic_utf8(LOWER, p)
-#define isPRINT_utf8(p)         _generic_utf8(PRINT, p)
-#define isPSXSPC_utf8(p)        _generic_utf8(PSXSPC, p)
-#define isPUNCT_utf8(p)         _generic_utf8(PUNCT, p)
-#define isSPACE_utf8(p)         _generic_utf8(SPACE, p)
-#define isUPPER_utf8(p)         _generic_utf8(UPPER, p)
-#define isVERTWS_utf8(p)        _generic_utf8(VERTSPACE, p)
-#define isWORDCHAR_utf8(p)      _generic_utf8(WORDCHAR, p)
-#define isXDIGIT_utf8(p)        _generic_utf8(XDIGIT, p)
+#define isALPHA_utf8(p, e)         isALPHA_utf8_safe(p, e)
+#define isALPHANUMERIC_utf8(p, e)  isALPHANUMERIC_utf8_safe(p, e)
+#define isASCII_utf8(p, e)         isASCII_utf8_safe(p, e)
+#define isBLANK_utf8(p, e)         isBLANK_utf8_safe(p, e)
+#define isCNTRL_utf8(p, e)         isCNTRL_utf8_safe(p, e)
+#define isDIGIT_utf8(p, e)         isDIGIT_utf8_safe(p, e)
+#define isGRAPH_utf8(p, e)         isGRAPH_utf8_safe(p, e)
+#define isIDCONT_utf8(p, e)        isIDCONT_utf8_safe(p, e)
+#define isIDFIRST_utf8(p, e)       isIDFIRST_utf8_safe(p, e)
+#define isLOWER_utf8(p, e)         isLOWER_utf8_safe(p, e)
+#define isPRINT_utf8(p, e)         isPRINT_utf8_safe(p, e)
+#define isPSXSPC_utf8(p, e)        isPSXSPC_utf8_safe(p, e)
+#define isPUNCT_utf8(p, e)         isPUNCT_utf8_safe(p, e)
+#define isSPACE_utf8(p, e)         isSPACE_utf8_safe(p, e)
+#define isUPPER_utf8(p, e)         isUPPER_utf8_safe(p, e)
+#define isVERTWS_utf8(p, e)        isVERTWS_utf8_safe(p, e)
+#define isWORDCHAR_utf8(p, e)      isWORDCHAR_utf8_safe(p, e)
+#define isXDIGIT_utf8(p, e)        isXDIGIT_utf8_safe(p, e)
 
 #define isALPHA_utf8_safe(p, e)  _generic_swash_utf8_safe(_CC_ALPHA, p, e)
 #define isALPHANUMERIC_utf8_safe(p, e)                                      \
@@ -2193,45 +2119,39 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
                                       (U8 *) (p), (U8 *) (e), 0, 1), 0)     \
                               : is_XDIGIT_high(p)))
 
-#define toFOLD_utf8(p,s,l)	to_utf8_fold(p,s,l)
-#define toLOWER_utf8(p,s,l)	to_utf8_lower(p,s,l)
-#define toTITLE_utf8(p,s,l)	to_utf8_title(p,s,l)
-#define toUPPER_utf8(p,s,l)	to_utf8_upper(p,s,l)
+#define toFOLD_utf8(p,e,s,l)	toFOLD_utf8_safe(p,e,s,l)
+#define toLOWER_utf8(p,e,s,l)	toLOWER_utf8_safe(p,e,s,l)
+#define toTITLE_utf8(p,e,s,l)	toTITLE_utf8_safe(p,e,s,l)
+#define toUPPER_utf8(p,e,s,l)	toUPPER_utf8_safe(p,e,s,l)
 
 /* For internal core use only, subject to change */
-#define _toFOLD_utf8_flags(p,e,s,l,f)  _to_utf8_fold_flags (p,e,s,l,f, "", 0)
-#define _toLOWER_utf8_flags(p,e,s,l,f) _to_utf8_lower_flags(p,e,s,l,f, "", 0)
-#define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f, "", 0)
-#define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f, "", 0)
+#define _toFOLD_utf8_flags(p,e,s,l,f)  _to_utf8_fold_flags (p,e,s,l,f)
+#define _toLOWER_utf8_flags(p,e,s,l,f) _to_utf8_lower_flags(p,e,s,l,f)
+#define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f)
+#define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f)
 
 #define toFOLD_utf8_safe(p,e,s,l)   _toFOLD_utf8_flags(p,e,s,l, FOLD_FLAGS_FULL)
 #define toLOWER_utf8_safe(p,e,s,l)  _toLOWER_utf8_flags(p,e,s,l, 0)
 #define toTITLE_utf8_safe(p,e,s,l)  _toTITLE_utf8_flags(p,e,s,l, 0)
 #define toUPPER_utf8_safe(p,e,s,l)  _toUPPER_utf8_flags(p,e,s,l, 0)
 
-/* For internal core Perl use only: the base macros for defining macros like
- * isALPHA_LC_utf8.  These are like _generic_utf8, but if the first code point
- * in 'p' is within the 0-255 range, it uses locale rules from the passed-in
- * 'macro' parameter */
-#define _generic_LC_utf8(name, p) _base_generic_utf8(name, name, p, 1)
-
-#define isALPHA_LC_utf8(p)         _generic_LC_utf8(ALPHA, p)
-#define isALPHANUMERIC_LC_utf8(p)  _generic_LC_utf8(ALPHANUMERIC, p)
-#define isASCII_LC_utf8(p)         _generic_LC_utf8(ASCII, p)
-#define isBLANK_LC_utf8(p)         _generic_LC_utf8(BLANK, p)
-#define isCNTRL_LC_utf8(p)         _generic_LC_utf8(CNTRL, p)
-#define isDIGIT_LC_utf8(p)         _generic_LC_utf8(DIGIT, p)
-#define isGRAPH_LC_utf8(p)         _generic_LC_utf8(GRAPH, p)
-#define isIDCONT_LC_utf8(p)        _generic_LC_utf8(IDCONT, p)
-#define isIDFIRST_LC_utf8(p)       _generic_LC_utf8(IDFIRST, p)
-#define isLOWER_LC_utf8(p)         _generic_LC_utf8(LOWER, p)
-#define isPRINT_LC_utf8(p)         _generic_LC_utf8(PRINT, p)
-#define isPSXSPC_LC_utf8(p)        _generic_LC_utf8(PSXSPC, p)
-#define isPUNCT_LC_utf8(p)         _generic_LC_utf8(PUNCT, p)
-#define isSPACE_LC_utf8(p)         _generic_LC_utf8(SPACE, p)
-#define isUPPER_LC_utf8(p)         _generic_LC_utf8(UPPER, p)
-#define isWORDCHAR_LC_utf8(p)      _generic_LC_utf8(WORDCHAR, p)
-#define isXDIGIT_LC_utf8(p)        _generic_LC_utf8(XDIGIT, p)
+#define isALPHA_LC_utf8(p, e)         isALPHA_LC_utf8_safe(p, e)
+#define isALPHANUMERIC_LC_utf8(p, e)  isALPHANUMERIC_LC_utf8_safe(p, e)
+#define isASCII_LC_utf8(p, e)         isASCII_LC_utf8_safe(p, e)
+#define isBLANK_LC_utf8(p, e)         isBLANK_LC_utf8_safe(p, e)
+#define isCNTRL_LC_utf8(p, e)         isCNTRL_LC_utf8_safe(p, e)
+#define isDIGIT_LC_utf8(p, e)         isDIGIT_LC_utf8_safe(p, e)
+#define isGRAPH_LC_utf8(p, e)         isGRAPH_LC_utf8_safe(p, e)
+#define isIDCONT_LC_utf8(p, e)        isIDCONT_LC_utf8_safe(p, e)
+#define isIDFIRST_LC_utf8(p, e)       isIDFIRST_LC_utf8_safe(p, e)
+#define isLOWER_LC_utf8(p, e)         isLOWER_LC_utf8_safe(p, e)
+#define isPRINT_LC_utf8(p, e)         isPRINT_LC_utf8_safe(p, e)
+#define isPSXSPC_LC_utf8(p, e)        isPSXSPC_LC_utf8_safe(p, e)
+#define isPUNCT_LC_utf8(p, e)         isPUNCT_LC_utf8_safe(p, e)
+#define isSPACE_LC_utf8(p, e)         isSPACE_LC_utf8_safe(p, e)
+#define isUPPER_LC_utf8(p, e)         isUPPER_LC_utf8_safe(p, e)
+#define isWORDCHAR_LC_utf8(p, e)      isWORDCHAR_LC_utf8_safe(p, e)
+#define isXDIGIT_LC_utf8(p, e)        isXDIGIT_LC_utf8_safe(p, e)
 
 /* For internal core Perl use only: the base macros for defining macros like
  * isALPHA_LC_utf8_safe.  These are like _generic_utf8, but if the first code
@@ -2312,16 +2232,16 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
 #define isALNUM_LC(c)       isWORDCHAR_LC(c)
 #define isALNUM_uni(c)      isWORDCHAR_uni(c)
 #define isALNUM_LC_uvchr(c) isWORDCHAR_LC_uvchr(c)
-#define isALNUM_utf8(p)     isWORDCHAR_utf8(p)
-#define isALNUM_LC_utf8(p)  isWORDCHAR_LC_utf8(p)
+#define isALNUM_utf8(p,e)   isWORDCHAR_utf8(p,e)
+#define isALNUM_LC_utf8(p,e)isWORDCHAR_LC_utf8(p,e)
 #define isALNUMC_A(c)       isALPHANUMERIC_A(c)      /* Mnemonic: "C's alnum" */
 #define isALNUMC_L1(c)      isALPHANUMERIC_L1(c)
 #define isALNUMC(c)	    isALPHANUMERIC(c)
 #define isALNUMC_LC(c)	    isALPHANUMERIC_LC(c)
 #define isALNUMC_uni(c)     isALPHANUMERIC_uni(c)
 #define isALNUMC_LC_uvchr(c) isALPHANUMERIC_LC_uvchr(c)
-#define isALNUMC_utf8(p)    isALPHANUMERIC_utf8(p)
-#define isALNUMC_LC_utf8(p) isALPHANUMERIC_LC_utf8(p)
+#define isALNUMC_utf8(p,e)  isALPHANUMERIC_utf8(p,e)
+#define isALNUMC_LC_utf8(p,e) isALPHANUMERIC_LC_utf8(p,e)
 
 /* On EBCDIC platforms, CTRL-@ is 0, CTRL-A is 1, etc, just like on ASCII,
  * except that they don't necessarily mean the same characters, e.g. CTRL-D is
diff --git a/mathoms.c b/mathoms.c
index 7e93a0a1e3..8b6388b8a2 100644
--- a/mathoms.c
+++ b/mathoms.c
@@ -1148,38 +1148,6 @@ Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
     return newATTRSUB(floor, o, proto, NULL, block);
 }
 
-UV
-Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
-{
-    PERL_ARGS_ASSERT_TO_UTF8_FOLD;
-
-    return toFOLD_utf8(p, ustrp, lenp);
-}
-
-UV
-Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
-{
-    PERL_ARGS_ASSERT_TO_UTF8_LOWER;
-
-    return toLOWER_utf8(p, ustrp, lenp);
-}
-
-UV
-Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
-{
-    PERL_ARGS_ASSERT_TO_UTF8_TITLE;
-
-    return toTITLE_utf8(p, ustrp, lenp);
-}
-
-UV
-Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
-{
-    PERL_ARGS_ASSERT_TO_UTF8_UPPER;
-
-    return toUPPER_utf8(p, ustrp, lenp);
-}
-
 SV *
 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
 {
@@ -1208,22 +1176,6 @@ ASCII_TO_NEED(const UV enc, const UV ch)
     return ch;
 }
 
-bool      /* Made into a function, so can be deprecated */
-Perl_isIDFIRST_lazy(pTHX_ const char* p)
-{
-    PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
-
-    return isIDFIRST_lazy_if(p,1);
-}
-
-bool      /* Made into a function, so can be deprecated */
-Perl_isALNUM_lazy(pTHX_ const char* p)
-{
-    PERL_ARGS_ASSERT_ISALNUM_LAZY;
-
-    return isALNUM_lazy_if(p,1);
-}
-
 bool
 Perl_is_uni_alnum(pTHX_ UV c)
 {
@@ -1384,263 +1336,6 @@ Perl_is_uni_idfirst(pTHX_ UV c)
     return _is_utf8_idstart(tmpbuf);
 }
 
-bool
-Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* The naming is historical. */
-{
-    PERL_ARGS_ASSERT_IS_UTF8_IDFIRST;
-
-    return _is_utf8_idstart(p);
-}
-
-bool
-Perl_is_utf8_xidfirst(pTHX_ const U8 *p) /* The naming is historical. */
-{
-    PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST;
-
-    return _is_utf8_xidstart(p);
-}
-
-bool
-Perl_is_utf8_idcont(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_IDCONT;
-
-    return _is_utf8_idcont(p);
-}
-
-bool
-Perl_is_utf8_xidcont(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_XIDCONT;
-
-    return _is_utf8_xidcont(p);
-}
-
-bool
-Perl_is_uni_upper_lc(pTHX_ UV c)
-{
-    return isUPPER_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_lower_lc(pTHX_ UV c)
-{
-    return isLOWER_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_cntrl_lc(pTHX_ UV c)
-{
-    return isCNTRL_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_graph_lc(pTHX_ UV c)
-{
-    return isGRAPH_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_print_lc(pTHX_ UV c)
-{
-    return isPRINT_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_punct_lc(pTHX_ UV c)
-{
-    return isPUNCT_LC_uvchr(c);
-}
-
-bool
-Perl_is_uni_xdigit_lc(pTHX_ UV c)
-{
-    return isXDIGIT_LC_uvchr(c);
-}
-
-U32
-Perl_to_uni_upper_lc(pTHX_ U32 c)
-{
-    /* XXX returns only the first character -- do not use XXX */
-    /* XXX no locale support yet */
-    STRLEN len;
-    U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
-    return (U32)to_uni_upper(c, tmpbuf, &len);
-}
-
-U32
-Perl_to_uni_title_lc(pTHX_ U32 c)
-{
-    /* XXX returns only the first character XXX -- do not use XXX */
-    /* XXX no locale support yet */
-    STRLEN len;
-    U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
-    return (U32)to_uni_title(c, tmpbuf, &len);
-}
-
-U32
-Perl_to_uni_lower_lc(pTHX_ U32 c)
-{
-    /* XXX returns only the first character -- do not use XXX */
-    /* XXX no locale support yet */
-    STRLEN len;
-    U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
-    return (U32)to_uni_lower(c, tmpbuf, &len);
-}
-
-bool
-Perl_is_utf8_alnum(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_ALNUM;
-
-    /* NOTE: "IsWord", not "IsAlnum", since Alnum is a true
-     * descendant of isalnum(3), in other words, it doesn't
-     * contain the '_'. --jhi */
-    return isWORDCHAR_utf8(p);
-}
-
-bool
-Perl_is_utf8_alnumc(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_ALNUMC;
-
-    return isALPHANUMERIC_utf8(p);
-}
-
-bool
-Perl_is_utf8_alpha(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_ALPHA;
-
-    return isALPHA_utf8(p);
-}
-
-bool
-Perl_is_utf8_ascii(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_ASCII;
-    PERL_UNUSED_CONTEXT;
-
-    return isASCII_utf8(p);
-}
-
-bool
-Perl_is_utf8_blank(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_BLANK;
-    PERL_UNUSED_CONTEXT;
-
-    return isBLANK_utf8(p);
-}
-
-bool
-Perl_is_utf8_space(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_SPACE;
-    PERL_UNUSED_CONTEXT;
-
-    return isSPACE_utf8(p);
-}
-
-bool
-Perl_is_utf8_perl_space(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE;
-    PERL_UNUSED_CONTEXT;
-
-    /* Only true if is an ASCII space-like character, and ASCII is invariant
-     * under utf8, so can just use the macro */
-    return isSPACE_A(*p);
-}
-
-bool
-Perl_is_utf8_perl_word(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD;
-    PERL_UNUSED_CONTEXT;
-
-    /* Only true if is an ASCII word character, and ASCII is invariant
-     * under utf8, so can just use the macro */
-    return isWORDCHAR_A(*p);
-}
-
-bool
-Perl_is_utf8_digit(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_DIGIT;
-
-    return isDIGIT_utf8(p);
-}
-
-bool
-Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT;
-    PERL_UNUSED_CONTEXT;
-
-    /* Only true if is an ASCII digit character, and ASCII is invariant
-     * under utf8, so can just use the macro */
-    return isDIGIT_A(*p);
-}
-
-bool
-Perl_is_utf8_upper(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_UPPER;
-
-    return isUPPER_utf8(p);
-}
-
-bool
-Perl_is_utf8_lower(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_LOWER;
-
-    return isLOWER_utf8(p);
-}
-
-bool
-Perl_is_utf8_cntrl(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_CNTRL;
-    PERL_UNUSED_CONTEXT;
-
-    return isCNTRL_utf8(p);
-}
-
-bool
-Perl_is_utf8_graph(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_GRAPH;
-
-    return isGRAPH_utf8(p);
-}
-
-bool
-Perl_is_utf8_print(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_PRINT;
-
-    return isPRINT_utf8(p);
-}
-
-bool
-Perl_is_utf8_punct(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_PUNCT;
-
-    return isPUNCT_utf8(p);
-}
-
-bool
-Perl_is_utf8_xdigit(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_XDIGIT;
-    PERL_UNUSED_CONTEXT;
-
-    return isXDIGIT_utf8(p);
-}
-
 bool
 Perl_is_utf8_mark(pTHX_ const U8 *p)
 {
diff --git a/pod/perldelta.pod b/pod/perldelta.pod
index 713514dc9d..948deda7aa 100644
--- a/pod/perldelta.pod
+++ b/pod/perldelta.pod
@@ -354,6 +354,14 @@ restored automatically by C<cx_pushsub()>, C<cx_popsub()> etc., but would
 need to be manually managed if you do any unusual manipulation of the
 context stack.
 
+=item *
+
+Various macros dealing with character type classification and changing
+case where the input is encoded in UTF-8 now require an extra parameter
+to prevent potential reads beyond the end of the buffer.  Use of these
+has generated a deprecation warning since 5.26.  Details are in
+L<perldeprecation/In XS code, use of various macros dealing with UTF-8.>
+
 =back
 
 =head1 Selected Bug Fixes
diff --git a/pod/perldeprecation.pod b/pod/perldeprecation.pod
index c96be0c671..781b151a67 100644
--- a/pod/perldeprecation.pod
+++ b/pod/perldeprecation.pod
@@ -113,7 +113,10 @@ and will be made fatal in 5.32.
 
 =head3 In XS code, use of various macros dealing with UTF-8.
 
-These macros will require an extra parameter in Perl 5.32:
+The macros below now require an extra parameter than in versions prior
+to Perl 5.32.  The final parameter in each one is a pointer into the
+string supplied by the first parameter beyond which the input will not
+be read.  This prevents potential reading beyond the end of the buffer.
 C<isALPHANUMERIC_utf8>,
 C<isASCII_utf8>,
 C<isBLANK_utf8>,
@@ -148,17 +151,14 @@ C<toTITLE_utf8>,
 and
 C<toUPPER_utf8>.
 
-There is now a macro that corresponds to each one of these, simply by
-appending C<_safe> to the name.  It takes the extra parameter.
-For example, C<isDIGIT_utf8_safe> corresponds to C<isDIGIT_utf8>, but
-takes the extra parameter, and its use doesn't generate a deprecation
-warning.  All are documented in L<perlapi/Character case changing> and
+Since Perl 5.26, this functionality with the extra parameter has been
+available by using a corresponding macro to each one of these, and whose
+name is formed by appending C<_safe> to the base name.  There is no
+change to the functionality of those.  For example, C<isDIGIT_utf8_safe>
+corresponds to C<isDIGIT_utf8>, and both now behave identically.  All
+are documented in L<perlapi/Character case changing> and
 L<perlapi/Character classification>.
 
-You can change to use these versions at any time, or, if you can live
-with the deprecation messages, wait until 5.32 and add the parameter to
-the existing calls, without changing the names.
-
 This change was originally scheduled for 5.30, but was delayed.
 
 =head2 Perl 5.30
@@ -298,7 +298,6 @@ points|perlunicode/Noncharacter code points>, nor L<code points that are
 above the legal Unicode maximum|perlunicode/Beyond Unicode code
 points>, those can be delimiters.
 
-
 =head2 Perl 5.28
 
 =head3 Attributes C<< :locked >> and C<< :unique >>
diff --git a/proto.h b/proto.h
index f351644567..767c129c55 100644
--- a/proto.h
+++ b/proto.h
@@ -145,11 +145,6 @@ PERL_CALLCONV bool	Perl__is_uni_perl_idstart(pTHX_ UV c)
 			__attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART
 
-PERL_CALLCONV bool	Perl__is_utf8_FOO(pTHX_ U8 classnum, const U8 * const p, const char * const name, const char * const alternative, const bool use_utf8, const bool use_locale, const char * const file, const unsigned line)
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_FOO	\
-	assert(p); assert(name); assert(alternative); assert(file)
-
 PERL_CALLCONV bool	Perl__is_utf8_FOO_with_len(pTHX_ const U8 classnum, const U8 *p, const U8 * const e)
 			__attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN	\
@@ -193,18 +188,18 @@ PERL_CALLCONV bool	Perl__is_utf8_xidstart(pTHX_ const U8 *p)
 PERL_CALLCONV UV	Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags);
 #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS	\
 	assert(p); assert(lenp)
-PERL_CALLCONV UV	Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, U8 flags, const char * const file, const int line);
+PERL_CALLCONV UV	Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, U8 flags);
 #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS	\
-	assert(p); assert(ustrp); assert(file)
-PERL_CALLCONV UV	Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line);
+	assert(p); assert(ustrp)
+PERL_CALLCONV UV	Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags);
 #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS	\
-	assert(p); assert(ustrp); assert(file)
-PERL_CALLCONV UV	Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line);
+	assert(p); assert(ustrp)
+PERL_CALLCONV UV	Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags);
 #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS	\
-	assert(p); assert(ustrp); assert(file)
-PERL_CALLCONV UV	Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line);
+	assert(p); assert(ustrp)
+PERL_CALLCONV UV	Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags);
 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS	\
-	assert(p); assert(ustrp); assert(file)
+	assert(p); assert(ustrp)
 PERL_CALLCONV UV	Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs);
 #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER	\
 	assert(s)
@@ -1584,14 +1579,6 @@ PERL_CALLCONV OP*	Perl_invert(pTHX_ OP* cmd)
 PERL_CALLCONV bool	Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail);
 #define PERL_ARGS_ASSERT_IO_CLOSE	\
 	assert(io)
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_isALNUM_lazy(pTHX_ const char* p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_ISALNUM_LAZY	\
-	assert(p)
-#endif
-
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE Size_t	Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
 			__attribute__warn_unused_result__;
@@ -1599,14 +1586,6 @@ PERL_STATIC_INLINE Size_t	Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const
 	assert(s0); assert(e)
 #endif
 
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_isIDFIRST_lazy(pTHX_ const char* p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_ISIDFIRST_LAZY	\
-	assert(p)
-#endif
-
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE Size_t	Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e)
 			__attribute__warn_unused_result__;
@@ -1884,46 +1863,6 @@ PERL_CALLCONV bool	Perl_is_uni_xdigit_lc(pTHX_ UV c)
 #define PERL_ARGS_ASSERT_IS_UNI_XDIGIT_LC
 #endif
 
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_alnum(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM	\
-	assert(p)
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_alnumc(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC	\
-	assert(p)
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_alpha(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_ALPHA	\
-	assert(p)
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_ascii(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_ASCII	\
-	assert(p)
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_blank(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_BLANK	\
-	assert(p)
-#endif
-
 #ifndef NO_MATHOMS
 PERL_CALLCONV STRLEN	Perl_is_utf8_char(const U8 *s)
 			__attribute__deprecated__;
@@ -1942,22 +1881,6 @@ PERL_CALLCONV STRLEN	Perl_is_utf8_char_helper(const U8 * const s, const U8 * e,
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER	\
 	assert(s); assert(e)
 
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_cntrl(pTHX_ const U8 *p)
-			__attribute__deprecated__
-			__attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_CNTRL	\
-	assert(p)
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool	Perl_is_utf8_digit(pTHX_ const U8 *p)
-			__attribute__deprecated__
... 561 lines suppressed ...

-- 
Perl5 Master Repository



nntp.perl.org: Perl Programming lists via nntp and http.
Comments to Ask Bjørn Hansen at ask@perl.org | Group listing | About