This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
regexec.c: Silence compiler warning
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 767c129..46e69cc 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -117,6 +117,24 @@ PERL_STATIC_INLINE void    Perl_SvREFCNT_inc_void(SV *sv);
 #define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID
 #endif
 #ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        Perl_SvTRUE(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SVTRUE
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        Perl_SvTRUE_NN(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SVTRUE_NN     \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback);
+#define PERL_ARGS_ASSERT_SVTRUE_COMMON \
+       assert(sv)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        Perl_SvTRUE_nomg(pTHX_ SV *sv);
+#define PERL_ARGS_ASSERT_SVTRUE_NOMG
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE I32 Perl_TOPMARK(pTHX);
 #define PERL_ARGS_ASSERT_TOPMARK
 #endif
@@ -126,7 +144,7 @@ PERL_CALLCONV char *        Perl__byte_dump_string(pTHX_ const U8 * const start, const
 PERL_CALLCONV void     Perl__force_out_malformed_utf8_message(pTHX_ const U8 *const p, const U8 * const e, const U32 flags, const bool die_here);
 #define PERL_ARGS_ASSERT__FORCE_OUT_MALFORMED_UTF8_MESSAGE     \
        assert(p); assert(e)
-PERL_CALLCONV Size_t   Perl__inverse_folds(pTHX_ const UV cp, unsigned int * first_folds_to, const unsigned int ** remaining_folds_to)
+PERL_CALLCONV Size_t   Perl__inverse_folds(pTHX_ const UV cp, U32 * first_folds_to, const U32 ** remaining_folds_to)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT__INVERSE_FOLDS        \
        assert(first_folds_to); assert(remaining_folds_to)
@@ -145,46 +163,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)
-                       __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)
+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_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)
@@ -244,6 +237,13 @@ PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av);
 PERL_CALLCONV void     Perl_av_clear(pTHX_ AV *av);
 #define PERL_ARGS_ASSERT_AV_CLEAR      \
        assert(av)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE Size_t      Perl_av_count(pTHX_ AV *av)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_AV_COUNT      \
+       assert(av)
+#endif
+
 PERL_CALLCONV void     Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val);
 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH    \
        assert(avp); assert(val)
@@ -309,12 +309,9 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val);
                        __attribute__warn_unused_result__; */
 #define PERL_ARGS_ASSERT_AV_TINDEX
 
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE SSize_t     Perl_av_top_index(pTHX_ AV *av)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_AV_TOP_INDEX  \
-       assert(av)
-#endif
+/* PERL_CALLCONV SSize_t       av_top_index(pTHX_ AV *av)
+                       __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_AV_TOP_INDEX
 
 PERL_CALLCONV void     Perl_av_undef(pTHX_ AV *av);
 #define PERL_ARGS_ASSERT_AV_UNDEF      \
@@ -505,6 +502,11 @@ PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_INDEX      \
        assert(o)
 
+PERL_CALLCONV OP *     Perl_ck_isa(pTHX_ OP *o)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CK_ISA        \
+       assert(o)
+
 PERL_CALLCONV OP *     Perl_ck_join(pTHX_ OP *o)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_CK_JOIN       \
@@ -676,6 +678,24 @@ PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV* av, bool abandon);
 PERL_CALLCONV const COP*       Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext);
 #define PERL_ARGS_ASSERT_CLOSEST_COP   \
        assert(cop)
+PERL_CALLCONV OP*      Perl_cmpchain_extend(pTHX_ I32 type, OP* ch, OP* right)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND       \
+       assert(ch)
+
+PERL_CALLCONV OP*      Perl_cmpchain_finish(pTHX_ OP* ch)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_FINISH       \
+       assert(ch)
+
+PERL_CALLCONV OP*      Perl_cmpchain_start(pTHX_ I32 type, OP* left, OP* right)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_START
+
+PERL_CALLCONV const char *     Perl_cntrl_to_mnemonic(const U8 c)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC
+
 PERL_CALLCONV const char *     Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags);
 #define PERL_ARGS_ASSERT_COP_FETCH_LABEL       \
        assert(cop)
@@ -700,7 +720,7 @@ PERL_CALLCONV_NO_RET void   Perl_croak_caller(const char* pat, ...)
                        __attribute__format__null_ok__(__printf__,1,2);
 #define PERL_ARGS_ASSERT_CROAK_CALLER
 
-PERL_STATIC_INLINE_NO_RET void Perl_croak_memory_wrap(void)
+PERL_CALLCONV_NO_RET void      Perl_croak_memory_wrap(void)
                        __attribute__noreturn__;
 #define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP
 
@@ -726,6 +746,10 @@ PERL_CALLCONV_NO_RET void  Perl_croak_xs_usage(const CV *const cv, const char *co
 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE        \
        assert(cv); assert(params)
 
+PERL_CALLCONV Signal_t Perl_csighandler1(int sig);
+#define PERL_ARGS_ASSERT_CSIGHANDLER1
+PERL_CALLCONV Signal_t Perl_csighandler3(int sig, Siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_CSIGHANDLER3
 PERL_CALLCONV regexp_engine const *    Perl_current_re_engine(pTHX);
 #define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE
 #ifndef NO_MATHOMS
@@ -831,12 +855,12 @@ PERL_CALLCONV SV *        Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
 
 PERL_CALLCONV void     Perl_delete_eval_scope(pTHX);
 #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE
-PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen);
+PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen);
 #define PERL_ARGS_ASSERT_DELIMCPY      \
-       assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
-PERL_CALLCONV char*    Perl_delimcpy_no_escape(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen);
+       assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
+PERL_CALLCONV char*    Perl_delimcpy_no_escape(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen);
 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE    \
-       assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
+       assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
 PERL_CALLCONV void     Perl_despatch_signals(pTHX);
 #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS
 PERL_CALLCONV_NO_RET OP*       Perl_die(pTHX_ const char* pat, ...)
@@ -950,6 +974,11 @@ PERL_CALLCONV Off_t        Perl_do_tell(pTHX_ GV* gv)
 PERL_CALLCONV Size_t   Perl_do_trans(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_DO_TRANS      \
        assert(sv)
+PERL_CALLCONV I16      Perl_do_uniprop_match(const char * const key, const U16 key_len)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH      \
+       assert(key)
+
 PERL_CALLCONV UV       Perl_do_vecget(pTHX_ SV* sv, STRLEN offset, int size);
 #define PERL_ARGS_ASSERT_DO_VECGET     \
        assert(sv)
@@ -1029,9 +1058,6 @@ PERL_CALLCONV char*       Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bige
 #define PERL_ARGS_ASSERT_FBM_INSTR     \
        assert(big); assert(bigend); assert(littlestr)
 
-PERL_CALLCONV bool     Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen);
-#define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED    \
-       assert(name)
 PERL_CALLCONV SV*      Perl_filter_add(pTHX_ filter_t funcp, SV* datasv);
 #define PERL_ARGS_ASSERT_FILTER_ADD
 PERL_CALLCONV void     Perl_filter_del(pTHX_ filter_t funcp);
@@ -1114,6 +1140,10 @@ PERL_CALLCONV CV*        Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 fla
 PERL_CALLCONV void     Perl_get_db_sub(pTHX_ SV **svp, CV *cv);
 #define PERL_ARGS_ASSERT_GET_DB_SUB    \
        assert(cv)
+PERL_CALLCONV const char *     Perl_get_deprecated_property_msg(const Size_t warning_offset)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG
+
 PERL_CALLCONV void     Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer);
 #define PERL_ARGS_ASSERT_GET_HASH_SEED \
        assert(seed_buffer)
@@ -1145,6 +1175,14 @@ PERL_CALLCONV PPADDR_t*  Perl_get_ppaddr(pTHX)
                        __attribute__pure__;
 #define PERL_ARGS_ASSERT_GET_PPADDR
 
+PERL_CALLCONV SV *     Perl_get_prop_definition(pTHX_ const int table_index)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_PROP_DEFINITION
+
+PERL_CALLCONV const char * const *     Perl_get_prop_values(const int table_index)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_PROP_VALUES
+
 PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_GET_RE_ARG
 PERL_CALLCONV SV*      Perl_get_sv(pTHX_ const char *name, I32 flags);
@@ -1167,6 +1205,9 @@ PERL_CALLCONV bool        Perl_grok_atoUV(const char* pv, UV* valptr, const char** endp
 PERL_CALLCONV UV       Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result);
 #define PERL_ARGS_ASSERT_GROK_BIN      \
        assert(start); assert(len_p); assert(flags)
+PERL_CALLCONV UV       Perl_grok_bin_oct_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix);
+#define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX      \
+       assert(start); assert(len_p); assert(flags)
 PERL_CALLCONV UV       Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result);
 #define PERL_ARGS_ASSERT_GROK_HEX      \
        assert(start); assert(len_p); assert(flags)
@@ -1290,7 +1331,7 @@ PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* nam
 PERL_CALLCONV GV*      Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags);
 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS       \
        assert(stash); assert(namesv)
-PERL_CALLCONV GV*      Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type);
+PERL_CALLCONV GV*      Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type);
 #define PERL_ARGS_ASSERT_GV_FETCHPV    \
        assert(nambeg)
 PERL_CALLCONV GV*      Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type);
@@ -1335,9 +1376,9 @@ PERL_CALLCONV void        Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32
 PERL_CALLCONV GV *     Perl_gv_override(pTHX_ const char * const name, const STRLEN len);
 #define PERL_ARGS_ASSERT_GV_OVERRIDE   \
        assert(name)
-PERL_CALLCONV void     Perl_gv_setref(pTHX_ SV *const dstr, SV *const sstr);
+PERL_CALLCONV void     Perl_gv_setref(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_GV_SETREF     \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(ssv)
 PERL_CALLCONV HV*      Perl_gv_stashpv(pTHX_ const char* name, I32 flags);
 #define PERL_ARGS_ASSERT_GV_STASHPV    \
        assert(name)
@@ -1576,6 +1617,9 @@ PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_INVERT
 
+PERL_CALLCONV void     Perl_invmap_dump(pTHX_ SV* invlist, UV * map);
+#define PERL_ARGS_ASSERT_INVMAP_DUMP   \
+       assert(invlist); assert(map)
 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)
@@ -1644,226 +1688,6 @@ PERL_STATIC_INLINE bool Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN le
        assert(s)
 #endif
 #ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alnum(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALNUM
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alnum_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALNUM_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alnumc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alnumc_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALNUMC_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alpha(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALPHA
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_alpha_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_ALPHA_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_ascii(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_ASCII
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_ascii_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_ASCII_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_blank(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_BLANK
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_blank_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_BLANK_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_cntrl(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_CNTRL
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_cntrl_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_CNTRL_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_digit(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_DIGIT
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_digit_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_DIGIT_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_graph(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_GRAPH
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_graph_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_GRAPH_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_idfirst(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_idfirst_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_IDFIRST_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_lower(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_LOWER
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_lower_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_LOWER_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_print(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_PRINT
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_print_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_PRINT_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_punct(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_PUNCT
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_punct_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_PUNCT_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_space(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_SPACE
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_space_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_SPACE_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_upper(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_UPPER
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_upper_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_IS_UNI_UPPER_LC
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_xdigit(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT
-#endif
-
-#ifndef NO_MATHOMS
-PERL_CALLCONV bool     Perl_is_uni_xdigit_lc(pTHX_ UV c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_IS_UNI_XDIGIT_LC
-#endif
-
-#ifndef NO_MATHOMS
 PERL_CALLCONV STRLEN   Perl_is_utf8_char(const U8 *s)
                        __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR  \
@@ -1901,14 +1725,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
@@ -2008,6 +1824,11 @@ PERL_CALLCONV void       Perl_lex_unstuff(pTHX_ char* ptr);
        assert(ptr)
 PERL_CALLCONV OP*      Perl_list(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_LIST
+PERL_CALLCONV HV*      Perl_load_charnames(pTHX_ SV * char_name, const char * context, const STRLEN context_len, const char ** error_msg)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_LOAD_CHARNAMES        \
+       assert(char_name); assert(context); assert(error_msg)
+
 PERL_CALLCONV void     Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...);
 #define PERL_ARGS_ASSERT_LOAD_MODULE   \
        assert(name)
@@ -2054,9 +1875,15 @@ PERL_CALLCONV int        Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg);
 PERL_CALLCONV int      Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P    \
        assert(sv); assert(mg)
+PERL_CALLCONV int      Perl_magic_freemglob(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB       \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD       \
        assert(sv); assert(mg)
+PERL_CALLCONV int      Perl_magic_freeutf8(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREEUTF8        \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_get(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_GET     \
        assert(sv); assert(mg)
@@ -2258,6 +2085,13 @@ PERL_CALLCONV void *     Perl_more_bodies(pTHX_ const svtype sv_type, const size_t b
 PERL_CALLCONV const char*      Perl_moreswitches(pTHX_ const char* s);
 #define PERL_ARGS_ASSERT_MORESWITCHES  \
        assert(s)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE char *      Perl_mortal_getenv(const char * str)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MORTAL_GETENV \
+       assert(str)
+#endif
+
 PERL_CALLCONV const struct mro_alg *   Perl_mro_get_from_name(pTHX_ SV *name);
 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME     \
        assert(name)
@@ -2322,10 +2156,8 @@ PERL_CALLCONV I32        Perl_my_fflush_all(pTHX);
 #define PERL_ARGS_ASSERT_MY_FFLUSH_ALL
 PERL_CALLCONV Pid_t    Perl_my_fork(void);
 #define PERL_ARGS_ASSERT_MY_FORK
-#ifndef NO_MATHOMS
-PERL_CALLCONV I32      Perl_my_lstat(pTHX);
+/* PERL_CALLCONV I32   my_lstat(pTHX); */
 #define PERL_ARGS_ASSERT_MY_LSTAT
-#endif
 PERL_CALLCONV I32      Perl_my_lstat_flags(pTHX_ const U32 flags);
 #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS
 PERL_CALLCONV int      Perl_my_mkostemp_cloexec(char *templte, int flags)
@@ -2350,10 +2182,8 @@ PERL_CALLCONV int        Perl_my_snprintf(char *buffer, const Size_t len, const char *f
 
 PERL_CALLCONV int      Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
 #define PERL_ARGS_ASSERT_MY_SOCKETPAIR
-#ifndef NO_MATHOMS
-PERL_CALLCONV I32      Perl_my_stat(pTHX);
+/* PERL_CALLCONV I32   my_stat(pTHX); */
 #define PERL_ARGS_ASSERT_MY_STAT
-#endif
 PERL_CALLCONV I32      Perl_my_stat_flags(pTHX_ const U32 flags);
 #define PERL_ARGS_ASSERT_MY_STAT_FLAGS
 PERL_CALLCONV char*    Perl_my_strerror(pTHX_ const int errnum);
@@ -2773,10 +2603,12 @@ PERL_CALLCONV void      Perl_optimize_optree(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE       \
        assert(o)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags);
+PERL_CALLCONV void     Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
+                       __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_PACK_CAT      \
        assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list)
 #endif
+
 PERL_CALLCONV void     Perl_package(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_PACKAGE       \
        assert(o)
@@ -2807,6 +2639,7 @@ PERL_CALLCONV void        Perl_pad_block_start(pTHX_ int full);
 #define PERL_ARGS_ASSERT_PAD_BLOCK_START
 #ifndef NO_MATHOMS
 PERL_CALLCONV HV*      Perl_pad_compname_type(pTHX_ const PADOFFSET po)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_PAD_COMPNAME_TYPE
 #endif
@@ -2900,6 +2733,8 @@ PERL_CALLCONV int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc
 PERL_CALLCONV int      perl_run(PerlInterpreter *my_perl);
 #define PERL_ARGS_ASSERT_PERL_RUN      \
        assert(my_perl)
+PERL_CALLCONV Signal_t Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe);
+#define PERL_ARGS_ASSERT_PERLY_SIGHANDLER
 PERL_CALLCONV void     Perl_pmop_dump(pTHX_ PMOP* pm);
 #define PERL_ARGS_ASSERT_PMOP_DUMP
 PERL_CALLCONV OP*      Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor);
@@ -3274,7 +3109,7 @@ PERL_CALLCONV char*       Perl_savepv(pTHX_ const char* pv)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SAVEPV
 
-PERL_CALLCONV char*    Perl_savepvn(pTHX_ const char* pv, I32 len)
+PERL_CALLCONV char*    Perl_savepvn(pTHX_ const char* pv, Size_t len)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SAVEPVN
@@ -3367,6 +3202,10 @@ PERL_CALLCONV void       Perl_setfd_inhexec_for_sysfd(pTHX_ int fd);
 PERL_CALLCONV HEK*     Perl_share_hek(pTHX_ const char* str, SSize_t len, U32 hash);
 #define PERL_ARGS_ASSERT_SHARE_HEK     \
        assert(str)
+PERL_CALLCONV Signal_t Perl_sighandler1(int sig);
+#define PERL_ARGS_ASSERT_SIGHANDLER1
+PERL_CALLCONV Signal_t Perl_sighandler3(int sig, Siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_SIGHANDLER3
 PERL_CALLCONV char*    Perl_skipspace_flags(pTHX_ char *s, U32 flags)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS       \
@@ -3429,7 +3268,7 @@ PERL_CALLCONV char*       Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
 #define PERL_ARGS_ASSERT_SV_2PV        \
        assert(sv)
 #endif
-PERL_CALLCONV char*    Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags);
+PERL_CALLCONV char*    Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS  \
        assert(sv)
 #ifndef NO_MATHOMS
@@ -3486,15 +3325,15 @@ PERL_CALLCONV SV*       Perl_sv_bless(pTHX_ SV *const sv, HV *const stash);
 PERL_CALLCONV bool     Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen);
 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \
        assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr)
-PERL_CALLCONV void     Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr);
+PERL_CALLCONV void     Perl_sv_catpv(pTHX_ SV *const dsv, const char* sstr);
 #define PERL_ARGS_ASSERT_SV_CATPV      \
-       assert(sv)
-PERL_CALLCONV void     Perl_sv_catpv_flags(pTHX_ SV *dstr, const char *sstr, const I32 flags);
+       assert(dsv)
+PERL_CALLCONV void     Perl_sv_catpv_flags(pTHX_ SV *dsv, const char *sstr, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS        \
-       assert(dstr); assert(sstr)
-PERL_CALLCONV void     Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr);
+       assert(dsv); assert(sstr)
+PERL_CALLCONV void     Perl_sv_catpv_mg(pTHX_ SV *const dsv, const char *const sstr);
 #define PERL_ARGS_ASSERT_SV_CATPV_MG   \
-       assert(sv)
+       assert(dsv)
 PERL_CALLCONV void     Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...)
                        __attribute__format__(__printf__,pTHX_2,pTHX_3);
 #define PERL_ARGS_ASSERT_SV_CATPVF     \
@@ -3510,24 +3349,24 @@ PERL_CALLCONV void      Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_CATPVN     \
        assert(dsv); assert(sstr)
 #endif
-PERL_CALLCONV void     Perl_sv_catpvn_flags(pTHX_ SV *const dstr, const char *sstr, const STRLEN len, const I32 flags);
+PERL_CALLCONV void     Perl_sv_catpvn_flags(pTHX_ SV *const dsv, const char *sstr, const STRLEN len, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS       \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(sstr)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
+PERL_CALLCONV void     Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_CATPVN_MG  \
-       assert(sv); assert(ptr)
+       assert(dsv); assert(sstr)
 #endif
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
+PERL_CALLCONV void     Perl_sv_catsv(pTHX_ SV *dsv, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_CATSV      \
-       assert(dstr)
+       assert(dsv)
 #endif
-PERL_CALLCONV void     Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags);
+PERL_CALLCONV void     Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const sstr, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS        \
        assert(dsv)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
+PERL_CALLCONV void     Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_CATSV_MG   \
        assert(dsv)
 #endif
@@ -3655,6 +3494,11 @@ PERL_CALLCONV void       Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN off
 PERL_CALLCONV int      Perl_sv_isa(pTHX_ SV* sv, const char *const name);
 #define PERL_ARGS_ASSERT_SV_ISA        \
        assert(name)
+PERL_CALLCONV bool     Perl_sv_isa_sv(pTHX_ SV* sv, SV* namesv)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_SV_ISA_SV     \
+       assert(sv); assert(namesv)
+
 PERL_CALLCONV int      Perl_sv_isobject(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SV_ISOBJECT
 #ifndef NO_MATHOMS
@@ -3772,7 +3616,7 @@ PERL_CALLCONV char*       Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp);
 #define PERL_ARGS_ASSERT_SV_PVN_FORCE  \
        assert(sv)
 #endif
-PERL_CALLCONV char*    Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags);
+PERL_CALLCONV char*    Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS    \
        assert(sv)
 #ifndef NO_MATHOMS
@@ -3899,16 +3743,16 @@ PERL_CALLCONV SV*       Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classn
 #define PERL_ARGS_ASSERT_SV_SETREF_UV  \
        assert(rv)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
+PERL_CALLCONV void     Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV      \
-       assert(dstr)
+       assert(dsv)
 #endif
-PERL_CALLCONV void     Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags);
+PERL_CALLCONV void     Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS        \
-       assert(dstr)
-PERL_CALLCONV void     Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr);
+       assert(dsv)
+PERL_CALLCONV void     Perl_sv_setsv_mg(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV_MG   \
-       assert(dstr)
+       assert(dsv)
 PERL_CALLCONV void     Perl_sv_setuv(pTHX_ SV *const sv, const UV num);
 #define PERL_ARGS_ASSERT_SV_SETUV      \
        assert(sv)
@@ -4023,14 +3867,6 @@ PERL_CALLCONV void       Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat,
 PERL_CALLCONV void     Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const Size_t sv_count, bool *const maybe_tainted);
 #define PERL_ARGS_ASSERT_SV_VSETPVFN   \
        assert(sv); assert(pat)
-PERL_CALLCONV UV       Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8);
-#define PERL_ARGS_ASSERT_SWASH_FETCH   \
-       assert(swash); assert(ptr)
-PERL_CALLCONV SV*      Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_SWASH_INIT    \
-       assert(pkg); assert(name); assert(listsv)
-
 PERL_CALLCONV void     Perl_switch_to_global_locale(void);
 #define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE
 PERL_CALLCONV bool     Perl_sync_locale(void);
@@ -4062,33 +3898,12 @@ PERL_CALLCONV SSize_t   Perl_tmps_grow_p(pTHX_ SSize_t ix);
 PERL_CALLCONV UV       Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UNI_LOWER  \
        assert(p); assert(lenp)
-#ifndef NO_MATHOMS
-PERL_CALLCONV U32      Perl_to_uni_lower_lc(pTHX_ U32 c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_TO_UNI_LOWER_LC
-#endif
-
 PERL_CALLCONV UV       Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UNI_TITLE  \
        assert(p); assert(lenp)
-#ifndef NO_MATHOMS
-PERL_CALLCONV U32      Perl_to_uni_title_lc(pTHX_ U32 c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_TO_UNI_TITLE_LC
-#endif
-
 PERL_CALLCONV UV       Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UNI_UPPER  \
        assert(p); assert(lenp)
-#ifndef NO_MATHOMS
-PERL_CALLCONV U32      Perl_to_uni_upper_lc(pTHX_ U32 c)
-                       __attribute__deprecated__
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_TO_UNI_UPPER_LC
-#endif
-
 PERL_CALLCONV bool     Perl_try_amagic_bin(pTHX_ int method, int flags);
 #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN
 PERL_CALLCONV bool     Perl_try_amagic_un(pTHX_ int method, int flags);
@@ -4110,10 +3925,10 @@ PERL_CALLCONV void      Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash);
 PERL_CALLCONV SV*      Perl_upg_version(pTHX_ SV *ver, bool qv);
 #define PERL_ARGS_ASSERT_UPG_VERSION   \
        assert(ver)
-PERL_CALLCONV U8*      Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen);
+PERL_CALLCONV U8*      Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, Size_t bytelen, Size_t *newlen);
 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \
        assert(p); assert(d); assert(newlen)
-PERL_CALLCONV U8*      Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen);
+PERL_CALLCONV U8*      Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, Size_t bytelen, Size_t *newlen);
 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED        \
        assert(p); assert(d); assert(newlen)
 #ifndef PERL_NO_INLINE_FUNCTIONS
@@ -4159,10 +3974,12 @@ PERL_CALLCONV STRLEN    Perl_utf8_length(pTHX_ const U8* s, const U8 *e)
 PERL_CALLCONV U8*      Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \
        assert(s); assert(lenp)
+#ifndef NO_MATHOMS
 PERL_CALLCONV UV       Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
                        __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \
        assert(s)
+#endif
 
 PERL_CALLCONV UV       Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen);
 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF     \
@@ -4195,9 +4012,13 @@ PERL_STATIC_INLINE UV    Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLE
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS   \
        assert(s)
 #endif
-PERL_CALLCONV UV       Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags);
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
+                       __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI        \
        assert(s)
+#endif
+
 PERL_CALLCONV void     Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg);
 #define PERL_ARGS_ASSERT_UTILIZE       \
        assert(idop)
@@ -4216,9 +4037,13 @@ PERL_CALLCONV U8*        Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, const UV
 PERL_CALLCONV U8*      Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \
        assert(d)
-PERL_CALLCONV U8*      Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags);
+#ifndef NO_MATHOMS
+PERL_CALLCONV U8*      Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
+                       __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS   \
        assert(d)
+#endif
+
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE UV  Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
                        __attribute__warn_unused_result__;
@@ -4357,6 +4182,13 @@ PERL_STATIC_INLINE void *        S_my_memrchr(const char * s, const char c, const STRLE
        assert(s)
 #endif
 #endif
+#if !(!defined(PERL_EXT_RE_BUILD))
+#  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+PERL_CALLCONV SV*      Perl_get_re_gclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist);
+#define PERL_ARGS_ASSERT_GET_RE_GCLASS_NONBITMAP_DATA  \
+       assert(node)
+#  endif
+#endif
 #if !(defined(DEBUGGING))
 #  if !defined(NV_PRESERVES_UV)
 #    if defined(PERL_IN_SV_C)
@@ -4376,23 +4208,16 @@ STATIC const char*      S_my_nl_langinfo(const int item, bool toggle);
 #define PERL_ARGS_ASSERT_MY_NL_LANGINFO
 #  endif
 #endif
-#if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
-PERL_CALLCONV Signal_t Perl_csighandler(int sig);
-#define PERL_ARGS_ASSERT_CSIGHANDLER
-PERL_CALLCONV Signal_t Perl_sighandler(int sig);
-#define PERL_ARGS_ASSERT_SIGHANDLER
-#endif
 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION))
 PERL_CALLCONV bool     Perl_do_exec(pTHX_ const char* cmd);
 #define PERL_ARGS_ASSERT_DO_EXEC       \
        assert(cmd)
 #endif
-#if !(defined(PERL_GLOBAL_STRUCT_PRIVATE))
-#  if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ int *indexp, size_t size);
-#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
-       assert(indexp)
-#  endif
+#if !(defined(PERL_USE_3ARG_SIGHANDLER))
+PERL_CALLCONV Signal_t Perl_csighandler(int sig);
+#define PERL_ARGS_ASSERT_CSIGHANDLER
+PERL_CALLCONV Signal_t Perl_sighandler(int sig);
+#define PERL_ARGS_ASSERT_SIGHANDLER
 #endif
 #if !(defined(_MSC_VER))
 PERL_CALLCONV_NO_RET int       Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
@@ -4454,10 +4279,12 @@ PERL_CALLCONV Size_t    Perl_my_strlcpy(char *dst, const char *src, Size_t size);
 #define PERL_ARGS_ASSERT_MY_STRLCPY
 #endif
 #if !defined(HAS_STRNLEN)
-PERL_CALLCONV Size_t   Perl_my_strnlen(const char *str, Size_t maxlen);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE Size_t      Perl_my_strnlen(const char *str, Size_t maxlen);
 #define PERL_ARGS_ASSERT_MY_STRNLEN    \
        assert(str)
 #endif
+#endif
 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP)
 PERL_CALLCONV I32      Perl_my_chsize(pTHX_ int fd, Off_t length)
                        __attribute__warn_unused_result__;
@@ -4509,9 +4336,6 @@ PERL_STATIC_INLINE void   S_invlist_clear(pTHX_ SV* invlist);
 #define PERL_ARGS_ASSERT_INVLIST_CLEAR \
        assert(invlist)
 #endif
-STATIC void    S_invlist_extend(pTHX_ SV* const invlist, const UV len);
-#define PERL_ARGS_ASSERT_INVLIST_EXTEND        \
-       assert(invlist)
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE UV  S_invlist_max(SV* const invlist)
                        __attribute__warn_unused_result__;
@@ -4530,11 +4354,6 @@ STATIC void      S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src);
 #define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC     \
        assert(dest); assert(src)
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset);
-#define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
-       assert(invlist)
-#endif
-#ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE void        S_invlist_set_previous_index(SV* const invlist, const IV index);
 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX    \
        assert(invlist)
@@ -4545,6 +4364,11 @@ PERL_STATIC_INLINE void  S_invlist_trim(SV* invlist);
        assert(invlist)
 #endif
 #  endif
+#  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+PERL_CALLCONV SV*      Perl_get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist);
+#define PERL_ARGS_ASSERT_GET_REGCLASS_NONBITMAP_DATA   \
+       assert(node)
+#  endif
 #endif
 #if !defined(PERL_IMPLICIT_SYS)
 PERL_CALLCONV I32      Perl_my_pclose(pTHX_ PerlIO* ptr);
@@ -4673,6 +4497,10 @@ STATIC void      S_validate_suid(pTHX_ PerlIO *rsfp);
        assert(rsfp)
 #  endif
 #endif
+#if !defined(USE_ITHREADS)
+/* PERL_CALLCONV void  CopFILEGV_set(pTHX_ COP * c, GV * gv); */
+#define PERL_ARGS_ASSERT_COPFILEGV_SET
+#endif
 #if !defined(UV_IS_QUAD)
 #  if defined(PERL_IN_UTF8_C)
 STATIC int     S_is_utf8_cp_above_31_bits(const U8 * const s, const U8 * const e, const bool consider_overlongs)
@@ -4750,7 +4578,7 @@ STATIC void       S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, H
 STATIC const regnode*  S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV* sv, I32 indent, U32 depth);
 #define PERL_ARGS_ASSERT_DUMPUNTIL     \
        assert(r); assert(start); assert(node); assert(sv)
-STATIC bool    S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV* nonbitmap_invlist, SV* only_utf8_locale_invlist, const regnode * const node, const bool force_as_is_display);
+STATIC bool    S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV* nonbitmap_invlist, SV* only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display);
 #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS  \
        assert(sv)
 STATIC SV*     S_put_charclass_bitmap_innards_common(pTHX_ SV* invlist, SV* posixes, SV* only_utf8, SV* not_utf8, SV* only_utf8_locale, const bool invert);
@@ -4854,12 +4682,6 @@ PERL_CALLCONV int        Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd)
        assert(pipefd)
 
 #endif
-#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
-PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap);
-#define PERL_ARGS_ASSERT_CSIGHANDLER
-PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap);
-#define PERL_ARGS_ASSERT_SIGHANDLER
-#endif
 #if defined(HAS_SOCKET)
 PERL_CALLCONV int      Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen)
                        __attribute__warn_unused_result__;
@@ -4899,9 +4721,9 @@ PERL_CALLCONV MEM_SIZE    Perl_malloced_size(void *p)
 
 #endif
 #if defined(PERL_ANY_COW)
-PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr);
+PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dsv, SV* ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV_COW  \
-       assert(sstr)
+       assert(ssv)
 #endif
 #if defined(PERL_CORE)
 PERL_CALLCONV void     Perl_opslab_force_free(pTHX_ OPSLAB *slab);
@@ -4997,25 +4819,6 @@ PERL_CALLCONV GV*        Perl_gv_SVadd(pTHX_ GV *gv);
 #define PERL_ARGS_ASSERT_GV_SVADD
 #endif
 #endif
-#if defined(PERL_GLOBAL_STRUCT)
-PERL_CALLCONV struct perl_vars *       Perl_GetVars(pTHX);
-#define PERL_ARGS_ASSERT_GETVARS
-PERL_CALLCONV void     Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp);
-#define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT    \
-       assert(plvarsp)
-PERL_CALLCONV struct perl_vars*        Perl_init_global_struct(pTHX);
-#define PERL_ARGS_ASSERT_INIT_GLOBAL_STRUCT
-#endif
-#if defined(PERL_GLOBAL_STRUCT_PRIVATE)
-#  if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV int      Perl_my_cxt_index(pTHX_ const char *my_cxt_key);
-#define PERL_ARGS_ASSERT_MY_CXT_INDEX  \
-       assert(my_cxt_key)
-PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size);
-#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
-       assert(my_cxt_key)
-#  endif
-#endif
 #if defined(PERL_IMPLICIT_CONTEXT)
 PERL_CALLCONV_NO_RET void      Perl_croak_nocontext(const char* pat, ...)
                        __attribute__noreturn__
@@ -5053,6 +4856,9 @@ PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...)
 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT        \
        assert(pat)
 
+PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ int *indexp, size_t size);
+#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
+       assert(indexp)
 PERL_CALLCONV SV*      Perl_newSVpvf_nocontext(const char *const pat, ...)
                        __attribute__format__(__printf__,1,2);
 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT    \
@@ -5136,35 +4942,30 @@ STATIC IO *     S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **s
        assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype)
 #endif
 #if defined(PERL_IN_DOOP_C)
-STATIC Size_t  S_do_trans_complex(pTHX_ SV * const sv)
+STATIC Size_t  S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX      \
-       assert(sv)
+       assert(sv); assert(tbl)
 
-STATIC Size_t  S_do_trans_complex_utf8(pTHX_ SV * const sv)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \
-       assert(sv)
-
-STATIC Size_t  S_do_trans_count(pTHX_ SV * const sv)
+STATIC Size_t  S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT        \
-       assert(sv)
+       assert(sv); assert(tbl)
 
-STATIC Size_t  S_do_trans_count_utf8(pTHX_ SV * const sv)
+STATIC Size_t  S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const map)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8   \
-       assert(sv)
+#define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \
+       assert(sv); assert(map)
 
-STATIC Size_t  S_do_trans_simple(pTHX_ SV * const sv)
+STATIC Size_t  S_do_trans_invmap(pTHX_ SV * const sv, AV * const map)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE       \
-       assert(sv)
+#define PERL_ARGS_ASSERT_DO_TRANS_INVMAP       \
+       assert(sv); assert(map)
 
-STATIC Size_t  S_do_trans_simple_utf8(pTHX_ SV * const sv)
+STATIC Size_t  S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8  \
-       assert(sv)
+#define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE       \
+       assert(sv); assert(tbl)
 
 #endif
 #if defined(PERL_IN_DUMP_C)
@@ -5209,9 +5010,6 @@ PERL_STATIC_INLINE HV*    S_gv_stashpvn_internal(pTHX_ const char* name, U32 namele
 #define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL  \
        assert(name)
 #endif
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags);
-#endif
 STATIC void    S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type);
 #define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV   \
        assert(gv); assert(name)
@@ -5227,6 +5025,9 @@ PERL_CALLCONV void        Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv);
 #define PERL_ARGS_ASSERT_SV_ADD_BACKREF        \
        assert(tsv); assert(sv)
 #endif
+#if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C)
+PERL_CALLCONV HV*      Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags);
+#endif
 #if defined(PERL_IN_HV_C)
 STATIC void    S_clear_placeholders(pTHX_ HV *hv, U32 items);
 #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS    \
@@ -5374,6 +5175,10 @@ STATIC AV*       S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level);
 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS        \
        assert(stash)
 #endif
+#if defined(PERL_IN_NUMERIC_C)
+STATIC void    S_output_non_portable(pTHX_ const U8 shift);
+#define PERL_ARGS_ASSERT_OUTPUT_NON_PORTABLE
+#endif
 #if defined(PERL_IN_OP_C)
 STATIC void    S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs);
 #define PERL_ARGS_ASSERT_APPLY_ATTRS   \
@@ -5627,13 +5432,6 @@ PERL_CALLCONV GV*        Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co
        assert(sv); assert(what); assert(spp)
 
 #endif
-#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE const char *        S_get_regex_charset_name(const U32 flags, STRLEN* const lenp);
-#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME        \
-       assert(lenp)
-#endif
-#endif
 #if defined(PERL_IN_PP_CTL_C)
 STATIC PerlIO *        S_check_type_and_open(pTHX_ SV *name)
                        __attribute__warn_unused_result__;
@@ -5730,6 +5528,14 @@ PERL_STATIC_INLINE HV*   S_opmethod_stash(pTHX_ SV* meth);
 #define PERL_ARGS_ASSERT_OPMETHOD_STASH        \
        assert(meth)
 #endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE bool  S_should_we_output_Debug_r(pTHX_ regexp * prog)
+                       __attribute__warn_unused_result__
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R      \
+       assert(prog)
+#endif
+
 #endif
 #if defined(PERL_IN_PP_PACK_C)
 STATIC int     S_div128(pTHX_ SV *pnum, bool *done);
@@ -5781,15 +5587,55 @@ STATIC SSize_t  S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const c
        assert(symptr); assert(s); assert(strbeg); assert(strend)
 #endif
 #if defined(PERL_IN_PP_SORT_C)
-STATIC I32     S_amagic_cmp(pTHX_ SV *const str1, SV *const str2);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_CMP    \
        assert(str1); assert(str2)
-STATIC I32     S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC       \
+       assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \
        assert(a); assert(b)
-STATIC I32     S_amagic_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_i_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC    \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_NCMP   \
        assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC      \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_cmp_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_CMP_DESC      \
+       assert(str1); assert(str2)
+#endif
+
 STATIC I32     S_sortcv(pTHX_ SV *const a, SV *const b);
 #define PERL_ARGS_ASSERT_SORTCV        \
        assert(a); assert(b)
@@ -5799,16 +5645,63 @@ STATIC I32      S_sortcv_stacked(pTHX_ SV *const a, SV *const b);
 STATIC I32     S_sortcv_xsub(pTHX_ SV *const a, SV *const b);
 #define PERL_ARGS_ASSERT_SORTCV_XSUB   \
        assert(a); assert(b)
-STATIC I32     S_sv_i_ncmp(pTHX_ SV *const a, SV *const b);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE void  S_sortsv_flags_impl(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL     \
+       assert(cmp)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_i_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_SV_I_NCMP     \
        assert(a); assert(b)
-STATIC I32     S_sv_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_i_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SV_I_NCMP_DESC        \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_SV_NCMP       \
        assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SV_NCMP_DESC  \
+       assert(a); assert(b)
+#endif
+
 #  if defined(USE_LOCALE_COLLATE)
-STATIC I32     S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE     \
        assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC        \
+       assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_CMP_LOCALE_DESC       \
+       assert(str1); assert(str2)
+#endif
+
 #  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C)
@@ -5819,20 +5712,9 @@ STATIC SV *      S_space_join_names_mortal(pTHX_ char *const *array);
 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL
 #endif
 #if defined(PERL_IN_REGCOMP_C)
-STATIC SV*     S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__MAKE_EXACTF_INVLIST  \
-       assert(pRExC_state); assert(node)
-
 STATIC void    S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist);
 #define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS        \
        assert(pRExC_state); assert(invlist)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST
-#endif
-
 STATIC U32     S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_ADD_DATA      \
@@ -5844,15 +5726,14 @@ STATIC AV*      S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, con
 STATIC void    S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size);
 #define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE    \
        assert(pRExC_state)
-STATIC const char *    S_cntrl_to_mnemonic(const U8 c)
+STATIC REGEXP* S_compile_wildcard(pTHX_ const char * subpattern, const STRLEN len, const bool ignore_case)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC
+#define PERL_ARGS_ASSERT_COMPILE_WILDCARD      \
+       assert(subpattern)
 
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE U8  S_compute_EXACTish(RExC_state_t *pRExC_state);
+STATIC U8      S_compute_EXACTish(RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
        assert(pRExC_state)
-#endif
 STATIC regnode *       S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth);
 #define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE       \
        assert(pRExC_state); assert(source)
@@ -5861,6 +5742,14 @@ STATIC int       S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const S
 #define PERL_ARGS_ASSERT_EDIT_DISTANCE \
        assert(src); assert(tgt)
 
+STATIC I32     S_execute_wildcard(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave);
+#define PERL_ARGS_ASSERT_EXECUTE_WILDCARD      \
+       assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE Size_t      S_find_first_differing_byte_pos(const U8 * s1, const U8 * s2, const Size_t max);
+#define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \
+       assert(s1); assert(s2)
+#endif
 STATIC SV *    S_get_ANYOFM_contents(pTHX_ const regnode * n)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS   \
@@ -5869,39 +5758,28 @@ STATIC SV *     S_get_ANYOFM_contents(pTHX_ const regnode * n)
 STATIC SV*     S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node);
 #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC     \
        assert(pRExC_state); assert(node)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE STRLEN*     S_get_invlist_iter_addr(SV* invlist)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
-       assert(invlist)
-#endif
-
 STATIC bool    S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset* nodep, UV *code_point_p, int* cp_count, I32 *flagp, const bool strict, const U32 depth);
 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \
        assert(pRExC_state); assert(flagp)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE regnode_offset      S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch);
+STATIC regnode_offset  S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch);
 #define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF  \
        assert(pRExC_state); assert(flagp); assert(parse_start)
-#endif
+STATIC bool    S_handle_names_wildcard(pTHX_ const char * wname, const STRLEN wname_len, SV ** prop_definition, AV ** strings);
+#define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \
+       assert(wname); assert(prop_definition); assert(strings)
 STATIC int     S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char* const s, char ** updated_parse_ptr, AV** posix_warnings, const bool check_only);
 #define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \
        assert(pRExC_state); assert(s)
 STATIC regnode_offset  S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse);
 #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS     \
        assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
-PERL_CALLCONV SV *     Perl_handle_user_defined_property(pTHX_ const char * name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV* contents, bool *user_defined_ptr, SV * msg, const STRLEN level);
+STATIC SV *    S_handle_user_defined_property(pTHX_ const char * name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV* contents, bool *user_defined_ptr, SV * msg, const STRLEN level);
 #define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY  \
        assert(name); assert(contents); assert(user_defined_ptr); assert(msg)
-STATIC SV*     S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_INVLIST_CONTENTS      \
-       assert(invlist)
-
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE UV  S_invlist_highest(SV* const invlist)
+PERL_STATIC_INLINE SV* S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style)
                        __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_INVLIST_HIGHEST       \
+#define PERL_ARGS_ASSERT_INVLIST_CONTENTS      \
        assert(invlist)
 #endif
 
@@ -5913,19 +5791,11 @@ PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist)
 #endif
 
 #ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_invlist_iterfinish(SV* invlist);
-#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH    \
-       assert(invlist)
-#endif
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_invlist_iterinit(SV* invlist);
-#define PERL_ARGS_ASSERT_INVLIST_ITERINIT      \
+PERL_STATIC_INLINE UV  S_invlist_lowest(SV* const invlist)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_INVLIST_LOWEST        \
        assert(invlist)
 #endif
-STATIC bool    S_invlist_iternext(SV* invlist, UV* start, UV* end)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT      \
-       assert(invlist); assert(start); assert(end)
 
 STATIC bool    S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc);
 #define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT       \
@@ -5933,6 +5803,11 @@ STATIC bool      S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ss
 STATIC U32     S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth);
 #define PERL_ARGS_ASSERT_JOIN_EXACT    \
        assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char)
+STATIC SV*     S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST   \
+       assert(pRExC_state); assert(node)
+
 STATIC I32     S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth);
 #define PERL_ARGS_ASSERT_MAKE_TRIE     \
        assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
@@ -5950,16 +5825,20 @@ STATIC void     S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_w
 STATIC void    S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS   \
        assert(pRExC_state)
-PERL_CALLCONV SV *     Perl_parse_uniprop_string(pTHX_ const char * const name, const Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, bool * user_defined_ptr, SV * msg, const STRLEN level);
+STATIC SV *    S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV ** strings, bool * user_defined_ptr, SV * msg, const STRLEN level);
 #define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING  \
        assert(name); assert(user_defined_ptr); assert(msg)
 STATIC void    S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr);
 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST   \
        assert(node); assert(invlist_ptr)
-PERL_STATIC_NO_RET void        S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...)
-                       __attribute__noreturn__;
-#define PERL_ARGS_ASSERT_RE_CROAK2     \
-       assert(pat1); assert(pat2)
+STATIC void    S_rck_elide_nothing(pTHX_ regnode *node);
+#define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING     \
+       assert(node)
+PERL_STATIC_NO_RET void        S_re_croak(pTHX_ bool utf8, const char* pat, ...)
+                       __attribute__noreturn__
+                       __attribute__format__(__printf__,pTHX_2,pTHX_3);
+#define PERL_ARGS_ASSERT_RE_CROAK      \
+       assert(pat)
 
 STATIC regnode_offset  S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth);
 #define PERL_ARGS_ASSERT_REG   \
@@ -6003,6 +5882,9 @@ STATIC regnode_offset     S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 o
 STATIC regnode_offset  S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth);
 #define PERL_ARGS_ASSERT_REGPIECE      \
        assert(pRExC_state); assert(flagp)
+STATIC regnode_offset  S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV * arg);
+#define PERL_ARGS_ASSERT_REGPNODE      \
+       assert(pRExC_state); assert(arg)
 STATIC bool    S_regtail(pTHX_ RExC_state_t * pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_REGTAIL       \
@@ -6020,38 +5902,30 @@ STATIC void     S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx);
 STATIC void    S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char ** p, const bool force_to_xmod);
 #define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT       \
        assert(pRExC_state); assert(p)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end);
+STATIC void    S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end);
 #define PERL_ARGS_ASSERT_SSC_ADD_RANGE \
        assert(ssc)
-#endif
 STATIC void    S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with);
 #define PERL_ARGS_ASSERT_SSC_AND       \
        assert(pRExC_state); assert(ssc); assert(and_with)
 STATIC void    S_ssc_anything(pTHX_ regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_ANYTHING  \
        assert(ssc)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_clear_locale(regnode_ssc *ssc);
+STATIC void    S_ssc_clear_locale(regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE      \
        assert(ssc)
-#endif
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp);
+STATIC void    S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp);
 #define PERL_ARGS_ASSERT_SSC_CP_AND    \
        assert(ssc)
-#endif
 STATIC void    S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_FINALIZE  \
        assert(pRExC_state); assert(ssc)
 STATIC void    S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_INIT      \
        assert(pRExC_state); assert(ssc)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
+STATIC void    S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
 #define PERL_ARGS_ASSERT_SSC_INTERSECTION      \
        assert(ssc); assert(invlist)
-#endif
 STATIC int     S_ssc_is_anything(const regnode_ssc *ssc)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING       \
@@ -6065,20 +5939,127 @@ STATIC int     S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnod
 STATIC void    S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with);
 #define PERL_ARGS_ASSERT_SSC_OR        \
        assert(pRExC_state); assert(ssc); assert(or_with)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
+STATIC void    S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
 #define PERL_ARGS_ASSERT_SSC_UNION     \
        assert(ssc); assert(invlist)
-#endif
-STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth);
+STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok);
 #define PERL_ARGS_ASSERT_STUDY_CHUNK   \
        assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
 #endif
-#if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C)
+#if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C) || defined(PERL_IN_OP_C)
 PERL_CALLCONV void     Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist);
 #define PERL_ARGS_ASSERT__INVLIST_DUMP \
        assert(file); assert(indent); assert(invlist)
 #endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        S_invlist_extend(pTHX_ SV* const invlist, const UV len);
+#define PERL_ARGS_ASSERT_INVLIST_EXTEND        \
+       assert(invlist)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE UV  S_invlist_highest(SV* const invlist)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_INVLIST_HIGHEST       \
+       assert(invlist)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset);
+#define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
+       assert(invlist)
+#endif
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_UTF8_C)
+PERL_CALLCONV SV*      Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST
+
+/* PERL_CALLCONV void  _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */
+#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION
+PERL_CALLCONV void     Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i);
+#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND    \
+       assert(b); assert(i)
+PERL_CALLCONV void     Perl__invlist_invert(pTHX_ SV* const invlist);
+#define PERL_ARGS_ASSERT__INVLIST_INVERT       \
+       assert(invlist)
+/* PERL_CALLCONV void  _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */
+#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT
+/* PERL_CALLCONV void  _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */
+#define PERL_ARGS_ASSERT__INVLIST_UNION
+PERL_CALLCONV void     Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output);
+#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND   \
+       assert(b); assert(output)
+PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__NEW_INVLIST
+
+PERL_CALLCONV SV*      Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \
+       assert(other_elements_ptr)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV const char *     Perl_form_alien_digit_msg(pTHX_ const U8 which, const STRLEN valids_len, const char * const first_bad, const char * const send, const bool UTF, const bool braced)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG  \
+       assert(first_bad); assert(send)
+
+PERL_CALLCONV bool     Perl_grok_bslash_c(pTHX_ const char source, U8 * result, const char** message, U32 * packed_warn)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GROK_BSLASH_C \
+       assert(result); assert(message)
+
+PERL_CALLCONV bool     Perl_grok_bslash_o(pTHX_ char** s, const char* const send, UV* uv, const char** message, U32 * packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
+       assert(s); assert(send); assert(uv); assert(message)
+
+PERL_CALLCONV bool     Perl_grok_bslash_x(pTHX_ char** s, const char* const send, UV* uv, const char** message, U32 * packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
+       assert(s); assert(send); assert(uv); assert(message)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C)
+PERL_CALLCONV const char *     Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char * string, const Size_t len, const UV cp)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE STRLEN*     S_get_invlist_iter_addr(SV* invlist)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
+       assert(invlist)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        S_invlist_iterfinish(SV* invlist);
+#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH    \
+       assert(invlist)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE void        S_invlist_iterinit(SV* invlist);
+#define PERL_ARGS_ASSERT_INVLIST_ITERINIT      \
+       assert(invlist)
+#endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE bool        S_invlist_iternext(SV* invlist, UV* start, UV* end)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT      \
+       assert(invlist); assert(start); assert(end)
+#endif
+
+#endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C)
 PERL_CALLCONV bool     Perl__invlistEQ(pTHX_ SV* const a, SV* const b, const bool complement_b);
 #define PERL_ARGS_ASSERT__INVLISTEQ    \
@@ -6089,18 +6070,24 @@ PERL_CALLCONV SV*       Perl__new_invlist_C_array(pTHX_ const UV* const list)
        assert(list)
 
 #endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE const char *        S_get_regex_charset_name(const U32 flags, STRLEN* const lenp);
+#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME        \
+       assert(lenp)
+#endif
+#endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV SV*      Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist);
-#define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA  \
-       assert(node)
-PERL_CALLCONV int      Perl_re_printf(pTHX_ const char *fmt, ...);
+PERL_CALLCONV int      Perl_re_printf(pTHX_ const char *fmt, ...)
+                       __attribute__format__(__printf__,pTHX_1,pTHX_2);
 #define PERL_ARGS_ASSERT_RE_PRINTF     \
        assert(fmt)
+
 PERL_CALLCONV void     Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_REGPROP       \
        assert(sv); assert(o)
 #endif
-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C)
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)    || defined(PERL_IN_PP_C) || defined(PERL_IN_OP_C)               || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C)           || defined(PERL_IN_DOOP_C)
 #ifndef PERL_NO_INLINE_FUNCTIONS
 PERL_STATIC_INLINE bool        S__invlist_contains_cp(SV* const invlist, const UV cp)
                        __attribute__warn_unused_result__;
@@ -6141,69 +6128,28 @@ PERL_STATIC_INLINE bool S_is_invlist(SV* const invlist)
 #endif
 
 #endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV bool     Perl_is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, const U8 *strend, const UV cp)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_IS_GRAPHEME   \
+       assert(strbeg); assert(s); assert(strend)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
+PERL_CALLCONV UV       Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags);
+#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1       \
+       assert(p); assert(lenp)
+#endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_SV_C)
 PERL_CALLCONV SV*      Perl_invlist_clone(pTHX_ SV* const invlist, SV* newlist);
 #define PERL_ARGS_ASSERT_INVLIST_CLONE \
        assert(invlist)
 #endif
-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_DQUOTE_C)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE char*       S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING      \
-       assert(s)
-#endif
-
-PERL_CALLCONV char     Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_GROK_BSLASH_C
-
-PERL_CALLCONV bool     Perl_grok_bslash_o(pTHX_ char** s, const char* const send, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
-       assert(s); assert(send); assert(uv); assert(error_msg)
-
-PERL_CALLCONV bool     Perl_grok_bslash_x(pTHX_ char** s, const char* const send, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
-       assert(s); assert(send); assert(uv); assert(error_msg)
-
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE I32 S_regcurly(const char *s)
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV bool     Perl_regcurly(const char *s)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_REGCURLY      \
        assert(s)
-#endif
-
-#endif
-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
-PERL_CALLCONV SV*      Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST
-
-/* PERL_CALLCONV void  _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */
-#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION
-PERL_CALLCONV void     Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i);
-#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND    \
-       assert(b); assert(i)
-PERL_CALLCONV void     Perl__invlist_invert(pTHX_ SV* const invlist);
-#define PERL_ARGS_ASSERT__INVLIST_INVERT       \
-       assert(invlist)
-/* PERL_CALLCONV void  _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */
-#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT
-/* PERL_CALLCONV void  _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */
-#define PERL_ARGS_ASSERT__INVLIST_UNION
-PERL_CALLCONV void     Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output);
-#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND   \
-       assert(b); assert(output)
-PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__NEW_INVLIST
-
-PERL_CALLCONV SV*      Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \
-       assert(other_elements_ptr)
 
 #endif
 #if defined(PERL_IN_REGEXEC_C)
@@ -6348,13 +6294,6 @@ STATIC void      S_to_utf8_substr(pTHX_ regexp * prog);
 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR        \
        assert(prog)
 #endif
-#if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C)
-PERL_CALLCONV bool     Perl__is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, const U8 *strend, const UV cp)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT__IS_GRAPHEME  \
-       assert(strbeg); assert(s); assert(strend)
-
-#endif
 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
 PERL_CALLCONV bool     Perl_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
                        __attribute__warn_unused_result__;
@@ -6398,9 +6337,9 @@ STATIC SV*        S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit
 STATIC bool    S_glob_2number(pTHX_ GV* const gv);
 #define PERL_ARGS_ASSERT_GLOB_2NUMBER  \
        assert(gv)
-STATIC void    S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype);
+STATIC void    S_glob_assign_glob(pTHX_ SV *const dsv, SV *const ssv, const int dtype);
 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB      \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(ssv)
 STATIC SV *    S_more_sv(pTHX);
 #define PERL_ARGS_ASSERT_MORE_SV
 STATIC void    S_not_a_number(pTHX_ SV *const sv);
@@ -6457,10 +6396,10 @@ STATIC I32      S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask);
 #define PERL_ARGS_ASSERT_VISIT \
        assert(f)
 #  if defined(USE_ITHREADS)
-STATIC SV*     S_sv_dup_common(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+STATIC SV*     S_sv_dup_common(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP_COMMON \
-       assert(sstr); assert(param)
+       assert(ssv); assert(param)
 
 STATIC SV **   S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param);
 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE   \
@@ -6612,12 +6551,11 @@ STATIC int      S_yywarn(pTHX_ const char *const s, U32 flags);
        assert(s)
 #endif
 #if defined(PERL_IN_UNIVERSAL_C)
-STATIC bool    S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags);
-#define PERL_ARGS_ASSERT_ISA_LOOKUP    \
-       assert(stash); assert(name)
+STATIC bool    S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char * name, STRLEN len, U32 flags);
+STATIC bool    S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char * name, const STRLEN len, U32 flags);
 #endif
 #if defined(PERL_IN_UTF8_C)
-STATIC UV      S__to_utf8_case(pTHX_ const UV uv1, const U8 *p, U8* ustrp, STRLEN *lenp, SV *invlist, const int * const invmap, const unsigned int * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal);
+STATIC UV      S__to_utf8_case(pTHX_ const UV uv1, const U8 *p, U8* ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal);
 #define PERL_ARGS_ASSERT__TO_UTF8_CASE \
        assert(ustrp); assert(lenp); assert(invlist); assert(invmap); assert(normal)
 STATIC UV      S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
@@ -6640,16 +6578,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
 
@@ -6665,16 +6596,6 @@ STATIC HV *      S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 f
 #define PERL_ARGS_ASSERT_NEW_MSG_HV    \
        assert(message)
 
-STATIC U8*     S_swash_scan_list_line(pTHX_ U8* l, U8* const lend, UV* min, UV* max, UV* val, const bool wants_value, const U8* const typestr)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_SWASH_SCAN_LIST_LINE  \
-       assert(l); assert(lend); assert(min); assert(max); assert(val); assert(typestr)
-
-STATIC SV*     S_swatch_get(pTHX_ SV* swash, UV start, UV span)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_SWATCH_GET    \
-       assert(swash)
-
 STATIC U8      S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_TO_LOWER_LATIN1
@@ -6699,11 +6620,6 @@ PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *le
 #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1        \
        assert(p); assert(lenp)
 #endif
-#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV UV       Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags);
-#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1       \
-       assert(p); assert(lenp)
-#endif
 #if defined(PERL_IN_UTIL_C)
 STATIC bool    S_ckwarn_common(pTHX_ U32 w);
 #define PERL_ARGS_ASSERT_CKWARN_COMMON
@@ -6738,6 +6654,12 @@ PERL_CALLCONV Malloc_t   Perl_mem_log_realloc(const UV n, const UV typesize, const
 STATIC void    S_pidgone(pTHX_ Pid_t pid, int status);
 #define PERL_ARGS_ASSERT_PIDGONE
 #endif
+#if defined(PERL_USE_3ARG_SIGHANDLER)
+PERL_CALLCONV Signal_t Perl_csighandler(int sig, Siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_CSIGHANDLER
+PERL_CALLCONV Signal_t Perl_sighandler(int sig, Siginfo_t *info, void *uap);
+#define PERL_ARGS_ASSERT_SIGHANDLER
+#endif
 #if defined(UNLINK_ALL_VERSIONS)
 PERL_CALLCONV I32      Perl_unlnk(pTHX_ const char* f);
 #define PERL_ARGS_ASSERT_UNLNK \
@@ -6852,9 +6774,9 @@ PERL_CALLCONV void        Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLON
 PERL_CALLCONV void*    Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param);
 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL      \
        assert(r); assert(param)
-PERL_CALLCONV void     Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param);
+PERL_CALLCONV void     Perl_rvpv_dup(pTHX_ SV *const dsv, const SV *const ssv, CLONE_PARAMS *const param);
 #define PERL_ARGS_ASSERT_RVPV_DUP      \
-       assert(dstr); assert(sstr); assert(param)
+       assert(dsv); assert(ssv); assert(param)
 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SI_DUP        \
@@ -6865,12 +6787,12 @@ PERL_CALLCONV ANY*      Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS*
 #define PERL_ARGS_ASSERT_SS_DUP        \
        assert(proto_perl); assert(param)
 
-PERL_CALLCONV SV*      Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+PERL_CALLCONV SV*      Perl_sv_dup(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP        \
        assert(param)
 
-PERL_CALLCONV SV*      Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+PERL_CALLCONV SV*      Perl_sv_dup_inc(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP_INC    \
        assert(param)
@@ -6881,6 +6803,9 @@ PERL_CALLCONV bool        Perl__is_cur_LC_category_utf8(pTHX_ int category);
 #define PERL_ARGS_ASSERT__IS_CUR_LC_CATEGORY_UTF8
 #endif
 #if defined(USE_LOCALE_COLLATE)
+PERL_CALLCONV int      Perl_magic_freecollxfrm(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM    \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM     \
        assert(sv); assert(mg)
@@ -6967,8 +6892,8 @@ PERL_CALLCONV SSize_t     Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_
 PERL_CALLCONV bool     Perl_quadmath_format_needed(const char* format);
 #define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED        \
        assert(format)
-PERL_CALLCONV const char*      Perl_quadmath_format_single(const char* format);
-#define PERL_ARGS_ASSERT_QUADMATH_FORMAT_SINGLE        \
+PERL_CALLCONV bool     Perl_quadmath_format_valid(const char* format);
+#define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \
        assert(format)
 #endif
 #if defined(WIN32)
@@ -6978,7 +6903,7 @@ PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname)
        assert(fname)
 
 #endif
-#if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS)
+#if defined(WIN32) || defined(VMS)
 PERL_CALLCONV int      Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp);
 #define PERL_ARGS_ASSERT_DO_ASPAWN     \
        assert(mark); assert(sp)
Unnamed repository; edit this file 'description' to name the repository.