This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Rmv more deprecated characlassify/case change macros
authorKarl Williamson <khw@cpan.org>
Fri, 1 Nov 2019 01:23:09 +0000 (19:23 -0600)
committerKarl Williamson <khw@cpan.org>
Fri, 1 Nov 2019 01:45:24 +0000 (19:45 -0600)
These were missed by 059703b088f44d5665f67fba0b9d80cad89085fd.

embed.fnc
embed.h
embedvar.h
handy.h
intrpvar.h
mathoms.c
proto.h
sv.c
utf8.c

index 893352c..399d09a 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -1104,19 +1104,12 @@ AmTdP   |bool   |is_utf8_valid_partial_char                                 \
                |NN const U8 * const s|NN const U8 * const e
 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_with_len|const U8 classnum|NN const U8 *p     \
+CpR     |bool   |_is_uni_FOO|const U8 classnum|const UV c
+CpR     |bool   |_is_utf8_FOO|const U8 classnum|NN const U8 *p     \
                |NN const U8 * const e
-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
-CpR    |bool   |_is_utf8_xidstart|NN const U8 *p
-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
-CpR    |bool   |_is_utf8_mark  |NN const U8 *p
-AbDxpR |bool   |is_utf8_mark   |NN const U8 *p
+CpR     |bool   |_is_utf8_perl_idcont|NN const U8 *p|NN const U8 * const e
+CpR     |bool   |_is_utf8_perl_idstart|NN const U8 *p|NN const U8 * const e
+
 #if defined(PERL_CORE) || defined(PERL_EXT)
 EXdpR  |bool   |isSCRIPT_RUN   |NN const U8 *s|NN const U8 *send   \
                                |const bool utf8_target
@@ -3121,10 +3114,8 @@ SR       |UV     |check_locale_boundary_crossing                             \
                |NN U8* const ustrp                                         \
                |NN STRLEN *lenp
 iR     |bool   |is_utf8_common |NN const U8 *const p                       \
+                               |NN const U8 *const e                       \
                                |NULLOK SV* const invlist
-iR     |bool   |is_utf8_common_with_len|NN const U8 *const p               \
-                                       |NN const U8 *const e               \
-                                       |NULLOK SV* const invlist
 SR     |SV*    |swatch_get     |NN SV* swash|UV start|UV span
 SR     |U8*    |swash_scan_list_line|NN U8* l|NN U8* const lend|NN UV* min \
                |NN UV* max|NN UV* val|const bool wants_value               \
diff --git a/embed.h b/embed.h
index b19ec30..7923f00 100644 (file)
--- a/embed.h
+++ b/embed.h
 #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_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)
-#define _is_utf8_mark(a)       Perl__is_utf8_mark(aTHX_ a)
-#define _is_utf8_perl_idcont_with_len(a,b)     Perl__is_utf8_perl_idcont_with_len(aTHX_ a,b)
-#define _is_utf8_perl_idstart_with_len(a,b)    Perl__is_utf8_perl_idstart_with_len(aTHX_ a,b)
-#define _is_utf8_xidcont(a)    Perl__is_utf8_xidcont(aTHX_ a)
-#define _is_utf8_xidstart(a)   Perl__is_utf8_xidstart(aTHX_ a)
+#define _is_utf8_FOO(a,b,c)    Perl__is_utf8_FOO(aTHX_ a,b,c)
+#define _is_utf8_perl_idcont(a,b)      Perl__is_utf8_perl_idcont(aTHX_ a,b)
+#define _is_utf8_perl_idstart(a,b)     Perl__is_utf8_perl_idstart(aTHX_ a,b)
 #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) 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 is_utf8_char_helper    Perl_is_utf8_char_helper
 #define is_utf8_fixed_width_buf_loclen_flags   Perl_is_utf8_fixed_width_buf_loclen_flags
 #define is_utf8_invariant_string_loc   Perl_is_utf8_invariant_string_loc
-#ifndef NO_MATHOMS
-#define is_utf8_mark(a)                Perl_is_utf8_mark(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
 #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
-#define is_utf8_common(a,b)    S_is_utf8_common(aTHX_ a,b)
-#define is_utf8_common_with_len(a,b,c) S_is_utf8_common_with_len(aTHX_ a,b,c)
+#define is_utf8_common(a,b,c)  S_is_utf8_common(aTHX_ a,b,c)
 #define is_utf8_overlong_given_start_byte_ok   S_is_utf8_overlong_given_start_byte_ok
 #define new_msg_hv(a,b,c)      S_new_msg_hv(aTHX_ a,b,c)
 #define swash_scan_list_line(a,b,c,d,e,f,g)    S_swash_scan_list_line(aTHX_ a,b,c,d,e,f,g)
index 35cf8f2..259a534 100644 (file)
 #define PL_scopestack_max      (vTHX->Iscopestack_max)
 #define PL_scopestack_name     (vTHX->Iscopestack_name)
 #define PL_secondgv            (vTHX->Isecondgv)
-#define PL_seen_deprecated_macro       (vTHX->Iseen_deprecated_macro)
 #define PL_setlocale_buf       (vTHX->Isetlocale_buf)
 #define PL_setlocale_bufsize   (vTHX->Isetlocale_bufsize)
 #define PL_sharehook           (vTHX->Isharehook)
diff --git a/handy.h b/handy.h
index eb20c21..aa45129 100644 (file)
--- a/handy.h
+++ b/handy.h
@@ -2024,10 +2024,10 @@ 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_with_len(), instead of
+/* Like the above, but passes classnum to _isFOO_utf8(), 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))
+_generic_utf8_safe(classnum, p, e, _is_utf8_FOO(classnum, p, e))
 
 /* Like the above, but should be used only when it is known that there are no
  * characters in the upper-Latin1 range (128-255 on ASCII platforms) which the
@@ -2082,10 +2082,10 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
 
 #define isDIGIT_utf8_safe(p, e)                                             \
             _generic_utf8_safe_no_upper_latin1(_CC_DIGIT, p, e,             \
-                                    _is_utf8_FOO_with_len(_CC_DIGIT, p, e))
+                                    _is_utf8_FOO(_CC_DIGIT, p, e))
 #define isGRAPH_utf8_safe(p, e)    _generic_swash_utf8_safe(_CC_GRAPH, p, e)
 #define isIDCONT_utf8_safe(p, e)   _generic_func_utf8_safe(_CC_WORDCHAR,    \
-                                     _is_utf8_perl_idcont_with_len, p, e)
+                                                 _is_utf8_perl_idcont, p, e)
 
 /* To prevent S_scan_word in toke.c from hanging, we have to make sure that
  * IDFIRST is an alnum.  See
@@ -2095,7 +2095,7 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
  * modern Unicode definition */
 #define isIDFIRST_utf8_safe(p, e)                                           \
     _generic_func_utf8_safe(_CC_IDFIRST,                                    \
-                    _is_utf8_perl_idstart_with_len, (U8 *) (p), (U8 *) (e))
+                            _is_utf8_perl_idstart, (U8 *) (p), (U8 *) (e))
 
 #define isLOWER_utf8_safe(p, e)     _generic_swash_utf8_safe(_CC_LOWER, p, e)
 #define isPRINT_utf8_safe(p, e)     _generic_swash_utf8_safe(_CC_PRINT, p, e)
@@ -2165,8 +2165,7 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
               : above_latin1))
 
 #define _generic_LC_swash_utf8_safe(macro, classnum, p, e)                  \
-            _generic_LC_utf8_safe(macro, p, e,                              \
-                               _is_utf8_FOO_with_len(classnum, p, e))
+            _generic_LC_utf8_safe(macro, p, e, _is_utf8_FOO(classnum, p, e))
 
 #define _generic_LC_func_utf8_safe(macro, above_latin1, p, e)               \
             _generic_LC_utf8_safe(macro, p, e, above_latin1(p, e))
@@ -2195,10 +2194,10 @@ _generic_utf8_safe(classnum, p, e, _is_utf8_FOO_with_len(classnum, p, e))
             _generic_LC_swash_utf8_safe(isGRAPH_LC, _CC_GRAPH, p, e)
 #define isIDCONT_LC_utf8_safe(p, e)                                         \
             _generic_LC_func_utf8_safe(isIDCONT_LC,                         \
-                                _is_utf8_perl_idcont_with_len, p, e)
+                                                _is_utf8_perl_idcont, p, e)
 #define isIDFIRST_LC_utf8_safe(p, e)                                        \
             _generic_LC_func_utf8_safe(isIDFIRST_LC,                        \
-                                _is_utf8_perl_idstart_with_len, p, e)
+                                               _is_utf8_perl_idstart, p, e)
 #define isLOWER_LC_utf8_safe(p, e)                                          \
             _generic_LC_swash_utf8_safe(isLOWER_LC, _CC_LOWER, p, e)
 #define isPRINT_LC_utf8_safe(p, e)                                          \
index 47383ae..e28726b 100644 (file)
@@ -724,7 +724,6 @@ PERLVARI(I, underlying_numeric_obj, locale_t, NULL)
 #endif /* !USE_LOCALE_NUMERIC */
 
 /* utf8 character class swashes */
-PERLVAR(I, seen_deprecated_macro, HV *)
 
 PERLVAR(I, last_swash_hv, HV *)
 PERLVAR(I, last_swash_tmps, U8 *)
index 194c83f..80aa14f 100644 (file)
--- a/mathoms.c
+++ b/mathoms.c
@@ -1328,94 +1328,6 @@ Perl_is_uni_digit_lc(pTHX_ UV c)
     return isDIGIT_LC_uvchr(c);
 }
 
-bool
-Perl_is_uni_idfirst(pTHX_ UV c)
-{
-    U8 tmpbuf[UTF8_MAXBYTES+1];
-    uvchr_to_utf8(tmpbuf, c);
-    return _is_utf8_idstart(tmpbuf);
-}
-
-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_mark(pTHX_ const U8 *p)
-{
-    PERL_ARGS_ASSERT_IS_UTF8_MARK;
-
-    return _is_utf8_mark(p);
-}
-
 /*
 =for apidoc is_utf8_char
 
diff --git a/proto.h b/proto.h
index 71ac060..654487c 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -145,46 +145,21 @@ 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_with_len(pTHX_ const U8 classnum, const U8 *p, const U8 * const e)
+PERL_CALLCONV bool     Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN \
+#define PERL_ARGS_ASSERT__IS_UTF8_FOO  \
        assert(p); assert(e)
 
-PERL_CALLCONV bool     Perl__is_utf8_idcont(pTHX_ const U8 *p)
+PERL_CALLCONV bool     Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_IDCONT       \
-       assert(p)
-
-PERL_CALLCONV bool     Perl__is_utf8_idstart(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_IDSTART      \
-       assert(p)
-
-PERL_CALLCONV bool     Perl__is_utf8_mark(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_MARK \
-       assert(p)
-
-PERL_CALLCONV bool     Perl__is_utf8_perl_idcont_with_len(pTHX_ const U8 *p, const U8 * const e)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT_WITH_LEN \
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT  \
        assert(p); assert(e)
 
-PERL_CALLCONV bool     Perl__is_utf8_perl_idstart_with_len(pTHX_ const U8 *p, const U8 * const e)
+PERL_CALLCONV bool     Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART_WITH_LEN        \
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
        assert(p); assert(e)
 
-PERL_CALLCONV bool     Perl__is_utf8_xidcont(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_XIDCONT      \
-       assert(p)
-
-PERL_CALLCONV bool     Perl__is_utf8_xidstart(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_UTF8_XIDSTART     \
-       assert(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)
@@ -1898,14 +1873,6 @@ PERL_STATIC_INLINE bool  Perl_is_utf8_invariant_string_loc(const U8* const s, STR
        assert(s)
 #endif
 
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_utf8_mark(pTHX_ const U8 *p)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_MARK  \
-       assert(p)
-#endif
-
 /* PERL_CALLCONV bool  is_utf8_string(const U8 *s, STRLEN len)
                        __attribute__warn_unused_result__; */
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING
@@ -6637,16 +6604,9 @@ PERL_STATIC_INLINE int   S_isFF_OVERLONG(const U8 * const s, const STRLEN len)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_common(pTHX_ const U8 *const p, SV* const invlist)
+PERL_STATIC_INLINE bool        S_is_utf8_common(pTHX_ const U8 *const p, const U8 *const e, SV* const invlist)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_IS_UTF8_COMMON        \
-       assert(p)
-#endif
-
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 *const e, SV* const invlist)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UTF8_COMMON_WITH_LEN       \
        assert(p); assert(e)
 #endif
 
diff --git a/sv.c b/sv.c
index c1e9346..ed07e68 100644 (file)
--- a/sv.c
+++ b/sv.c
@@ -15695,8 +15695,9 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     PL_setlocale_buf = NULL;
     PL_setlocale_bufsize = 0;
 
-    /* utf8 character class swashes */
+#if 0
     PL_seen_deprecated_macro = hv_dup_inc(proto_perl->Iseen_deprecated_macro, param);
+#endif
 
     if (proto_perl->Ipsig_pend) {
        Newxz(PL_psig_pend, SIG_SIZE, int);
diff --git a/utf8.c b/utf8.c
index 3ead565..d73f8c3 100644 (file)
--- a/utf8.c
+++ b/utf8.c
@@ -2800,21 +2800,6 @@ Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
     return _invlist_contains_cp(PL_XPosix_ptrs[classnum], c);
 }
 
-/* Internal function so we can deprecate the external one, and call
-   this one from other deprecated functions in this file */
-
-bool
-Perl__is_utf8_idstart(pTHX_ const U8 *p)
-{
-    dVAR;
-
-    PERL_ARGS_ASSERT__IS_UTF8_IDSTART;
-
-    if (*p == '_')
-       return TRUE;
-    return is_utf8_common(p, PL_utf8_idstart);
-}
-
 bool
 Perl__is_uni_perl_idcont(pTHX_ UV c)
 {
@@ -3136,37 +3121,8 @@ Perl__to_uni_fold_flags(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags)
 }
 
 PERL_STATIC_INLINE bool
-S_is_utf8_common(pTHX_ const U8 *const p, SV* const invlist)
-{
-    /* returns a boolean giving whether or not the UTF8-encoded character that
-     * starts at <p> is in the inversion list indicated by <invlist>.
-     *
-     * Note that it is assumed that the buffer length of <p> is enough to
-     * contain all the bytes that comprise the character.  Thus, <*p> should
-     * have been checked before this call for mal-formedness enough to assure
-     * that.  This function, does make sure to not look past any NUL, so it is
-     * safe to use on C, NUL-terminated, strings */
-    STRLEN len = my_strnlen((char *) p, UTF8SKIP(p));
-
-    PERL_ARGS_ASSERT_IS_UTF8_COMMON;
-
-    /* The API should have included a length for the UTF-8 character in <p>,
-     * but it doesn't.  We therefore assume that p has been validated at least
-     * as far as there being enough bytes available in it to accommodate the
-     * character without reading beyond the end, and pass that number on to the
-     * validating routine */
-    if (! isUTF8_CHAR(p, p + len)) {
-        _force_out_malformed_utf8_message(p, p + len, _UTF8_NO_CONFIDENCE_IN_CURLEN,
-                                          1 /* Die */ );
-        NOT_REACHED; /* NOTREACHED */
-    }
-
-    return is_utf8_common_with_len(p, p + len, invlist);
-}
-
-PERL_STATIC_INLINE bool
-S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 * const e,
-                          SV* const invlist)
+S_is_utf8_common(pTHX_ const U8 *const p, const U8 * const e,
+                       SV* const invlist)
 {
     /* returns a boolean giving whether or not the UTF8-encoded character that
      * starts at <p>, and extending no further than <e - 1> is in the inversion
@@ -3174,7 +3130,7 @@ S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 * const e,
 
     UV cp = utf8n_to_uvchr(p, e - p, NULL, 0);
 
-    PERL_ARGS_ASSERT_IS_UTF8_COMMON_WITH_LEN;
+    PERL_ARGS_ASSERT_IS_UTF8_COMMON;
 
     if (cp == 0 && (p >= e || *p != '\0')) {
         _force_out_malformed_utf8_message(p, e, 0, 1);
@@ -3186,6 +3142,8 @@ S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 * const e,
 }
 
 #if 0  /* Not currently used, but may be needed in the future */
+PERLVAR(I, seen_deprecated_macro, HV *)
+
 STATIC void
 S_warn_on_first_deprecated_use(pTHX_ const char * const name,
                                      const char * const alternative,
@@ -3230,69 +3188,27 @@ S_warn_on_first_deprecated_use(pTHX_ const char * const name,
 #endif
 
 bool
-Perl__is_utf8_FOO_with_len(pTHX_ const U8 classnum, const U8 *p,
-                                                            const U8 * const e)
+Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e)
 {
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN;
+    PERL_ARGS_ASSERT__IS_UTF8_FOO;
 
-    return is_utf8_common_with_len(p, e, PL_XPosix_ptrs[classnum]);
+    return is_utf8_common(p, e, PL_XPosix_ptrs[classnum]);
 }
 
 bool
-Perl__is_utf8_perl_idstart_with_len(pTHX_ const U8 *p, const U8 * const e)
+Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e)
 {
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART_WITH_LEN;
+    PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART;
 
-    return is_utf8_common_with_len(p, e, PL_utf8_perl_idstart);
+    return is_utf8_common(p, e, PL_utf8_perl_idstart);
 }
 
 bool
-Perl__is_utf8_xidstart(pTHX_ const U8 *p)
+Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e)
 {
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_XIDSTART;
-
-    if (*p == '_')
-       return TRUE;
-    return is_utf8_common(p, PL_utf8_xidstart);
-}
-
-bool
-Perl__is_utf8_perl_idcont_with_len(pTHX_ const U8 *p, const U8 * const e)
-{
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT_WITH_LEN;
-
-    return is_utf8_common_with_len(p, e, PL_utf8_perl_idcont);
-}
-
-bool
-Perl__is_utf8_idcont(pTHX_ const U8 *p)
-{
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_IDCONT;
-
-    return is_utf8_common(p, PL_utf8_idcont);
-}
-
-bool
-Perl__is_utf8_xidcont(pTHX_ const U8 *p)
-{
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_XIDCONT;
-
-    return is_utf8_common(p, PL_utf8_xidcont);
-}
-
-bool
-Perl__is_utf8_mark(pTHX_ const U8 *p)
-{
-    dVAR;
-    PERL_ARGS_ASSERT__IS_UTF8_MARK;
+    PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT;
 
-    return is_utf8_common(p, PL_utf8_mark);
+    return is_utf8_common(p, e, PL_utf8_perl_idcont);
 }
 
 STATIC UV