Avoid pointer churn in study_chunk recursion bitmap allocation

[perl5.git] / proto.h

diff --git a/proto.h b/proto.h
index f6e0883..49b586d 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -17,15 +17,22 @@
  */
 
 START_EXTERN_C
  */
 
 START_EXTERN_C

+PERL_CALLCONV UV       ASCII_TO_NEED(const UV enc, const UV ch)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+

 PERL_CALLCONV int      Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_AMUPDATE   \
        assert(stash)
 
 PERL_CALLCONV int      Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_AMUPDATE   \
        assert(stash)
 

-PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);
-PERL_CALLCONV_NO_RET void      Perl_croak_memory_wrap(void)
-                       __attribute__noreturn__;
+PERL_CALLCONV UV       NATIVE_TO_NEED(const UV enc, const UV ch)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;

 
 

+PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);

 PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;


@@ -115,6 +122,11 @@ PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method)
        assert(ref)
 
 PERL_CALLCONV bool     Perl_amagic_is_enabled(pTHX_ int method);
        assert(ref)
 
 PERL_CALLCONV bool     Perl_amagic_is_enabled(pTHX_ int method);

+PERL_STATIC_INLINE void        S_append_utf8_from_native_byte(const U8 byte, U8** dest)
+                       __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE  \
+       assert(dest)
+

 PERL_CALLCONV I32      Perl_apply(pTHX_ I32 type, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 PERL_CALLCONV I32      Perl_apply(pTHX_ I32 type, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);


@@ -152,36 +164,36 @@ PERL_CALLCONV SV**        Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *cons
 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE     \
        assert(avp); assert(val)
 
 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE     \
        assert(avp); assert(val)
 

-PERL_CALLCONV SV*      Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
+PERL_CALLCONV SV*      Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_DELETE     \
        assert(av)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_DELETE     \
        assert(av)
 

-PERL_CALLCONV bool     Perl_av_exists(pTHX_ AV *av, I32 key)
+PERL_CALLCONV bool     Perl_av_exists(pTHX_ AV *av, SSize_t key)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_EXISTS     \
        assert(av)
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_EXISTS     \
        assert(av)
 

-PERL_CALLCONV void     Perl_av_extend(pTHX_ AV *av, I32 key)
+PERL_CALLCONV void     Perl_av_extend(pTHX_ AV *av, SSize_t key)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_EXTEND     \
        assert(av)
 
                        __attribute__nonnull__(pTHX_1);
 #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)
+PERL_CALLCONV void     Perl_av_extend_guts(pTHX_ AV *av, SSize_t 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)
 
                        __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)
+PERL_CALLCONV SV**     Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_FETCH      \
        assert(av)
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_FETCH      \
        assert(av)
 

-PERL_CALLCONV void     Perl_av_fill(pTHX_ AV *av, I32 fill)
+PERL_CALLCONV void     Perl_av_fill(pTHX_ AV *av, SSize_t fill)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_FILL       \
        assert(av)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_FILL       \
        assert(av)


@@ -191,13 +203,13 @@ PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av)
 #define PERL_ARGS_ASSERT_AV_ITER_P     \
        assert(av)
 
 #define PERL_ARGS_ASSERT_AV_ITER_P     \
        assert(av)
 

-PERL_CALLCONV I32      Perl_av_len(pTHX_ AV *av)
+PERL_CALLCONV SSize_t  Perl_av_len(pTHX_ AV *av)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_LEN        \
        assert(av)
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_LEN        \
        assert(av)
 

-PERL_CALLCONV AV*      Perl_av_make(pTHX_ I32 size, SV **strp)
+PERL_CALLCONV AV*      Perl_av_make(pTHX_ SSize_t size, SV **strp)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_AV_MAKE       \
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_AV_MAKE       \


@@ -225,16 +237,16 @@ PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av)
 #define PERL_ARGS_ASSERT_AV_SHIFT      \
        assert(av)
 
 #define PERL_ARGS_ASSERT_AV_SHIFT      \
        assert(av)
 

-PERL_CALLCONV SV**     Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
+PERL_CALLCONV SV**     Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_STORE      \
        assert(av)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_STORE      \
        assert(av)
 

-/* PERL_CALLCONV I32   Perl_av_tindex(pTHX_ AV *av)
+/* PERL_CALLCONV SSize_t       Perl_av_tindex(pTHX_ AV *av)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1); */
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1); */
 

-PERL_STATIC_INLINE I32 S_av_top_index(pTHX_ AV *av)
+PERL_STATIC_INLINE SSize_t     S_av_top_index(pTHX_ AV *av)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_TOP_INDEX  \
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_TOP_INDEX  \


@@ -245,7 +257,7 @@ PERL_CALLCONV void  Perl_av_undef(pTHX_ AV *av)
 #define PERL_ARGS_ASSERT_AV_UNDEF      \
        assert(av)
 
 #define PERL_ARGS_ASSERT_AV_UNDEF      \
        assert(av)
 

-PERL_CALLCONV void     Perl_av_unshift(pTHX_ AV *av, I32 num)
+PERL_CALLCONV void     Perl_av_unshift(pTHX_ AV *av, SSize_t num)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_UNSHIFT    \
        assert(av)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_AV_UNSHIFT    \
        assert(av)


@@ -353,6 +365,12 @@ PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_ANONCODE   \
        assert(o)
 
 #define PERL_ARGS_ASSERT_CK_ANONCODE   \
        assert(o)
 

+PERL_CALLCONV OP *     Perl_ck_backtick(pTHX_ OP *o)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_BACKTICK   \
+       assert(o)
+

 PERL_CALLCONV OP *     Perl_ck_bitop(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 PERL_CALLCONV OP *     Perl_ck_bitop(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -383,12 +401,6 @@ PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_DELETE     \
        assert(o)
 
 #define PERL_ARGS_ASSERT_CK_DELETE     \
        assert(o)
 

-PERL_CALLCONV OP *     Perl_ck_die(pTHX_ OP *o)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_DIE        \
-       assert(o)
-

 PERL_CALLCONV OP *     Perl_ck_each(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 PERL_CALLCONV OP *     Perl_ck_each(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -445,12 +457,6 @@ PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_EXISTS     \
        assert(o)
 
 #define PERL_ARGS_ASSERT_CK_EXISTS     \
        assert(o)
 

-PERL_CALLCONV OP *     Perl_ck_exit(pTHX_ OP *o)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_EXIT       \
-       assert(o)
-

 PERL_CALLCONV OP *     Perl_ck_ftst(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 PERL_CALLCONV OP *     Perl_ck_ftst(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -651,6 +657,11 @@ PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...)
 
 PERL_CALLCONV bool     Perl_ckwarn(pTHX_ U32 w);
 PERL_CALLCONV bool     Perl_ckwarn_d(pTHX_ U32 w);
 
 PERL_CALLCONV bool     Perl_ckwarn(pTHX_ U32 w);
 PERL_CALLCONV bool     Perl_ckwarn_d(pTHX_ U32 w);

+PERL_CALLCONV const COP*       Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CLOSEST_COP   \
+       assert(cop)
+

 PERL_CALLCONV OP*      Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV OP*      Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
                        __attribute__warn_unused_result__;
 


@@ -680,6 +691,9 @@ PERL_CALLCONV_NO_RET void   Perl_croak(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 

+PERL_STATIC_NO_RET void        S_croak_memory_wrap(void)
+                       __attribute__noreturn__;
+

 PERL_CALLCONV_NO_RET void      Perl_croak_no_mem(void)
                        __attribute__noreturn__;
 
 PERL_CALLCONV_NO_RET void      Perl_croak_no_mem(void)
                        __attribute__noreturn__;
 


@@ -709,6 +723,12 @@ PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o)
 #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC        \
        assert(o)
 
 #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC        \
        assert(o)
 

+PERL_CALLCONV XOPRETANY        Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD   \
+       assert(o)
+

 PERL_CALLCONV const char *     Perl_custom_op_name(pTHX_ const OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 PERL_CALLCONV const char *     Perl_custom_op_name(pTHX_ const OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -721,11 +741,9 @@ PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP
 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER    \
        assert(ppaddr); assert(xop)
 
 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER    \
        assert(ppaddr); assert(xop)
 

-PERL_CALLCONV const XOP *      Perl_custom_op_xop(pTHX_ const OP *o)
+/* PERL_CALLCONV const XOP *   Perl_custom_op_xop(pTHX_ const OP *o)

                        __attribute__pure__
                        __attribute__pure__

-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CUSTOM_OP_XOP \
-       assert(o)
+                       __attribute__nonnull__(pTHX_1); */

 
 PERL_CALLCONV void     Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags)
                        __attribute__nonnull__(pTHX_1);
 
 PERL_CALLCONV void     Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags)
                        __attribute__nonnull__(pTHX_1);


@@ -746,6 +764,9 @@ PERL_CALLCONV CV*   Perl_cv_clone_into(pTHX_ CV* proto, CV *target)
 PERL_CALLCONV SV*      Perl_cv_const_sv(pTHX_ const CV *const cv)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV SV*      Perl_cv_const_sv(pTHX_ const CV *const cv)
                        __attribute__warn_unused_result__;
 

+PERL_CALLCONV SV*      Perl_cv_const_sv_or_av(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        \
 PERL_CALLCONV void     Perl_cv_forget_slab(pTHX_ CV *cv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CV_FORGET_SLAB        \


@@ -1001,6 +1022,16 @@ PERL_CALLCONV void       Perl_dounwind(pTHX_ I32 cxix);
 PERL_CALLCONV I32      Perl_dowantarray(pTHX)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV I32      Perl_dowantarray(pTHX)
                        __attribute__warn_unused_result__;
 

+PERL_CALLCONV void     Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_DRAND48_INIT_R        \
+       assert(random_state)
+
+PERL_CALLCONV double   Perl_drand48_r(perl_drand48_t *random_state)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_DRAND48_R     \
+       assert(random_state)
+

 PERL_CALLCONV void     Perl_dump_all(pTHX);
 PERL_CALLCONV void     Perl_dump_all_perl(pTHX_ bool justperl);
 PERL_CALLCONV void     Perl_dump_eval(pTHX);
 PERL_CALLCONV void     Perl_dump_all(pTHX);
 PERL_CALLCONV void     Perl_dump_all_perl(pTHX_ bool justperl);
 PERL_CALLCONV void     Perl_dump_eval(pTHX);


@@ -1281,7 +1312,7 @@ PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags)
 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV        \
        assert(namesv)
 
 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV        \
        assert(namesv)
 

-PERL_CALLCONV void     Perl_gv_check(pTHX_ const HV* stash)
+PERL_CALLCONV void     Perl_gv_check(pTHX_ HV* stash)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_CHECK      \
        assert(stash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_CHECK      \
        assert(stash)


@@ -1455,6 +1486,11 @@ PERL_CALLCONV void       Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32
 #define PERL_ARGS_ASSERT_GV_NAME_SET   \
        assert(gv); assert(name)
 
 #define PERL_ARGS_ASSERT_GV_NAME_SET   \
        assert(gv); assert(name)
 

+PERL_CALLCONV GV *     Perl_gv_override(pTHX_ const char * const name, const STRLEN len)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_OVERRIDE   \
+       assert(name)
+

 PERL_CALLCONV HV*      Perl_gv_stashpv(pTHX_ const char* name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_STASHPV    \
 PERL_CALLCONV HV*      Perl_gv_stashpv(pTHX_ const char* name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_STASHPV    \


@@ -1631,7 +1667,7 @@ PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv)
 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET   \
        assert(hv)
 
 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET   \
        assert(hv)
 

-PERL_CALLCONV I32*     Perl_hv_placeholders_p(pTHX_ HV *hv)
+PERL_CALLCONV SSize_t* Perl_hv_placeholders_p(pTHX_ HV *hv)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P     \
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P     \


@@ -1738,6 +1774,14 @@ PERL_CALLCONV bool       Perl_is_ascii_string(const U8 *s, STRLEN len)
 PERL_CALLCONV I32      Perl_is_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV I32      Perl_is_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
 

+PERL_STATIC_INLINE bool        S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL       \
+       assert(pv); assert(what); assert(op_name)
+

 PERL_CALLCONV bool     Perl_is_uni_alnum(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
 PERL_CALLCONV bool     Perl_is_uni_alnum(pTHX_ UV c)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__


@@ -2857,6 +2901,13 @@ PERL_CALLCONV SV*        Perl_newSV_type(pTHX_ const svtype type)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 

+PERL_CALLCONV SV*      Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWSVAVDEFELEM        \
+       assert(av)
+

 PERL_CALLCONV SV*      Perl_newSVhek(pTHX_ const HEK *const hek)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 PERL_CALLCONV SV*      Perl_newSVhek(pTHX_ const HEK *const hek)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;


@@ -3000,7 +3051,7 @@ PERL_CALLCONV void        Perl_op_clear(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_OP_CLEAR      \
        assert(o)
 
 #define PERL_ARGS_ASSERT_OP_CLEAR      \
        assert(o)
 

-PERL_CALLCONV SV*      Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
+PERL_CALLCONV SV*      Perl_op_const_sv(pTHX_ const OP* o)

                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV OP*      Perl_op_contextualize(pTHX_ OP* o, I32 context)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV OP*      Perl_op_contextualize(pTHX_ OP* o, I32 context)


@@ -3184,7 +3235,7 @@ PERL_CALLCONV REGEXP*     Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
 #define PERL_ARGS_ASSERT_PREGCOMP      \
        assert(pattern)
 
 #define PERL_ARGS_ASSERT_PREGCOMP      \
        assert(pattern)
 

-PERL_CALLCONV I32      Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave)
+PERL_CALLCONV I32      Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)


@@ -3406,7 +3457,7 @@ PERL_CALLCONV void        Perl_regdump(pTHX_ const regexp* r)
 #define PERL_ARGS_ASSERT_REGDUMP       \
        assert(r)
 
 #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)
+PERL_CALLCONV I32      Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)


@@ -3503,16 +3554,16 @@ PERL_CALLCONV void      Perl_save_I8(pTHX_ I8* bytep)
 #define PERL_ARGS_ASSERT_SAVE_I8       \
        assert(bytep)
 
 #define PERL_ARGS_ASSERT_SAVE_I8       \
        assert(bytep)
 

-PERL_CALLCONV void     Perl_save_adelete(pTHX_ AV *av, I32 key)
+PERL_CALLCONV void     Perl_save_adelete(pTHX_ AV *av, SSize_t key)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SAVE_ADELETE  \
        assert(av)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SAVE_ADELETE  \
        assert(av)
 

-/* PERL_CALLCONV void  Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr)
+/* PERL_CALLCONV void  Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3); */
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3); */
 

-PERL_CALLCONV void     Perl_save_aelem_flags(pTHX_ AV* av, I32 idx, SV **sptr, const U32 flags)
+PERL_CALLCONV void     Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS      \
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS      \


@@ -3664,6 +3715,11 @@ PERL_CALLCONV void       Perl_save_sptr(pTHX_ SV** sptr)
 #define PERL_ARGS_ASSERT_SAVE_SPTR     \
        assert(sptr)
 
 #define PERL_ARGS_ASSERT_SAVE_SPTR     \
        assert(sptr)
 

+PERL_CALLCONV void     Perl_save_strlen(pTHX_ STRLEN* ptr)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SAVE_STRLEN   \
+       assert(ptr)
+

 PERL_CALLCONV SV*      Perl_save_svref(pTHX_ SV** sptr)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SAVE_SVREF    \
 PERL_CALLCONV SV*      Perl_save_svref(pTHX_ SV** sptr)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SAVE_SVREF    \


@@ -3758,6 +3814,7 @@ PERL_CALLCONV char*       Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_
        assert(bigstr); assert(littlestr); assert(old_posp)
 
 PERL_CALLCONV U32      Perl_seed(pTHX);
        assert(bigstr); assert(littlestr); assert(old_posp)
 
 PERL_CALLCONV U32      Perl_seed(pTHX);

+PERL_CALLCONV void     Perl_set_caret_X(pTHX);

 PERL_CALLCONV void     Perl_set_context(void *t)
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_SET_CONTEXT   \
 PERL_CALLCONV void     Perl_set_context(void *t)
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_SET_CONTEXT   \


@@ -3786,7 +3843,7 @@ PERL_CALLCONV void        Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPAR
 #define PERL_ARGS_ASSERT_SORTSV_FLAGS  \
        assert(cmp)
 
 #define PERL_ARGS_ASSERT_SORTSV_FLAGS  \
        assert(cmp)
 

-PERL_CALLCONV SV**     Perl_stack_grow(pTHX_ SV** sp, SV** p, int n)
+PERL_CALLCONV SV**     Perl_stack_grow(pTHX_ SV** sp, SV** p, SSize_t n)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_STACK_GROW    \
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_STACK_GROW    \


@@ -3813,7 +3870,7 @@ PERL_CALLCONV void        Perl_sub_crush_depth(pTHX_ CV* cv)
 /* PERL_CALLCONV bool  sv_2bool(pTHX_ SV *const sv)
                        __attribute__nonnull__(pTHX_1); */
 
 /* PERL_CALLCONV bool  sv_2bool(pTHX_ SV *const sv)
                        __attribute__nonnull__(pTHX_1); */
 

-PERL_CALLCONV bool     Perl_sv_2bool_flags(pTHX_ SV *const sv, const I32 flags)
+PERL_CALLCONV bool     Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS        \
        assert(sv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS        \
        assert(sv)


@@ -4157,6 +4214,11 @@ PERL_CALLCONV void       Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp)
 #define PERL_ARGS_ASSERT_SV_POS_B2U    \
        assert(offsetp)
 
 #define PERL_ARGS_ASSERT_SV_POS_B2U    \
        assert(offsetp)
 

+PERL_CALLCONV STRLEN   Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS      \
+       assert(sv)
+

 PERL_CALLCONV void     Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_SV_POS_U2B    \
 PERL_CALLCONV void     Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_SV_POS_U2B    \


@@ -4568,7 +4630,7 @@ PERL_CALLCONV OP *        Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, c
 #define PERL_ARGS_ASSERT_TIED_METHOD   \
        assert(methname); assert(sp); assert(sv); assert(mg)
 
 #define PERL_ARGS_ASSERT_TIED_METHOD   \
        assert(methname); assert(sp); assert(sv); assert(mg)
 

-PERL_CALLCONV void     Perl_tmps_grow(pTHX_ I32 n);
+PERL_CALLCONV void     Perl_tmps_grow(pTHX_ SSize_t n);

 /* PERL_CALLCONV UV    Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3); */
 /* PERL_CALLCONV UV    Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3); */


@@ -4712,11 +4774,9 @@ PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \
        assert(s)
 
 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \
        assert(s)
 

-PERL_CALLCONV UV       Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+/* PERL_CALLCONV UV    utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_1)

-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF     \
-       assert(s); assert(send)
+                       __attribute__nonnull__(pTHX_2); */

 
 PERL_CALLCONV UV       Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
                        __attribute__deprecated__
 
 PERL_CALLCONV UV       Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
                        __attribute__deprecated__


@@ -4725,23 +4785,35 @@ PERL_CALLCONV UV        Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
        assert(s)
 
 PERL_CALLCONV UV       Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
        assert(s)
 
 PERL_CALLCONV UV       Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)

+                       __attribute__deprecated__

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF     \
        assert(s); assert(send)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF     \
        assert(s); assert(send)
 

+PERL_CALLCONV UV       Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR        \
+       assert(s)
+

 PERL_CALLCONV UV       Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI        \
        assert(s)
 
 PERL_CALLCONV UV       Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI        \
        assert(s)
 

-PERL_CALLCONV U8*      Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
+/* PERL_CALLCONV U8*   uvchr_to_utf8(pTHX_ U8 *d, UV uv)
+                       __attribute__nonnull__(pTHX_1); */
+
+/* PERL_CALLCONV U8*   uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
+                       __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV U8*      Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)

                        __attribute__nonnull__(pTHX_1);
                        __attribute__nonnull__(pTHX_1);

-#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS   \
+#define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS        \

        assert(d)
 
        assert(d)
 

-/* PERL_CALLCONV U8*   Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
-                       __attribute__nonnull__(pTHX_1); */
+PERL_CALLCONV U8*      Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
+                       __attribute__nonnull__(pTHX_1);

 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \
        assert(d)
 
 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \
        assert(d)
 


@@ -4750,7 +4822,13 @@ 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)
 
 #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)
 PERL_CALLCONV UV       Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)

+                       __attribute__deprecated__

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI   \
        assert(s)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI   \
        assert(s)


@@ -4936,23 +5014,6 @@ STATIC int       S_sv_2iuv_non_preserve(pTHX_ SV *const sv)
 #    endif
 #  endif
 #endif
 #    endif
 #  endif
 #endif

-#if !(defined(EBCDIC))
-/* PERL_CALLCONV UV    Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
-                       __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR        \
-       assert(s)
-
-/* PERL_CALLCONV U8*   Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
-                       __attribute__nonnull__(pTHX_1); */
-#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);
 PERL_CALLCONV Signal_t Perl_sighandler(int sig);
 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
 PERL_CALLCONV Signal_t Perl_csighandler(int sig);
 PERL_CALLCONV Signal_t Perl_sighandler(int sig);


@@ -5209,9 +5270,15 @@ STATIC void      S_put_byte(pTHX_ SV* sv, int c)
 #define PERL_ARGS_ASSERT_PUT_BYTE      \
        assert(sv)
 
 #define PERL_ARGS_ASSERT_PUT_BYTE      \
        assert(sv)
 

+STATIC bool    S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS  \
+       assert(sv); assert(bitmap)
+

 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 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)
+STATIC U8      S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);


@@ -5266,30 +5333,6 @@ PERL_CALLCONV void       Perl_dump_sv_child(pTHX_ SV *sv)
        assert(sv)
 
 #endif
        assert(sv)
 
 #endif

-#if defined(DUMP_FDS)
-PERL_CALLCONV void     Perl_dump_fds(pTHX_ char* s)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DUMP_FDS      \
-       assert(s)
-
-#endif
-#if defined(EBCDIC)
-PERL_CALLCONV UV       Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR        \
-       assert(s)
-
-PERL_CALLCONV U8*      Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
-                       __attribute__nonnull__(pTHX_1);
-#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)
                        __attribute__nonnull__(pTHX_2)
 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 PERL_CALLCONV I32      Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)


@@ -5410,6 +5453,14 @@ PERL_CALLCONV void       Perl_Slab_to_rw(pTHX_ OPSLAB *const slab)
 
 #  endif
 #endif
 
 #  endif
 #endif

+#if defined(PERL_CORE) || defined (PERL_EXT)
+PERL_STATIC_INLINE STRLEN      S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B      \
+       assert(sv); assert(pv)
+
+#endif

 #if defined(PERL_CR_FILTER)
 #  if defined(PERL_IN_TOKE_C)
 STATIC I32     S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
 #if defined(PERL_CR_FILTER)
 #  if defined(PERL_IN_TOKE_C)
 STATIC I32     S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);


@@ -5674,16 +5725,49 @@ PERL_CALLCONV void      Perl_hv_kill_backrefs(pTHX_ HV *hv)
 
 #endif
 #if defined(PERL_IN_GV_C)
 
 #endif
 #if defined(PERL_IN_GV_C)

+STATIC bool    S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, svtype sv_type)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH    \
+       assert(stash); 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        \
        assert(gv)
 
 STATIC void    S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE        \
        assert(gv)
 

+STATIC bool    S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \
+       assert(name)
+
+STATIC bool    S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, bool addmg, svtype sv_type)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_GV_MAGICALIZE \
+       assert(gv); assert(stash); assert(name)
+

 STATIC void    S_gv_magicalize_isa(pTHX_ GV *gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA     \
        assert(gv)
 
 STATIC void    S_gv_magicalize_isa(pTHX_ GV *gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA     \
        assert(gv)
 

+STATIC void    S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV   \
+       assert(gv); assert(name)
+
+STATIC bool    S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4)
+                       __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME   \
+       assert(stash); assert(gv); assert(name); assert(len); assert(nambeg)
+

 STATIC HV*     S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
 STATIC HV*     S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)


@@ -5783,15 +5867,20 @@ PERL_CALLCONV SV*       Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp)
        assert(hv); assert(indexp)
 
 #endif
        assert(hv); assert(indexp)
 
 #endif

-#if defined(PERL_IN_LOCALE_C)
-#  if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE)
+#if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE)

 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 \
        assert(locs)
 
 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 \
        assert(locs)
 

-#  endif
+#endif
+#if defined(PERL_IN_MALLOC_C)
+STATIC int     S_adjust_size_and_find_bucket(size_t *nbytes_p)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET   \
+       assert(nbytes_p)
+

 #endif
 #if defined(PERL_IN_MG_C)
 STATIC SV*     S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val)
 #endif
 #if defined(PERL_IN_MG_C)
 STATIC SV*     S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val)


@@ -5825,7 +5914,7 @@ PERL_CALLCONV bool        Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv
 
 #endif
 #if defined(PERL_IN_MRO_C)
 
 #endif
 #if defined(PERL_IN_MRO_C)

-STATIC void    S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 flags)
+STATIC void    S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV      \
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV      \


@@ -5934,6 +6023,13 @@ STATIC bool      S_looks_like_bool(pTHX_ const OP* o)
        assert(o)
 
 STATIC OP*     S_modkids(pTHX_ OP *o, I32 type);
        assert(o)
 
 STATIC OP*     S_modkids(pTHX_ OP *o, I32 type);

+STATIC void    S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR       \
+       assert(proto); assert(attrs); assert(name)
+

 STATIC OP *    S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_MY_KID        \
 STATIC OP *    S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_MY_KID        \


@@ -6149,7 +6245,7 @@ PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co
 
 #endif
 #if defined(PERL_IN_PP_CTL_C)
 
 #endif
 #if defined(PERL_IN_PP_CTL_C)

-STATIC SV **   S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags)
+STATIC SV **   S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags, bool lvalue)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);


@@ -6448,86 +6544,55 @@ STATIC SV*      S__new_invlist_C_array(pTHX_ const UV* const list)
 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
                        __attribute__warn_unused_result__;
 
 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
                        __attribute__warn_unused_result__;
 

-STATIC U32     S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s)
+STATIC U32     S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)

-                       __attribute__nonnull__(3);
+                       __attribute__nonnull__(2);

 #define PERL_ARGS_ASSERT_ADD_DATA      \
        assert(pRExC_state); assert(s)
 
 #define PERL_ARGS_ASSERT_ADD_DATA      \
        assert(pRExC_state); assert(s)
 

-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)
+PERL_STATIC_INLINE void        S_alloc_maybe_populate_EXACT(pTHX_ 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)
 
                        __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)
-                       __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_AND        \
-       assert(cl); assert(and_with)
-
-STATIC void    S_cl_anything(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
-                       __attribute__nonnull__(1)
-                       __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_ANYTHING   \
-       assert(pRExC_state); assert(cl)
-
-STATIC void    S_cl_init(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
-                       __attribute__nonnull__(1)
-                       __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_INIT       \
-       assert(pRExC_state); assert(cl)
-
-STATIC int     S_cl_is_anything(const struct regnode_charclass_class *cl)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_CL_IS_ANYTHING        \
-       assert(cl)
-
-STATIC void    S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
-                       __attribute__nonnull__(1)
-                       __attribute__nonnull__(2)
-                       __attribute__nonnull__(3);
-#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)
+PERL_STATIC_INLINE U8  S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
        assert(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)
+STATIC bool    S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS     \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS     \
        assert(pRExC_state)
 

+STATIC SV*     S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass_posixl* const node)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC     \
+       assert(pRExC_state); assert(node)
+

 PERL_STATIC_INLINE STRLEN*     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 STRLEN*     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 bool*       S_get_invlist_offset_addr(pTHX_ SV* invlist)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR       \
-       assert(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_PREVIOUS_INDEX_ADDR       \
        assert(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_PREVIOUS_INDEX_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)
+STATIC bool    S_grok_bslash_N(pTHX_ 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)
 
                        __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)
+STATIC regnode*        S_handle_regex_sets(pTHX_ 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);
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_5);


@@ -6593,7 +6658,7 @@ PERL_STATIC_INLINE IV     S_invlist_previous_index(pTHX_ SV* const invlist)
 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX        \
        assert(invlist)
 
 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX        \
        assert(invlist)
 

-PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ SV* const invlist, const UV len)
+PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
        assert(invlist)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
        assert(invlist)


@@ -6608,7 +6673,7 @@ PERL_STATIC_INLINE void   S_invlist_trim(pTHX_ SV* const invlist)
 #define PERL_ARGS_ASSERT_INVLIST_TRIM  \
        assert(invlist)
 
 #define PERL_ARGS_ASSERT_INVLIST_TRIM  \
        assert(invlist)
 

-STATIC U32     S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *has_exactf_sharp_s, U32 flags, regnode *val, U32 depth)
+STATIC U32     S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *has_exactf_sharp_s, U32 flags, regnode *val, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)


@@ -6616,7 +6681,7 @@ STATIC U32        S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, U
 #define PERL_ARGS_ASSERT_JOIN_EXACT    \
        assert(pRExC_state); assert(scan); assert(min_subtract); assert(has_exactf_sharp_s)
 
 #define PERL_ARGS_ASSERT_JOIN_EXACT    \
        assert(pRExC_state); assert(scan); assert(min_subtract); assert(has_exactf_sharp_s)
 

-STATIC I32     S_make_trie(pTHX_ struct RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
+STATIC I32     S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)


@@ -6625,37 +6690,43 @@ STATIC I32      S_make_trie(pTHX_ struct RExC_state_t *pRExC_state, regnode *startbra
 #define PERL_ARGS_ASSERT_MAKE_TRIE     \
        assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
 
 #define PERL_ARGS_ASSERT_MAKE_TRIE     \
        assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
 

-STATIC void    S_make_trie_failtable(pTHX_ struct RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth)
+STATIC void    S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE   \
        assert(pRExC_state); assert(source); assert(stclass)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE   \
        assert(pRExC_state); assert(source); assert(stclass)
 

-STATIC char *  S_nextchar(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC char *  S_nextchar(pTHX_ RExC_state_t *pRExC_state)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_NEXTCHAR      \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_NEXTCHAR      \
        assert(pRExC_state)
 

-STATIC void    S_parse_lparen_question_flags(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC void    S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS   \
        assert(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__
+STATIC void    S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);

+#define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST   \
+       assert(node); assert(invlist_ptr)
+
+PERL_STATIC_NO_RET void        S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...)
+                       __attribute__noreturn__
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);

 #define PERL_ARGS_ASSERT_RE_CROAK2     \
        assert(pat1); assert(pat2)
 
 #define PERL_ARGS_ASSERT_RE_CROAK2     \
        assert(pat1); assert(pat2)
 

-STATIC regnode*        S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)
+STATIC regnode*        S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REG   \
        assert(pRExC_state); assert(flagp)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REG   \
        assert(pRExC_state); assert(flagp)
 

-STATIC regnode*        S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op)
+STATIC regnode*        S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_NODE      \
        assert(pRExC_state)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_NODE      \
        assert(pRExC_state)


@@ -6665,91 +6736,173 @@ STATIC UV      S_reg_recode(pTHX_ const char value, SV **encp)
 #define PERL_ARGS_ASSERT_REG_RECODE    \
        assert(encp)
 
 #define PERL_ARGS_ASSERT_REG_RECODE    \
        assert(encp)
 

-STATIC SV *    S_reg_scan_name(pTHX_ struct RExC_state_t *pRExC_state, U32 flags)
+STATIC SV *    S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \
        assert(pRExC_state)
 

-STATIC bool    S_reg_skipcomment(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC bool    S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT       \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT       \
        assert(pRExC_state)
 

-STATIC regnode*        S_reganode(pTHX_ struct RExC_state_t *pRExC_state, U8 op, U32 arg)
+STATIC regnode*        S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGANODE      \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGANODE      \
        assert(pRExC_state)
 

-STATIC regnode*        S_regatom(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
+STATIC regnode*        S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGATOM       \
        assert(pRExC_state); assert(flagp)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGATOM       \
        assert(pRExC_state); assert(flagp)
 

-STATIC regnode*        S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
+STATIC regnode*        S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGBRANCH     \
        assert(pRExC_state); assert(flagp)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGBRANCH     \
        assert(pRExC_state); assert(flagp)
 

-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)
+STATIC regnode*        S_regclass(pTHX_ 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(flagp)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGCLASS      \
        assert(pRExC_state); assert(flagp)
 

-STATIC void    S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
+STATIC void    S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGINSERT     \
        assert(pRExC_state); assert(opnd)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #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)
+STATIC char *  S_regpatws(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)
 
                        __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)
+STATIC regnode*        S_regpiece(pTHX_ 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)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REGPIECE      \
        assert(pRExC_state); assert(flagp)
 

-PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, const bool strict)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict)

                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGPPOSIXCC   \
        assert(pRExC_state)
 
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGPPOSIXCC   \
        assert(pRExC_state)
 

-STATIC void    S_regtail(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
+STATIC void    S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGTAIL       \
        assert(pRExC_state); assert(p); assert(val)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGTAIL       \
        assert(pRExC_state); assert(p); assert(val)
 

-STATIC STRLEN  S_reguni(pTHX_ const struct RExC_state_t *pRExC_state, UV uv, char *s)
+STATIC STRLEN  S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char *s)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGUNI        \
        assert(pRExC_state); assert(s)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_REGUNI        \
        assert(pRExC_state); assert(s)
 

-STATIC char *  S_regwhite(struct RExC_state_t *pRExC_state, char *p)
+STATIC char *  S_regwhite(RExC_state_t *pRExC_state, char *p)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REGWHITE      \
        assert(pRExC_state); assert(p)
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REGWHITE      \
        assert(pRExC_state); assert(p)
 

-STATIC void    S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct scan_data_t *data, I32 *minlenp, int is_inf)
+STATIC void    S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_SCAN_COMMIT   \
        assert(pRExC_state); assert(data); assert(minlenp)
 
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_SCAN_COMMIT   \
        assert(pRExC_state); assert(data); assert(minlenp)
 

-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)
+STATIC void    S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const swash, const bool has_user_defined_property)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SET_ANYOF_ARG \
+       assert(pRExC_state); assert(node)
+
+PERL_STATIC_INLINE void        S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_ADD_RANGE \
+       assert(ssc)
+
+STATIC void    S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *and_with)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_SSC_AND       \
+       assert(pRExC_state); assert(ssc); assert(and_with)
+
+STATIC void    S_ssc_anything(pTHX_ regnode_ssc *ssc)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_ANYTHING  \
+       assert(ssc)
+
+PERL_STATIC_INLINE void        S_ssc_clear_locale(pTHX_ regnode_ssc *ssc)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE      \
+       assert(ssc)
+
+PERL_STATIC_INLINE void        S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_CP_AND    \
+       assert(ssc)
+
+STATIC void    S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_FINALIZE  \
+       assert(pRExC_state); assert(ssc)
+
+STATIC void    S_ssc_flags_and(regnode_ssc *ssc, const U8 and_with)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SSC_FLAGS_AND \
+       assert(ssc)
+
+STATIC void    S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_INIT      \
+       assert(pRExC_state); assert(ssc)
+
+PERL_STATIC_INLINE void        S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_INTERSECTION      \
+       assert(ssc); assert(invlist)
+
+STATIC int     S_ssc_is_anything(pTHX_ const regnode_ssc *ssc)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_IS_ANYTHING       \
+       assert(ssc)
+
+STATIC int     S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state, const regnode_ssc *ssc)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \
+       assert(pRExC_state); assert(ssc)
+
+STATIC void    S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_ssc *or_with)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_SSC_OR        \
+       assert(pRExC_state); assert(ssc); assert(or_with)
+
+PERL_STATIC_INLINE void        S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_UNION     \
+       assert(ssc); assert(invlist)
+
+STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)


@@ -6759,13 +6912,16 @@ STATIC I32      S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp
        assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
 
 #endif
        assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
 
 #endif

-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-PERL_STATIC_INLINE STRLEN*     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)
+#if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C)
+PERL_CALLCONV void     Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT__INVLIST_DUMP \
+       assert(file); assert(indent); assert(invlist)

 
 

+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)

 PERL_CALLCONV SV*      Perl__get_swash_invlist(pTHX_ SV* const swash)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 PERL_CALLCONV SV*      Perl__get_swash_invlist(pTHX_ SV* const swash)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -6802,6 +6958,12 @@ PERL_CALLCONV HV*        Perl__swash_inversion_hash(pTHX_ SV* const swash)
 #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
        assert(swash)
 
 #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
        assert(swash)
 

+PERL_STATIC_INLINE bool*       S_get_invlist_offset_addr(pTHX_ SV* invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR       \
+       assert(invlist)
+

 #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)
 #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)


@@ -6946,14 +7108,14 @@ STATIC CHECKPOINT       S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxop
 #define PERL_ARGS_ASSERT_REGCPPUSH     \
        assert(rex)
 
 #define PERL_ARGS_ASSERT_REGCPPUSH     \
        assert(rex)
 

-STATIC U8*     S_reghop3(U8 *s, I32 off, const U8 *lim)
+STATIC U8*     S_reghop3(U8 *s, SSize_t off, const U8 *lim)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3);
 #define PERL_ARGS_ASSERT_REGHOP3       \
        assert(s); assert(lim)
 
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3);
 #define PERL_ARGS_ASSERT_REGHOP3       \
        assert(s); assert(lim)
 

-STATIC U8*     S_reghopmaybe3(U8 *s, I32 off, const U8 *lim)
+STATIC U8*     S_reghopmaybe3(U8 *s, SSize_t off, const U8 *lim)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3);
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3);


@@ -6967,7 +7129,7 @@ STATIC bool       S_reginclass(pTHX_ regexp * const prog, const regnode * const n, con
 #define PERL_ARGS_ASSERT_REGINCLASS    \
        assert(n); assert(p)
 
 #define PERL_ARGS_ASSERT_REGINCLASS    \
        assert(n); assert(p)
 

-STATIC I32     S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
+STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)


@@ -7002,7 +7164,7 @@ STATIC void       S_to_utf8_substr(pTHX_ regexp * prog)
        assert(prog)
 
 #  if defined(XXX_dmq)
        assert(prog)
 
 #  if defined(XXX_dmq)

-STATIC U8*     S_reghop4(U8 *s, I32 off, const U8 *llim, const U8 *rlim)
+STATIC U8*     S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(3)


@@ -7084,6 +7246,11 @@ STATIC void      S_not_a_number(pTHX_ SV *const sv)
 #define PERL_ARGS_ASSERT_NOT_A_NUMBER  \
        assert(sv)
 
 #define PERL_ARGS_ASSERT_NOT_A_NUMBER  \
        assert(sv)
 

+STATIC void    S_not_incrementable(pTHX_ SV *const sv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NOT_INCREMENTABLE     \
+       assert(sv)
+

 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);


@@ -7100,6 +7267,12 @@ STATIC void      S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flag
 #define PERL_ARGS_ASSERT_SV_ADD_ARENA  \
        assert(ptr)
 
 #define PERL_ARGS_ASSERT_SV_ADD_ARENA  \
        assert(ptr)
 

+STATIC const char *    S_sv_display(pTHX_ SV *const sv, char *tmpbuf, STRLEN tmpbuf_size)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_DISPLAY    \
+       assert(sv); assert(tmpbuf)
+

 STATIC STRLEN  S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
 STATIC STRLEN  S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)


@@ -7288,7 +7461,6 @@ STATIC void       S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_pa
        assert(s); assert(d); assert(e)
 
 STATIC int     S_pending_ident(pTHX);
        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__
                        __attribute__nonnull__(pTHX_1);
 STATIC char*   S_scan_const(pTHX_ char *start)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);


@@ -7307,12 +7479,11 @@ STATIC char*    S_scan_heredoc(pTHX_ char *s)
 #define PERL_ARGS_ASSERT_SCAN_HEREDOC  \
        assert(s)
 
 #define PERL_ARGS_ASSERT_SCAN_HEREDOC  \
        assert(s)
 

-STATIC char*   S_scan_ident(pTHX_ char *s, const char *send, char *dest, STRLEN destlen, I32 ck_uni)
+STATIC char*   S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni)

                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_1)

-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
+                       __attribute__nonnull__(pTHX_2);

 #define PERL_ARGS_ASSERT_SCAN_IDENT    \
 #define PERL_ARGS_ASSERT_SCAN_IDENT    \

-       assert(s); assert(send); assert(dest)
+       assert(s); assert(dest)

 
 STATIC char*   S_scan_inputsymbol(pTHX_ char *start)
                        __attribute__warn_unused_result__
 
 STATIC char*   S_scan_inputsymbol(pTHX_ char *start)
                        __attribute__warn_unused_result__


@@ -7326,7 +7497,7 @@ STATIC char*      S_scan_pat(pTHX_ char *start, I32 type)
 #define PERL_ARGS_ASSERT_SCAN_PAT      \
        assert(start)
 
 #define PERL_ARGS_ASSERT_SCAN_PAT      \
        assert(start)
 

-STATIC char*   S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching)
+STATIC char*   S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char **delimp)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SCAN_STR      \
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SCAN_STR      \


@@ -7351,10 +7522,10 @@ STATIC char*    S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_pa
 #define PERL_ARGS_ASSERT_SCAN_WORD     \
        assert(s); assert(dest); assert(slp)
 
 #define PERL_ARGS_ASSERT_SCAN_WORD     \
        assert(s); assert(dest); assert(slp)
 

-STATIC char*   S_skipspace(pTHX_ char *s)
+STATIC char*   S_skipspace_flags(pTHX_ char *s, U32 flags)

                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);

-#define PERL_ARGS_ASSERT_SKIPSPACE     \
+#define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS       \

        assert(s)
 
 STATIC I32     S_sublex_done(pTHX)
        assert(s)
 
 STATIC I32     S_sublex_done(pTHX)


@@ -7468,11 +7639,6 @@ PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, con
 #endif
 #if defined(PERL_IN_UTIL_C)
 STATIC bool    S_ckwarn_common(pTHX_ U32 w);
 #endif
 #if defined(PERL_IN_UTIL_C)
 STATIC bool    S_ckwarn_common(pTHX_ U32 w);

-STATIC const COP*      S_closest_cop(pTHX_ const COP *cop, const OP *o)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CLOSEST_COP   \
-       assert(cop)
-

 STATIC bool    S_invoke_exception_hook(pTHX_ SV *ex, bool warn);
 STATIC SV*     S_mess_alloc(pTHX);
 STATIC SV *    S_with_queued_errors(pTHX_ SV *ex)
 STATIC bool    S_invoke_exception_hook(pTHX_ SV *ex, bool warn);
 STATIC SV*     S_mess_alloc(pTHX);
 STATIC SV *    S_with_queued_errors(pTHX_ SV *ex)


@@ -7798,10 +7964,10 @@ PERL_CALLCONV int       Perl_PerlIO_fileno(pTHX_ PerlIO *f);
 PERL_CALLCONV int      Perl_PerlIO_fill(pTHX_ PerlIO *f);
 PERL_CALLCONV int      Perl_PerlIO_flush(pTHX_ PerlIO *f);
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_base(pTHX_ PerlIO *f);
 PERL_CALLCONV int      Perl_PerlIO_fill(pTHX_ PerlIO *f);
 PERL_CALLCONV int      Perl_PerlIO_flush(pTHX_ PerlIO *f);
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_base(pTHX_ PerlIO *f);

-PERL_CALLCONV int      Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
+PERL_CALLCONV SSize_t  Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)

                        __attribute__warn_unused_result__;
 
                        __attribute__warn_unused_result__;
 

-PERL_CALLCONV int      Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
+PERL_CALLCONV SSize_t  Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)

                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV STDCHAR *        Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);


@@ -7811,8 +7977,8 @@ PERL_CALLCONV SSize_t     Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count
        assert(vbuf)
 
 PERL_CALLCONV int      Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
        assert(vbuf)
 
 PERL_CALLCONV int      Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);

-PERL_CALLCONV void     Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt);
-PERL_CALLCONV void     Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, int cnt);
+PERL_CALLCONV void     Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt);
+PERL_CALLCONV void     Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt);

 PERL_CALLCONV void     Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX)
                        __attribute__warn_unused_result__;
 PERL_CALLCONV void     Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX)
                        __attribute__warn_unused_result__;