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
perldelta for vstrings and set-magic
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index ba75b64..63d1c9c 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -23,10 +23,49 @@ PERL_CALLCONV int   Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
        assert(stash)
 
 PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);
-PERL_CALLCONV bool     Perl__is_utf8__perl_idstart(pTHX_ const U8 *p)
+PERL_CALLCONV_NO_RET void      Perl_croak_memory_wrap(void)
+                       __attribute__noreturn__;
+
+PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV void     Perl_Slab_Free(pTHX_ void *op)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_FREE     \
+       assert(op)
+
+PERL_CALLCONV bool     Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV bool     Perl__is_uni_perl_idcont(pTHX_ UV c)
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV bool     Perl__is_uni_perl_idstart(pTHX_ UV c)
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV bool     Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT__IS_UTF8_FOO  \
+       assert(p)
+
+PERL_CALLCONV bool     Perl__is_utf8_mark(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_MARK \
+       assert(p)
+
+PERL_CALLCONV bool     Perl__is_utf8_perl_idcont(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT  \
+       assert(p)
+
+PERL_CALLCONV bool     Perl__is_utf8_perl_idstart(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__IS_UTF8__PERL_IDSTART        \
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
        assert(p)
 
 PERL_CALLCONV UV       Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const U8 flags)
@@ -129,6 +168,13 @@ PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, I32 key)
 #define PERL_ARGS_ASSERT_AV_EXTEND     \
        assert(av)
 
+PERL_CALLCONV void     Perl_av_extend_guts(pTHX_ AV *av, I32 key, SSize_t *maxp, SV ***allocp, SV ***arrayp)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4)
+                       __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_AV_EXTEND_GUTS        \
+       assert(maxp); assert(allocp); assert(arrayp)
+
 PERL_CALLCONV SV**     Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -184,6 +230,16 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
 #define PERL_ARGS_ASSERT_AV_STORE      \
        assert(av)
 
+/* PERL_CALLCONV I32   Perl_av_tindex(pTHX_ AV *av)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1); */
+
+PERL_STATIC_INLINE I32 S_av_top_index(pTHX_ AV *av)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_AV_TOP_INDEX  \
+       assert(av)
+
 PERL_CALLCONV void     Perl_av_undef(pTHX_ AV *av)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_UNDEF      \
@@ -303,12 +359,6 @@ PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_BITOP      \
        assert(o)
 
-PERL_CALLCONV OP *     Perl_ck_chdir(pTHX_ OP *o)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_CHDIR      \
-       assert(o)
-
 PERL_CALLCONV OP *     Perl_ck_cmp(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -620,29 +670,35 @@ PERL_CALLCONV SV *        Perl_core_prototype(pTHX_ SV *sv, const char *name, const int
 #define PERL_ARGS_ASSERT_CORE_PROTOTYPE        \
        assert(name)
 
-PERL_CALLCONV OP *     Perl_coresub_op(pTHX_ SV *coreargssv, const int code, const int opnum)
+PERL_CALLCONV OP *     Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CORESUB_OP    \
        assert(coreargssv)
 
 PERL_CALLCONV PERL_CONTEXT*    Perl_create_eval_scope(pTHX_ U32 flags);
-PERL_CALLCONV void     Perl_croak(pTHX_ const char* pat, ...)
+PERL_CALLCONV_NO_RET void      Perl_croak(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 
-PERL_CALLCONV void     Perl_croak_no_modify(pTHX)
+PERL_CALLCONV_NO_RET void      Perl_croak_no_mem(void)
+                       __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void      Perl_croak_no_modify(void)
+                       __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void      Perl_croak_popstack(void)
                        __attribute__noreturn__;
 
-PERL_CALLCONV void     Perl_croak_sv(pTHX_ SV *baseex)
+PERL_CALLCONV_NO_RET void      Perl_croak_sv(pTHX_ SV *baseex)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CROAK_SV      \
        assert(baseex)
 
-PERL_CALLCONV void     Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params)
+PERL_CALLCONV_NO_RET void      Perl_croak_xs_usage(const CV *const cv, const char *const params)
                        __attribute__noreturn__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE        \
        assert(cv); assert(params)
 
@@ -681,9 +737,20 @@ PERL_CALLCONV CV*  Perl_cv_clone(pTHX_ CV* proto)
 #define PERL_ARGS_ASSERT_CV_CLONE      \
        assert(proto)
 
+PERL_CALLCONV CV*      Perl_cv_clone_into(pTHX_ CV* proto, CV *target)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CV_CLONE_INTO \
+       assert(proto); assert(target)
+
 PERL_CALLCONV SV*      Perl_cv_const_sv(pTHX_ const CV *const cv)
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV void     Perl_cv_forget_slab(pTHX_ CV *cv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_FORGET_SLAB        \
+       assert(cv)
+
 PERL_CALLCONV void     Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -755,7 +822,7 @@ PERL_CALLCONV OP*   Perl_die_sv(pTHX_ SV *baseex)
 #define PERL_ARGS_ASSERT_DIE_SV        \
        assert(baseex)
 
-PERL_CALLCONV void     Perl_die_unwind(pTHX_ SV* msv)
+PERL_CALLCONV_NO_RET void      Perl_die_unwind(pTHX_ SV* msv)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_DIE_UNWIND    \
@@ -1020,9 +1087,13 @@ PERL_CALLCONV void       Perl_finalize_optree(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_FINALIZE_OPTREE       \
        assert(o)
 
+PERL_CALLCONV CV *     Perl_find_lexical_cv(pTHX_ PADOFFSET off);
 PERL_CALLCONV CV*      Perl_find_runcv(pTHX_ U32 *db_seqp)
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV CV*      Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV SV*      Perl_find_rundefsv(pTHX);
 PERL_CALLCONV SV*      Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq)
                        __attribute__nonnull__(pTHX_1);
@@ -1099,8 +1170,10 @@ PERL_CALLCONV void       Perl_get_db_sub(pTHX_ SV **svp, CV *cv)
 #define PERL_ARGS_ASSERT_GET_DB_SUB    \
        assert(cv)
 
-PERL_CALLCONV UV       Perl_get_hash_seed(pTHX)
-                       __attribute__warn_unused_result__;
+PERL_CALLCONV void     Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_HASH_SEED \
+       assert(seed_buffer)
 
 PERL_CALLCONV HV*      Perl_get_hv(pTHX_ const char *name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
@@ -1476,12 +1549,12 @@ PERL_CALLCONV void      Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len,
 #define PERL_ARGS_ASSERT_HV_FETCH_ENT  \
        assert(keysv)
 
-PERL_CALLCONV STRLEN   Perl_hv_fill(pTHX_ HV const *const hv)
+PERL_CALLCONV STRLEN   Perl_hv_fill(pTHX_ HV *const hv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_FILL       \
        assert(hv)
 
-PERL_CALLCONV void     Perl_hv_free_ent(pTHX_ HV *hv, HE *entryK)
+PERL_CALLCONV void     Perl_hv_free_ent(pTHX_ HV *hv, HE *entry)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_FREE_ENT   \
        assert(hv)
@@ -1563,6 +1636,11 @@ PERL_CALLCONV void       Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph)
 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET   \
        assert(hv)
 
+PERL_CALLCONV void     Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_HV_RAND_SET   \
+       assert(hv)
+
 PERL_CALLCONV I32*     Perl_hv_riter_p(pTHX_ HV *hv)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -1602,6 +1680,7 @@ PERL_CALLCONV void        Perl_init_argv_symbols(pTHX_ int argc, char **argv)
 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS     \
        assert(argv)
 
+PERL_CALLCONV void     Perl_init_constants(pTHX);
 PERL_CALLCONV void     Perl_init_dbargs(pTHX);
 PERL_CALLCONV void     Perl_init_debugger(pTHX);
 PERL_CALLCONV int      Perl_init_i18nl10n(pTHX_ int printwarn);
@@ -1629,6 +1708,22 @@ PERL_CALLCONV bool       Perl_io_close(pTHX_ IO* io, bool not_implicit)
 #define PERL_ARGS_ASSERT_IO_CLOSE      \
        assert(io)
 
+PERL_STATIC_INLINE bool        S_isALNUM_lazy(pTHX_ const char* p)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_ISALNUM_LAZY  \
+       assert(p)
+
+PERL_STATIC_INLINE bool        S_isIDFIRST_lazy(pTHX_ const char* p)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_ISIDFIRST_LAZY        \
+       assert(p)
+
 PERL_CALLCONV bool     Perl_is_ascii_string(const U8 *s, STRLEN len)
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_ASCII_STRING       \
@@ -1638,187 +1733,190 @@ PERL_CALLCONV I32     Perl_is_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV bool     Perl_is_uni_alnum(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_alnum_lc(pTHX_ UV c)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
+PERL_CALLCONV bool     Perl_is_uni_alnumc(pTHX_ UV c)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
+PERL_CALLCONV bool     Perl_is_uni_alnumc_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_alpha(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_alpha_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_ascii(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_ascii_lc(pTHX_ UV c)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
+PERL_CALLCONV bool     Perl_is_uni_blank(pTHX_ UV c)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
+PERL_CALLCONV bool     Perl_is_uni_blank_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_cntrl(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_cntrl_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_digit(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_digit_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_graph(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_graph_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_idfirst(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_idfirst_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_lower(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_lower_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_print(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_print_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_punct(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_punct_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_space(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_space_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_upper(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_upper_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_xdigit(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_xdigit_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
-PERL_CALLCONV bool     Perl_is_utf8_X_L(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_L   \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_LV(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LV  \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_LVT(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V    \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_T(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_T   \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_V(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_V   \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_begin(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN       \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_extend(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND      \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL  \
-       assert(p)
-
-PERL_CALLCONV bool     Perl_is_utf8_X_prepend(pTHX_ const U8 *p)
+PERL_CALLCONV bool     Perl_is_utf8_alnum(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND     \
+#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \
        assert(p)
 
-PERL_CALLCONV bool     Perl_is_utf8_alnum(pTHX_ const U8 *p)
+PERL_CALLCONV bool     Perl_is_utf8_alnumc(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \
+#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_alpha(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_ascii(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \
        assert(p)
 
+PERL_CALLCONV bool     Perl_is_utf8_blank(pTHX_ const U8 *p)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_BLANK \
+       assert(p)
+
 PERL_CALLCONV STRLEN   Perl_is_utf8_char(const U8 *s)
                        __attribute__deprecated__
                        __attribute__nonnull__(1);
@@ -1832,78 +1930,91 @@ PERL_CALLCONV STRLEN    Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
        assert(buf); assert(buf_end)
 
 PERL_CALLCONV bool     Perl_is_utf8_cntrl(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_digit(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_graph(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_idcont(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_idfirst(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST       \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_lower(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_mark(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_MARK  \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_perl_space(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE    \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_perl_word(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD     \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT   \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_print(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_punct(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_space(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \
@@ -1925,24 +2036,28 @@ PERL_CALLCONV bool      Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8
        assert(s)
 
 PERL_CALLCONV bool     Perl_is_utf8_upper(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xdigit(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xidcont(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT       \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xidfirst(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST      \
@@ -2026,6 +2141,12 @@ PERL_CALLCONV int        Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg)
 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV   \
        assert(sv); assert(mg)
 
+PERL_CALLCONV int      Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P   \
+       assert(sv); assert(mg)
+
 PERL_CALLCONV int      Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -2159,13 +2280,7 @@ PERL_CALLCONV int        Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS    \
        assert(sv); assert(mg)
 
-PERL_CALLCONV U32      Perl_magic_len(pTHX_ SV* sv, MAGIC* mg)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_LEN     \
-       assert(sv); assert(mg)
-
-PERL_CALLCONV SV*      Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...)
+PERL_CALLCONV SV*      Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -2191,13 +2306,6 @@ PERL_CALLCONV int        Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg)
 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET    \
        assert(sv); assert(mg)
 
-PERL_CALLCONV int      Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
-                       __attribute__noreturn__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
-       assert(sv); assert(mg)
-
 PERL_CALLCONV SV*      Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -2317,12 +2425,6 @@ PERL_CALLCONV int        Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg)
 #define PERL_ARGS_ASSERT_MAGIC_SETVEC  \
        assert(sv); assert(mg)
 
-PERL_CALLCONV int      Perl_magic_setvstring(pTHX_ SV* sv, MAGIC* mg)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_SETVSTRING      \
-       assert(sv); assert(mg)
-
 PERL_CALLCONV U32      Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -2385,6 +2487,7 @@ PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv)
        assert(sv)
 
 PERL_CALLCONV U32      Perl_mg_length(pTHX_ SV* sv)
+                       __attribute__deprecated__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_MG_LENGTH     \
        assert(sv)
@@ -2494,10 +2597,10 @@ PERL_CALLCONV OP *      Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 
 PERL_CALLCONV void     Perl_my_clearenv(pTHX);
 PERL_CALLCONV int      Perl_my_dirfd(pTHX_ DIR* dir);
-PERL_CALLCONV void     Perl_my_exit(pTHX_ U32 status)
+PERL_CALLCONV_NO_RET void      Perl_my_exit(pTHX_ U32 status)
                        __attribute__noreturn__;
 
-PERL_CALLCONV void     Perl_my_failure_exit(pTHX)
+PERL_CALLCONV_NO_RET void      Perl_my_failure_exit(pTHX)
                        __attribute__noreturn__;
 
 PERL_CALLCONV I32      Perl_my_fflush_all(pTHX);
@@ -2526,11 +2629,6 @@ PERL_CALLCONV char *     Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, i
 #define PERL_ARGS_ASSERT_MY_STRFTIME   \
        assert(fmt)
 
-PERL_CALLCONV void     Perl_my_swabn(void* ptr, int n)
-                       __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_MY_SWABN      \
-       assert(ptr)
-
 PERL_CALLCONV void     Perl_my_unexec(pTHX);
 PERL_CALLCONV int      Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)
                        __attribute__nonnull__(1)
@@ -2663,6 +2761,11 @@ PERL_CALLCONV OP*        Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP*
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV CV *     Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_NEWMYSUB      \
+       assert(o)
+
 PERL_CALLCONV OP*      Perl_newNULLLIST(pTHX)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -2714,6 +2817,11 @@ PERL_CALLCONV OP*        Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV CV*      Perl_newSTUB(pTHX_ GV *gv, bool fake)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWSTUB       \
+       assert(gv)
+
 /* PERL_CALLCONV CV*   Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */
 PERL_CALLCONV SV*      Perl_newSV(pTHX_ const STRLEN len)
                        __attribute__malloc__
@@ -2910,6 +3018,7 @@ PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
 PERL_CALLCONV void     Perl_op_refcnt_lock(pTHX);
 PERL_CALLCONV void     Perl_op_refcnt_unlock(pTHX);
 PERL_CALLCONV OP*      Perl_op_scope(pTHX_ OP* o);
+PERL_CALLCONV OP*      Perl_op_unscope(pTHX_ OP* o);
 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__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -2982,7 +3091,7 @@ PERL_CALLCONV void        Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv
        assert(padlist); assert(old_cv); assert(new_cv)
 
 PERL_CALLCONV void     Perl_pad_free(pTHX_ PADOFFSET po);
-PERL_CALLCONV void     Perl_pad_leavemy(pTHX);
+PERL_CALLCONV OP *     Perl_pad_leavemy(pTHX);
 PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -2994,6 +3103,11 @@ PERL_CALLCONV void       Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
 
 PERL_CALLCONV void     Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust);
 PERL_CALLCONV void     Perl_pad_tidy(pTHX_ padtidy_type type);
+PERL_CALLCONV PAD **   Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADLIST_STORE \
+       assert(padlist)
+
 PERL_CALLCONV OP*      Perl_parse_arithexpr(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_barestmt(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_block(pTHX_ U32 flags);
@@ -3138,19 +3252,20 @@ PERL_CALLCONV REGEXP*   Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flag
 #define PERL_ARGS_ASSERT_RE_COMPILE    \
        assert(pattern)
 
-PERL_CALLCONV char*    Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data)
+PERL_CALLCONV char*    Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, const char* const strbeg, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(pTHX_4)
+                       __attribute__nonnull__(pTHX_5);
 #define PERL_ARGS_ASSERT_RE_INTUIT_START       \
-       assert(rx); assert(strpos); assert(strend)
+       assert(rx); assert(strbeg); assert(strpos); assert(strend)
 
 PERL_CALLCONV SV*      Perl_re_intuit_string(pTHX_ REGEXP  *const r)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING      \
        assert(r)
 
-PERL_CALLCONV REGEXP*  Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *VOL old_re, int *is_bare_re, U32 rx_flags, U32 pm_flags)
+PERL_CALLCONV REGEXP*  Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, U32 rx_flags, U32 pm_flags)
                        __attribute__nonnull__(pTHX_4);
 #define PERL_ARGS_ASSERT_RE_OP_COMPILE \
        assert(eng)
@@ -3279,11 +3394,6 @@ PERL_CALLCONV void       Perl_regdump(pTHX_ const regexp* r)
 #define PERL_ARGS_ASSERT_REGDUMP       \
        assert(r)
 
-PERL_CALLCONV void     Perl_regdump(pTHX_ const regexp* r)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_REGDUMP       \
-       assert(r)
-
 PERL_CALLCONV I32      Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -3847,29 +3957,22 @@ PERL_CALLCONV I32       Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2);
 PERL_CALLCONV I32      Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
 PERL_CALLCONV I32      Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
 PERL_CALLCONV I32      Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
-PERL_CALLCONV OP*      Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
-                       __attribute__deprecated__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_SV_COMPILE_2OP        \
-       assert(sv); assert(startop); assert(code); assert(padp)
-
-PERL_CALLCONV OP*      Perl_sv_compile_2op_is_broken(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
+/* PERL_CALLCONV void  Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_SV_COMPILE_2OP_IS_BROKEN      \
-       assert(sv); assert(startop); assert(code); assert(padp)
+                       __attribute__nonnull__(pTHX_2); */
+#define PERL_ARGS_ASSERT_SV_COPYPV     \
+       assert(dsv); assert(ssv)
 
-PERL_CALLCONV void     Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
+PERL_CALLCONV void     Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_COPYPV     \
+#define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS       \
        assert(dsv); assert(ssv)
 
+/* PERL_CALLCONV void  Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2); */
+
 PERL_CALLCONV void     Perl_sv_dec(pTHX_ SV *const sv);
 PERL_CALLCONV void     Perl_sv_dec_nomg(pTHX_ SV *const sv);
 PERL_CALLCONV void     Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv)
@@ -3953,7 +4056,7 @@ PERL_CALLCONV void        Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flag
        assert(sv)
 
 PERL_CALLCONV void     Perl_sv_free(pTHX_ SV *const sv);
-PERL_CALLCONV void     Perl_sv_free2(pTHX_ SV *const sv)
+PERL_CALLCONV void     Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_FREE2      \
        assert(sv)
@@ -3965,11 +4068,6 @@ PERL_CALLCONV char*      Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 appen
 #define PERL_ARGS_ASSERT_SV_GETS       \
        assert(sv); assert(fp)
 
-PERL_CALLCONV bool     Perl_sv_gmagical_2iv_please(pTHX_ SV *sv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SV_GMAGICAL_2IV_PLEASE        \
-       assert(sv)
-
 PERL_CALLCONV char*    Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_GROW       \
@@ -4002,6 +4100,11 @@ PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv)
 
 PERL_CALLCONV STRLEN   Perl_sv_len(pTHX_ SV *const sv);
 PERL_CALLCONV STRLEN   Perl_sv_len_utf8(pTHX_ SV *const sv);
+PERL_CALLCONV STRLEN   Perl_sv_len_utf8_nomg(pTHX_ SV *const sv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG      \
+       assert(sv)
+
 PERL_CALLCONV void     Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_MAGIC      \
@@ -4012,7 +4115,11 @@ PERL_CALLCONV MAGIC *    Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const
 #define PERL_ARGS_ASSERT_SV_MAGICEXT   \
        assert(sv)
 
-PERL_CALLCONV SV*      Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
+/* PERL_CALLCONV SV*   Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__; */
+
+PERL_CALLCONV SV*      Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
@@ -4133,6 +4240,7 @@ PERL_CALLCONV void        Perl_sv_reset(pTHX_ const char* s, HV *const stash)
 #define PERL_ARGS_ASSERT_SV_RESET      \
        assert(s)
 
+PERL_CALLCONV void     Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash);
 PERL_CALLCONV SV*      Perl_sv_rvweaken(pTHX_ SV *const sv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_RVWEAKEN   \
@@ -4377,6 +4485,12 @@ PERL_CALLCONV void       Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, c
 #define PERL_ARGS_ASSERT_SV_VCATPVFN   \
        assert(sv); assert(pat)
 
+PERL_CALLCONV void     Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS     \
+       assert(sv); assert(pat)
+
 PERL_CALLCONV void     Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -4429,7 +4543,7 @@ PERL_CALLCONV void        Perl_taint_proper(pTHX_ const char* f, const char *const s)
 #define PERL_ARGS_ASSERT_TAINT_PROPER  \
        assert(s)
 
-PERL_CALLCONV OP *     Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
+PERL_CALLCONV OP *     Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
@@ -4449,6 +4563,7 @@ PERL_CALLCONV UV  Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_lower_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4459,6 +4574,7 @@ PERL_CALLCONV UV  Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_title_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4469,6 +4585,7 @@ PERL_CALLCONV UV  Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_upper_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4616,23 +4733,23 @@ PERL_CALLCONV U8*       Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS   \
        assert(d)
 
-PERL_CALLCONV UV       Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR   \
-       assert(s)
-
 PERL_CALLCONV UV       Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI   \
        assert(s)
 
+PERL_CALLCONV bool     Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_VALIDATE_PROTO        \
+       assert(name)
+
 PERL_CALLCONV int      Perl_vcmp(pTHX_ SV *lhv, SV *rhv)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_VCMP  \
        assert(lhv); assert(rhv)
 
-PERL_CALLCONV void     Perl_vcroak(pTHX_ const char* pat, va_list* args)
+PERL_CALLCONV_NO_RET void      Perl_vcroak(pTHX_ const char* pat, va_list* args)
                        __attribute__noreturn__;
 
 PERL_CALLCONV void     Perl_vdeb(pTHX_ const char* pat, va_list* args)
@@ -4813,6 +4930,11 @@ STATIC int       S_sv_2iuv_non_preserve(pTHX_ SV *const sv)
 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \
        assert(d)
 
+/* PERL_CALLCONV UV    Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
+                       __attribute__nonnull__(pTHX_1); */
+#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR   \
+       assert(s)
+
 #endif
 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
 PERL_CALLCONV Signal_t Perl_csighandler(int sig);
@@ -4839,9 +4961,6 @@ PERL_CALLCONV void*       Perl_my_cxt_init(pTHX_ int *index, size_t size)
 #endif
 #if !(defined(PERL_MAD))
 PERL_CALLCONV void     Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV void     Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
-                       __attribute__noreturn__;
-
 PERL_CALLCONV void     Perl_package(pTHX_ OP* o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PACKAGE       \
@@ -4853,14 +4972,14 @@ PERL_CALLCONV void      Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop
        assert(idop)
 
 #endif
-#if !(defined(USE_ITHREADS))
-#  if defined(PERL_IN_OP_C)
-STATIC void    S_forget_pmop(pTHX_ PMOP *const o)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP   \
-       assert(o)
+#if !(defined(_MSC_VER))
+PERL_CALLCONV_NO_RET int       Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
+                       __attribute__noreturn__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
+       assert(sv); assert(mg)
 
-#  endif
 #endif
 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
 PERL_CALLCONV char*    Perl_my_bzero(char* loc, I32 len)
@@ -5074,6 +5193,7 @@ STATIC void       S_put_byte(pTHX_ SV* sv, int c)
        assert(sv)
 
 STATIC void    S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
+STATIC void    S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
 STATIC U8      S_regtail_study(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -5147,6 +5267,11 @@ PERL_CALLCONV U8*        Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \
        assert(d)
 
+PERL_CALLCONV UV       Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR   \
+       assert(s)
+
 #endif
 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 PERL_CALLCONV I32      Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp)
@@ -5223,25 +5348,50 @@ PERL_CALLCONV MEM_SIZE  Perl_malloced_size(void *p)
        assert(p)
 
 #endif
-#if defined(MYSWAP)
-PERL_CALLCONV long     Perl_my_htonl(pTHX_ long l)
-                       __attribute__malloc__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
+#if defined(NO_MATHOMS)
+/* PERL_CALLCONV void  Perl_sv_nounlocking(pTHX_ SV *sv); */
+#endif
+#if defined(PERL_ANY_COW)
+PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_SETSV_COW  \
+       assert(sstr)
 
-PERL_CALLCONV long     Perl_my_ntohl(pTHX_ long l)
-                       __attribute__malloc__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
+#endif
+#if defined(PERL_CORE)
+PERL_CALLCONV void     Perl_opslab_force_free(pTHX_ OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE     \
+       assert(slab)
 
-PERL_CALLCONV short    Perl_my_swap(pTHX_ short s)
-                       __attribute__malloc__
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
+PERL_CALLCONV void     Perl_opslab_free(pTHX_ OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FREE   \
+       assert(slab)
 
-#endif
-#if defined(NO_MATHOMS)
-/* PERL_CALLCONV void  Perl_sv_nounlocking(pTHX_ SV *sv); */
+PERL_CALLCONV void     Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD     \
+       assert(slab)
+
+PERL_CALLCONV void     Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS      \
+       assert(parser); assert(slab)
+
+#  if defined(PERL_DEBUG_READONLY_OPS)
+PERL_CALLCONV void     Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_TO_RO    \
+       assert(slab)
+
+PERL_CALLCONV void     Perl_Slab_to_rw(pTHX_ OPSLAB *const slab)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_TO_RW    \
+       assert(slab)
+
+#  endif
 #endif
 #if defined(PERL_CR_FILTER)
 #  if defined(PERL_IN_TOKE_C)
@@ -5254,24 +5404,12 @@ STATIC void     S_strip_return(pTHX_ SV *sv)
 #  endif
 #endif
 #if defined(PERL_DEBUG_READONLY_OPS)
-#  if defined(PERL_IN_OP_C)
-#    if defined(PL_OP_SLAB_ALLOC)
-STATIC void    S_Slab_to_rw(pTHX_ void *op)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SLAB_TO_RW    \
-       assert(op)
-
-#    endif
-#  endif
-#  if defined(PL_OP_SLAB_ALLOC)
 PERL_CALLCONV PADOFFSET        Perl_op_refcnt_dec(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \
        assert(o)
 
 PERL_CALLCONV OP *     Perl_op_refcnt_inc(pTHX_ OP *o);
-PERL_CALLCONV void     Perl_pending_Slabs_to_ro(pTHX);
-#  endif
 #endif
 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
 /* PERL_CALLCONV bool  Perl_do_exec(pTHX_ const char* cmd)
@@ -5305,7 +5443,7 @@ PERL_CALLCONV void*       Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size)
 #  endif
 #endif
 #if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV void     Perl_croak_nocontext(const char* pat, ...)
+PERL_CALLCONV_NO_RET void      Perl_croak_nocontext(const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,1,2);
 
@@ -5488,27 +5626,6 @@ STATIC I32       S_do_trans_simple_utf8(pTHX_ SV * const sv)
        assert(sv)
 
 #endif
-#if defined(PERL_IN_DQUOTE_STATIC_C)
-STATIC char    S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
-                       __attribute__warn_unused_result__;
-
-STATIC bool    S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
-       assert(s); assert(uv); assert(len); assert(error_msg)
-
-PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s)
-                       __attribute__warn_unused_result__
-                       __attribute__pure__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_REGCURLY      \
-       assert(s)
-
-#endif
 #if defined(PERL_IN_DUMP_C)
 STATIC CV*     S_deb_curcv(pTHX_ const I32 ix);
 STATIC void    S_debprof(pTHX_ const OP *o)
@@ -5540,11 +5657,6 @@ PERL_CALLCONV void       Perl_hv_kill_backrefs(pTHX_ HV *hv)
 
 #endif
 #if defined(PERL_IN_GV_C)
-STATIC HV*     S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen, U32 flags)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_GET_SUPER_PKG      \
-       assert(name)
-
 STATIC void    S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE        \
@@ -5583,21 +5695,22 @@ STATIC void     S_hfreeentries(pTHX_ HV *hv)
 #define PERL_ARGS_ASSERT_HFREEENTRIES  \
        assert(hv)
 
-STATIC void    S_hsplit(pTHX_ HV *hv)
+STATIC void    S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HSPLIT        \
        assert(hv)
 
-STATIC struct xpvhv_aux*       S_hv_auxinit(HV *hv)
-                       __attribute__nonnull__(1);
+STATIC struct xpvhv_aux*       S_hv_auxinit(pTHX_ HV *hv)
+                       __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_AUXINIT    \
        assert(hv)
 
 STATIC SV*     S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
-STATIC SV*     S_hv_free_ent_ret(pTHX_ HV *hv, HE *entryK)
-                       __attribute__nonnull__(pTHX_1);
+STATIC SV*     S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET       \
-       assert(hv)
+       assert(hv); assert(entry)
 
 STATIC void    S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store)
                        __attribute__nonnull__(1)
@@ -5606,7 +5719,7 @@ STATIC void       S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store)
 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK        \
        assert(hv); assert(needs_copy); assert(needs_store)
 
-STATIC void    S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
+PERL_STATIC_NO_RET void        S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_4);
@@ -5617,6 +5730,7 @@ STATIC HE*        S_new_he(pTHX)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u);
 STATIC SV *    S_refcounted_he_value(pTHX_ const struct refcounted_he *he)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE   \
@@ -5654,6 +5768,7 @@ PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp)
 #endif
 #if defined(PERL_IN_LOCALE_C)
 #  if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE)
+STATIC bool    S_is_cur_LC_category_utf8(pTHX_ int category);
 STATIC char*   S_stdize_locale(pTHX_ char* locs)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \
@@ -5662,14 +5777,14 @@ STATIC char*    S_stdize_locale(pTHX_ char* locs)
 #  endif
 #endif
 #if defined(PERL_IN_MG_C)
-STATIC SV*     S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, int n, SV *val)
+STATIC SV*     S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_MAGIC_METHCALL1       \
        assert(sv); assert(mg); assert(meth)
 
-STATIC int     S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
+STATIC int     S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -5677,9 +5792,9 @@ STATIC int        S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
        assert(sv); assert(mg); assert(meth)
 
 STATIC void    S_restore_magic(pTHX_ const void *p);
-STATIC void    S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
+STATIC void    S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
                        __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SAVE_MAGIC    \
+#define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS      \
        assert(sv)
 
 STATIC void    S_unwind_handler_stack(pTHX_ const void *p);
@@ -5717,7 +5832,7 @@ STATIC NV S_mulexp10(NV value, I32 exponent);
 #endif
 #if defined(PERL_IN_OP_C)
 PERL_STATIC_INLINE bool        S_aassign_common_vars(pTHX_ OP* o);
-STATIC void    S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
+STATIC void    S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_APPLY_ATTRS   \
@@ -5730,19 +5845,19 @@ STATIC void     S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp
 #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY        \
        assert(stash); assert(target); assert(imopsp)
 
-STATIC void    S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid)
+STATIC void    S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_BAD_TYPE_PV   \
-       assert(t); assert(name); assert(kid)
+#define PERL_ARGS_ASSERT_BAD_TYPE_GV   \
+       assert(t); assert(gv); assert(kid)
 
-STATIC void    S_bad_type_sv(pTHX_ I32 n, const char *t, SV *namesv, U32 flags, const OP *kid)
+STATIC void    S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_BAD_TYPE_SV   \
-       assert(t); assert(namesv); assert(kid)
+#define PERL_ARGS_ASSERT_BAD_TYPE_PV   \
+       assert(t); assert(name); assert(kid)
 
 STATIC void    S_cop_free(pTHX_ COP *cop)
                        __attribute__nonnull__(pTHX_1);
@@ -5770,6 +5885,11 @@ STATIC OP*       S_fold_constants(pTHX_ OP *o)
        assert(o)
 
 STATIC OP*     S_force_list(pTHX_ OP* arg);
+STATIC void    S_forget_pmop(pTHX_ PMOP *const o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FORGET_PMOP   \
+       assert(o)
+
 STATIC OP*     S_gen_constant_list(pTHX_ OP* o);
 STATIC SV*     S_gv_ename(pTHX_ GV *gv)
                        __attribute__nonnull__(pTHX_1);
@@ -5838,11 +5958,6 @@ PERL_STATIC_INLINE OP*   S_op_std_init(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_OP_STD_INIT   \
        assert(o)
 
-STATIC OP*     S_opt_scalarhv(pTHX_ OP* rep_op)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_OPT_SCALARHV  \
-       assert(rep_op)
-
 STATIC OP*     S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -5850,10 +5965,10 @@ STATIC OP*      S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl)
 #define PERL_ARGS_ASSERT_PMTRANS       \
        assert(o); assert(expr); assert(repl)
 
-STATIC void    S_process_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
-                       __attribute__nonnull__(pTHX_1)
+STATIC void    S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
                        __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS        \
        assert(fullname); assert(gv); assert(cv)
 
@@ -5907,13 +6022,6 @@ STATIC OP*       S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
        assert(o); assert(namesv)
 
-#  if defined(USE_ITHREADS)
-STATIC void    S_forget_pmop(pTHX_ PMOP *const o, U32 flags)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP   \
-       assert(o)
-
-#  endif
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C)
 PERL_CALLCONV void     Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp)
@@ -5977,10 +6085,10 @@ STATIC SV*      S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags)
 #define PERL_ARGS_ASSERT_MAYBERELOCATE \
        assert(dir)
 
-STATIC void    S_minus_v(pTHX)
+PERL_STATIC_NO_RET void        S_minus_v(pTHX)
                        __attribute__noreturn__;
 
-STATIC void    S_my_exit_jump(pTHX)
+PERL_STATIC_NO_RET void        S_my_exit_jump(pTHX)
                        __attribute__noreturn__;
 
 STATIC void    S_nuke_stacks(pTHX);
@@ -5991,10 +6099,10 @@ STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool
        assert(scriptname); assert(suidscript)
 
 STATIC void*   S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
-STATIC void    S_run_body(pTHX_ I32 oldscope)
+PERL_STATIC_NO_RET void        S_run_body(pTHX_ I32 oldscope)
                        __attribute__noreturn__;
 
-STATIC void    S_usage(pTHX)
+PERL_STATIC_NO_RET void        S_usage(pTHX)
                        __attribute__noreturn__;
 
 #endif
@@ -6046,7 +6154,7 @@ STATIC OP*        S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copie
 STATIC OP*     S_docatch(pTHX_ OP *o)
                        __attribute__warn_unused_result__;
 
-STATIC bool    S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq, HV* hh);
+STATIC bool    S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh);
 STATIC OP*     S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
@@ -6101,10 +6209,10 @@ STATIC bool     S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv)
 STATIC bool    S_num_overflow(NV value, I32 fldsize, I32 frcsize)
                        __attribute__warn_unused_result__;
 
-STATIC bool    S_path_is_absolute(const char *name)
+PERL_STATIC_INLINE bool        S_path_is_searchable(const char *name)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_PATH_IS_ABSOLUTE      \
+#define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE    \
        assert(name)
 
 STATIC I32     S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen)
@@ -6131,12 +6239,11 @@ STATIC void     S_save_lines(pTHX_ AV *array, SV *sv)
 
 #endif
 #if defined(PERL_IN_PP_HOT_C)
-STATIC void    S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
+STATIC void    S_do_oddball(pTHX_ SV **oddkey, SV **firstkey)
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_DO_ODDBALL    \
-       assert(hash); assert(relem); assert(firstrelem)
+       assert(oddkey); assert(firstkey)
 
 STATIC SV*     S_method_common(pTHX_ SV* meth, U32* hashp)
                        __attribute__warn_unused_result__
@@ -6146,7 +6253,7 @@ STATIC SV*        S_method_common(pTHX_ SV* meth, U32* hashp)
 
 #endif
 #if defined(PERL_IN_PP_PACK_C)
-STATIC char *  S_bytes_to_uni(const U8 *start, STRLEN len, char *dest)
+STATIC char *  S_bytes_to_uni(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3);
@@ -6321,12 +6428,6 @@ STATIC SV*       S__new_invlist_C_array(pTHX_ UV* list)
 #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY  \
        assert(list)
 
-STATIC void    S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_ADD_ALTERNATE \
-       assert(alternate_ptr); assert(string)
-
 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
                        __attribute__warn_unused_result__;
 
@@ -6337,10 +6438,12 @@ STATIC U32      S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s)
 #define PERL_ARGS_ASSERT_ADD_DATA      \
        assert(pRExC_state); assert(s)
 
-STATIC void    S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CHECKPOSIXCC  \
-       assert(pRExC_state)
+PERL_STATIC_INLINE void        S_alloc_maybe_populate_EXACT(pTHX_ struct RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT    \
+       assert(pRExC_state); assert(node); assert(flagp)
 
 STATIC void    S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with)
                        __attribute__nonnull__(1)
@@ -6373,16 +6476,26 @@ STATIC void     S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charc
 #define PERL_ARGS_ASSERT_CL_OR \
        assert(pRExC_state); assert(cl); assert(or_with)
 
+PERL_STATIC_INLINE U8  S_compute_EXACTish(pTHX_ struct RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
+       assert(pRExC_state)
+
+STATIC bool    S_could_it_be_a_POSIX_class(pTHX_ struct RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS     \
+       assert(pRExC_state)
+
 PERL_STATIC_INLINE UV* S_get_invlist_iter_addr(pTHX_ SV* invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
        assert(invlist)
 
-PERL_STATIC_INLINE UV* S_get_invlist_len_addr(pTHX_ SV* invlist)
+PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_LEN_ADDR  \
+#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR       \
        assert(invlist)
 
 PERL_STATIC_INLINE UV* S_get_invlist_version_id_addr(pTHX_ SV* invlist)
@@ -6397,6 +6510,19 @@ PERL_STATIC_INLINE UV*   S_get_invlist_zero_addr(pTHX_ SV* invlist)
 #define PERL_ARGS_ASSERT_GET_INVLIST_ZERO_ADDR \
        assert(invlist)
 
+STATIC bool    S_grok_bslash_N(pTHX_ struct RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
+       assert(pRExC_state); assert(flagp)
+
+STATIC regnode*        S_handle_regex_sets(pTHX_ struct RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS     \
+       assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
+
 PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6414,6 +6540,23 @@ STATIC void      S_invlist_extend(pTHX_ SV* const invlist, const UV len)
 #define PERL_ARGS_ASSERT_INVLIST_EXTEND        \
        assert(invlist)
 
+PERL_STATIC_INLINE UV  S_invlist_highest(pTHX_ SV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_HIGHEST       \
+       assert(invlist)
+
+PERL_STATIC_INLINE bool        S_invlist_is_iterating(pTHX_ SV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING  \
+       assert(invlist)
+
+PERL_STATIC_INLINE void        S_invlist_iterfinish(pTHX_ SV* invlist)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH    \
+       assert(invlist)
+
 PERL_STATIC_INLINE void        S_invlist_iterinit(pTHX_ SV* invlist)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INVLIST_ITERINIT      \
@@ -6427,22 +6570,16 @@ STATIC bool     S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
 #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT      \
        assert(invlist); assert(start); assert(end)
 
-PERL_STATIC_INLINE UV  S_invlist_len(pTHX_ SV* const invlist)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_LEN   \
-       assert(invlist)
-
 PERL_STATIC_INLINE UV  S_invlist_max(pTHX_ SV* const invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INVLIST_MAX   \
        assert(invlist)
 
-STATIC IV      S_invlist_search(pTHX_ SV* const invlist, const UV cp)
+PERL_STATIC_INLINE IV  S_invlist_previous_index(pTHX_ SV* const invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_SEARCH        \
+#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX        \
        assert(invlist)
 
 PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ SV* const invlist, const UV len)
@@ -6450,6 +6587,11 @@ PERL_STATIC_INLINE void  S_invlist_set_len(pTHX_ SV* const invlist, const UV len)
 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
        assert(invlist)
 
+PERL_STATIC_INLINE void        S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX    \
+       assert(invlist)
+
 PERL_STATIC_INLINE void        S_invlist_trim(pTHX_ SV* const invlist)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INVLIST_TRIM  \
@@ -6484,7 +6626,12 @@ STATIC char *    S_nextchar(pTHX_ struct RExC_state_t *pRExC_state)
 #define PERL_ARGS_ASSERT_NEXTCHAR      \
        assert(pRExC_state)
 
-STATIC void    S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
+STATIC void    S_parse_lparen_question_flags(pTHX_ struct RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS   \
+       assert(pRExC_state)
+
+PERL_STATIC_NO_RET void        S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -6497,11 +6644,6 @@ STATIC regnode*  S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *fl
 #define PERL_ARGS_ASSERT_REG   \
        assert(pRExC_state); assert(flagp)
 
-STATIC regnode*        S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp, U32 depth)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_REG_NAMEDSEQ  \
-       assert(pRExC_state)
-
 STATIC regnode*        S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_NODE      \
@@ -6539,10 +6681,11 @@ STATIC regnode* S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp,
 #define PERL_ARGS_ASSERT_REGBRANCH     \
        assert(pRExC_state); assert(flagp)
 
-STATIC regnode*        S_regclass(pTHX_ struct RExC_state_t *pRExC_state, U32 depth)
-                       __attribute__nonnull__(pTHX_1);
+STATIC regnode*        S_regclass(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, SV** ret_invlist)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGCLASS      \
-       assert(pRExC_state)
+       assert(pRExC_state); assert(flagp)
 
 STATIC void    S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
                        __attribute__nonnull__(pTHX_1)
@@ -6550,13 +6693,20 @@ STATIC void     S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *
 #define PERL_ARGS_ASSERT_REGINSERT     \
        assert(pRExC_state); assert(opnd)
 
+STATIC char *  S_regpatws(struct RExC_state_t *pRExC_state, char *p, const bool recognize_comment)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_REGPATWS      \
+       assert(pRExC_state); assert(p)
+
 STATIC regnode*        S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGPIECE      \
        assert(pRExC_state); assert(flagp)
 
-STATIC I32     S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, const bool strict)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGPPOSIXCC   \
        assert(pRExC_state)
@@ -6588,22 +6738,6 @@ STATIC void      S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct s
 #define PERL_ARGS_ASSERT_SCAN_COMMIT   \
        assert(pRExC_state); assert(data); assert(minlenp)
 
-PERL_STATIC_INLINE U8  S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_4)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT      \
-       assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
-
-STATIC U8      S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_4)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \
-       assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
-
 STATIC I32     S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -6615,18 +6749,91 @@ STATIC I32      S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp
 
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-PERL_CALLCONV SV*      Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, bool return_if_undef, SV* invlist, bool passed_in_invlist_has_user_defined_property)
+PERL_STATIC_INLINE UV* S__get_invlist_len_addr(pTHX_ SV* invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__GET_INVLIST_LEN_ADDR \
+       assert(invlist)
+
+PERL_CALLCONV SV*      Perl__get_swash_invlist(pTHX_ SV* const swash)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__GET_SWASH_INVLIST    \
+       assert(swash)
+
+PERL_STATIC_INLINE bool        S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP  \
+       assert(invlist)
+
+PERL_CALLCONV SV*      Perl__invlist_contents(pTHX_ SV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_CONTENTS     \
+       assert(invlist)
+
+PERL_STATIC_INLINE UV  S__invlist_len(pTHX_ SV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_LEN  \
+       assert(invlist)
+
+PERL_CALLCONV IV       Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_SEARCH       \
+       assert(invlist)
+
+PERL_CALLCONV HV*      Perl__swash_inversion_hash(pTHX_ SV* const swash)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
+       assert(swash)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV SV*      Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT__CORE_SWASH_INIT      \
        assert(pkg); assert(name); assert(listsv)
 
-PERL_CALLCONV SV*      Perl__invlist_contents(pTHX_ SV* const invlist)
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C)
+STATIC char*   S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len)
                        __attribute__warn_unused_result__
+                       __attribute__pure__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__INVLIST_CONTENTS     \
-       assert(invlist)
+#define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING      \
+       assert(s)
+
+STATIC char    S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
+                       __attribute__warn_unused_result__;
+
+STATIC bool    S_grok_bslash_o(pTHX_ char** s, 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__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
+       assert(s); assert(uv); assert(error_msg)
+
+PERL_STATIC_INLINE bool        S_grok_bslash_x(pTHX_ char** s, 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__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
+       assert(s); assert(uv); assert(error_msg)
+
+PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped)
+                       __attribute__warn_unused_result__
+                       __attribute__pure__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_REGCURLY      \
+       assert(s)
 
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
@@ -6678,12 +6885,6 @@ PERL_CALLCONV void       Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, S
 PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV HV*      Perl__swash_inversion_hash(pTHX_ SV* const swash)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
-       assert(swash)
-
 PERL_CALLCONV SV*      Perl__swash_to_invlist(pTHX_ SV* const swash)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6692,7 +6893,7 @@ PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash)
 
 #endif
 #if defined(PERL_IN_REGEXEC_C)
-STATIC SV*     S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp)
+STATIC SV*     S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH   \
@@ -6707,6 +6908,15 @@ STATIC char*     S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, cons
 #define PERL_ARGS_ASSERT_FIND_BYCLASS  \
        assert(prog); assert(c); assert(s); assert(strend)
 
+STATIC bool    S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
+                       __attribute__warn_unused_result__;
+
+STATIC bool    S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \
+       assert(character)
+
 STATIC I32     S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
@@ -6714,12 +6924,17 @@ STATIC I32      S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode
 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED  \
        assert(rex); assert(scan)
 
-STATIC char*   S_regcppop(pTHX_ const regexp *rex)
-                       __attribute__nonnull__(pTHX_1);
+STATIC void    S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGCPPOP      \
+       assert(rex); assert(maxopenparen_p)
+
+STATIC CHECKPOINT      S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_REGCPPUSH     \
        assert(rex)
 
-STATIC CHECKPOINT      S_regcppush(pTHX_ I32 parenfloor);
 STATIC U8*     S_reghop3(U8 *s, I32 off, const U8 *lim)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
@@ -6734,35 +6949,38 @@ STATIC U8*      S_reghopmaybe3(U8 *s, I32 off, const U8 *lim)
 #define PERL_ARGS_ASSERT_REGHOPMAYBE3  \
        assert(s); assert(lim)
 
-STATIC bool    S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, STRLEN *lenp, bool const do_utf8sv_is_utf8)
+STATIC bool    S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, bool const utf8_target)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGINCLASS    \
        assert(n); assert(p)
 
-STATIC I32     S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
+STATIC I32     S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGMATCH      \
-       assert(reginfo); assert(prog)
+       assert(reginfo); assert(startpos); assert(prog)
 
-STATIC I32     S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth)
+STATIC I32     S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
 #define PERL_ARGS_ASSERT_REGREPEAT     \
-       assert(prog); assert(p)
+       assert(prog); assert(startposp); assert(p); assert(reginfo)
 
-STATIC I32     S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
+STATIC I32     S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGTRY        \
-       assert(reginfo); assert(startpos)
+       assert(reginfo); assert(startposp)
 
-STATIC void    S_to_byte_substr(pTHX_ regexp * prog)
+STATIC bool    S_to_byte_substr(pTHX_ regexp * prog)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR        \
        assert(prog)
@@ -6993,6 +7211,7 @@ STATIC void       S_force_ident(pTHX_ const char *s, int kind)
 #define PERL_ARGS_ASSERT_FORCE_IDENT   \
        assert(s)
 
+STATIC void    S_force_ident_maybe_lex(pTHX_ char pit);
 STATIC void    S_force_next(pTHX_ I32 type);
 STATIC char*   S_force_strict_version(pTHX_ char *s)
                        __attribute__nonnull__(pTHX_1);
@@ -7004,11 +7223,18 @@ STATIC char*    S_force_version(pTHX_ char *s, int guessing)
 #define PERL_ARGS_ASSERT_FORCE_VERSION \
        assert(s)
 
-STATIC char*   S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_tick)
+STATIC char*   S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_FORCE_WORD    \
        assert(start)
 
+PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME        \
+       assert(s); assert(e)
+
 STATIC void    S_incline(pTHX_ const char *s)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INCLINE       \
@@ -7029,7 +7255,7 @@ STATIC I32        S_lop(pTHX_ I32 f, int x, char *s)
 #define PERL_ARGS_ASSERT_LOP   \
        assert(s)
 
-STATIC void    S_missingterm(pTHX_ char *s)
+PERL_STATIC_NO_RET void        S_missingterm(pTHX_ char *s)
                        __attribute__noreturn__;
 
 STATIC SV*     S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen)
@@ -7043,6 +7269,14 @@ STATIC void      S_no_op(pTHX_ const char *const what, char *s)
 #define PERL_ARGS_ASSERT_NO_OP \
        assert(what)
 
+STATIC void    S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_PARSE_IDENT   \
+       assert(s); assert(d); assert(e)
+
+STATIC int     S_pending_ident(pTHX);
 STATIC void    S_readpipe_override(pTHX);
 STATIC char*   S_scan_const(pTHX_ char *start)
                        __attribute__warn_unused_result__
@@ -7081,7 +7315,7 @@ STATIC char*      S_scan_pat(pTHX_ char *start, I32 type)
 #define PERL_ARGS_ASSERT_SCAN_PAT      \
        assert(start)
 
-STATIC char*   S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims)
+STATIC char*   S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SCAN_STR      \
@@ -7181,13 +7415,13 @@ STATIC UV       S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV res
 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING        \
        assert(p); assert(ustrp); assert(lenp)
 
-STATIC STRLEN  S_is_utf8_char_slow(const U8 *s, const STRLEN len)
+PERL_STATIC_INLINE STRLEN      S_is_utf8_char_slow(const U8 *s, const STRLEN len)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW     \
        assert(s)
 
-STATIC bool    S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
+PERL_STATIC_INLINE bool        S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -7206,12 +7440,6 @@ STATIC U8        S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp)
 
 #endif
 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C)
-PERL_CALLCONV bool     Perl__is_utf8_quotemeta(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__IS_UTF8_QUOTEMETA    \
-       assert(p)
-
 PERL_CALLCONV UV       Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -7220,7 +7448,7 @@ PERL_CALLCONV UV  Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *le
 
 #endif
 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV UV       Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const bool flags)
+PERL_CALLCONV UV       Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1       \
@@ -7241,9 +7469,6 @@ STATIC SV *       S_with_queued_errors(pTHX_ SV *ex)
 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS    \
        assert(ex)
 
-STATIC char *  S_write_no_mem(pTHX)
-                       __attribute__noreturn__;
-
 #  if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
 STATIC void    S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
                        __attribute__nonnull__(4)
@@ -7277,9 +7502,6 @@ PERL_CALLCONV MADPROP*    Perl_newMADsv(pTHX_ char key, SV* sv)
 #define PERL_ARGS_ASSERT_NEWMADSV      \
        assert(sv)
 
-PERL_CALLCONV OP *     Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
-                       __attribute__noreturn__;
-
 PERL_CALLCONV TOKEN*   Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop);
 PERL_CALLCONV void     Perl_op_getmad(pTHX_ OP* from, OP* o, char slot);
 PERL_CALLCONV void     Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot);
@@ -7380,99 +7602,9 @@ PERL_CALLCONV void       Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const cha
        assert(file); assert(pat)
 
 #endif
-#if defined(PERL_NEED_MY_BETOH16)
-PERL_CALLCONV U16      Perl_my_betoh16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_BETOH32)
-PERL_CALLCONV U32      Perl_my_betoh32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_BETOH64)
-PERL_CALLCONV U64      Perl_my_betoh64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_BETOHI)
-PERL_CALLCONV int      Perl_my_betohi(int n);
-#endif
-#if defined(PERL_NEED_MY_BETOHL)
-PERL_CALLCONV long     Perl_my_betohl(long n);
-#endif
-#if defined(PERL_NEED_MY_BETOHS)
-PERL_CALLCONV short    Perl_my_betohs(short n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE16)
-PERL_CALLCONV U16      Perl_my_htobe16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE32)
-PERL_CALLCONV U32      Perl_my_htobe32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE64)
-PERL_CALLCONV U64      Perl_my_htobe64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBEI)
-PERL_CALLCONV int      Perl_my_htobei(int n);
-#endif
-#if defined(PERL_NEED_MY_HTOBEL)
-PERL_CALLCONV long     Perl_my_htobel(long n);
-#endif
-#if defined(PERL_NEED_MY_HTOBES)
-PERL_CALLCONV short    Perl_my_htobes(short n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE16)
-PERL_CALLCONV U16      Perl_my_htole16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE32)
-PERL_CALLCONV U32      Perl_my_htole32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE64)
-PERL_CALLCONV U64      Perl_my_htole64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLEI)
-PERL_CALLCONV int      Perl_my_htolei(int n);
-#endif
-#if defined(PERL_NEED_MY_HTOLEL)
-PERL_CALLCONV long     Perl_my_htolel(long n);
-#endif
-#if defined(PERL_NEED_MY_HTOLES)
-PERL_CALLCONV short    Perl_my_htoles(short n);
-#endif
-#if defined(PERL_NEED_MY_LETOH16)
-PERL_CALLCONV U16      Perl_my_letoh16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_LETOH32)
-PERL_CALLCONV U32      Perl_my_letoh32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_LETOH64)
-PERL_CALLCONV U64      Perl_my_letoh64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_LETOHI)
-PERL_CALLCONV int      Perl_my_letohi(int n);
-#endif
-#if defined(PERL_NEED_MY_LETOHL)
-PERL_CALLCONV long     Perl_my_letohl(long n);
-#endif
-#if defined(PERL_NEED_MY_LETOHS)
-PERL_CALLCONV short    Perl_my_letohs(short n);
-#endif
-#if defined(PERL_OLD_COPY_ON_WRITE)
-PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_SETSV_COW  \
-       assert(sstr)
-
-#endif
 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
 STATIC void    S_pidgone(pTHX_ Pid_t pid, int status);
 #endif
-#if defined(PL_OP_SLAB_ALLOC)
-PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
-                       __attribute__malloc__
-                       __attribute__warn_unused_result__;
-
-PERL_CALLCONV void     Perl_Slab_Free(pTHX_ void *op)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SLAB_FREE     \
-       assert(op)
-
-#endif
 #if defined(UNLINK_ALL_VERSIONS)
 PERL_CALLCONV I32      Perl_unlnk(pTHX_ const char* f)
                        __attribute__nonnull__(pTHX_1);
@@ -7559,7 +7691,7 @@ PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv)
 #define PERL_ARGS_ASSERT_NEWPADOP      \
        assert(sv)
 
-PERL_CALLCONV AV*      Perl_padlist_dup(pTHX_ AV *srcpad, CLONE_PARAMS *param)
+PERL_CALLCONV PADLIST *        Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_PADLIST_DUP   \
@@ -7692,6 +7824,14 @@ PERL_CALLCONV SSize_t    Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_
        assert(vbuf)
 
 #endif
+#if defined(WIN32)
+PERL_CALLCONV_NO_RET void      win32_croak_not_implemented(const char * fname)
+                       __attribute__noreturn__
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED   \
+       assert(fname)
+
+#endif
 #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS)
 PERL_CALLCONV int      Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
@@ -7710,6 +7850,14 @@ PERL_CALLCONV int        Perl_do_spawn_nowait(pTHX_ char* cmd)
        assert(cmd)
 
 #endif
+#if defined(_MSC_VER)
+PERL_CALLCONV int      Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
+       assert(sv); assert(mg)
+
+#endif
 #ifdef PERL_CORE
 #  include "pp_proto.h"
 #endif
Unnamed repository; edit this file 'description' to name the repository.