[Merge] CVs without GVs

[perl5.git] / proto.h

diff --git a/proto.h b/proto.h
index 3532594..cca048c 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -374,16 +374,16 @@ PERL_CALLCONV bool        Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* s
 #define PERL_ARGS_ASSERT_CANDO \
        assert(statbufp)
 
-PERL_CALLCONV I32      Perl_cast_i32(pTHX_ NV f)
+PERL_CALLCONV I32      Perl_cast_i32(NV f)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV IV       Perl_cast_iv(pTHX_ NV f)
+PERL_CALLCONV IV       Perl_cast_iv(NV f)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV U32      Perl_cast_ulong(pTHX_ NV f)
+PERL_CALLCONV U32      Perl_cast_ulong(NV f)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV UV       Perl_cast_uv(pTHX_ NV f)
+PERL_CALLCONV UV       Perl_cast_uv(NV f)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV bool     Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
@@ -793,10 +793,10 @@ PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target)
 #define PERL_ARGS_ASSERT_CV_CLONE_INTO \
        assert(proto); assert(target)
 
-PERL_CALLCONV SV*      Perl_cv_const_sv(pTHX_ const CV *const cv)
+PERL_CALLCONV SV*      Perl_cv_const_sv(const CV *const cv)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV SV*      Perl_cv_const_sv_or_av(pTHX_ const CV *const cv)
+PERL_CALLCONV SV*      Perl_cv_const_sv_or_av(const CV *const cv)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV void     Perl_cv_forget_slab(pTHX_ CV *cv)
@@ -811,6 +811,11 @@ PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckf
 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER   \
        assert(cv); assert(ckfun_p); assert(ckobj_p)
 
+PERL_CALLCONV SV *     Perl_cv_name(pTHX_ CV *cv, SV *sv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_NAME       \
+       assert(cv)
+
 PERL_CALLCONV void     Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -818,11 +823,23 @@ PERL_CALLCONV void        Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfu
 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER   \
        assert(cv); assert(ckfun); assert(ckobj)
 
+PERL_CALLCONV void     Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 flags)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS     \
+       assert(cv); assert(ckfun); assert(ckobj)
+
 PERL_CALLCONV void     Perl_cv_undef(pTHX_ CV* cv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CV_UNDEF      \
        assert(cv)
 
+PERL_CALLCONV GV *     Perl_cvgv_from_hek(pTHX_ CV* cv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CVGV_FROM_HEK \
+       assert(cv)
+
 PERL_CALLCONV void     Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CVGV_SET      \
@@ -1289,6 +1306,11 @@ PERL_CALLCONV int        Perl_getcwd_sv(pTHX_ SV* sv)
 
 PERL_CALLCONV void     Perl_gp_free(pTHX_ GV* gv);
 PERL_CALLCONV GP*      Perl_gp_ref(pTHX_ GP* gp);
+PERL_CALLCONV UV       Perl_grok_atou(const char* pv, const char** endptr)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GROK_ATOU     \
+       assert(pv)
+
 PERL_CALLCONV UV       Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -1303,11 +1325,22 @@ PERL_CALLCONV UV        Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flag
 #define PERL_ARGS_ASSERT_GROK_HEX      \
        assert(start); assert(len_p); assert(flags)
 
+PERL_CALLCONV int      Perl_grok_infnan(const char** sp, const char *send)
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_GROK_INFNAN   \
+       assert(sp); assert(send)
+
 PERL_CALLCONV int      Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GROK_NUMBER   \
        assert(pv)
 
+PERL_CALLCONV int      Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS     \
+       assert(pv)
+
 PERL_CALLCONV bool     Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
@@ -2149,6 +2182,7 @@ PERL_CALLCONV bool        Perl_is_utf8_xidfirst(pTHX_ const U8 *p)
 #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST      \
        assert(p)
 
+PERL_CALLCONV bool     Perl_isinfnan(NV nv);
 PERL_CALLCONV OP*      Perl_jmaybe(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_JMAYBE        \
@@ -2551,7 +2585,7 @@ PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
 #define PERL_ARGS_ASSERT_MG_COPY       \
        assert(sv); assert(nsv)
 
-PERL_CALLCONV MAGIC*   Perl_mg_find(pTHX_ const SV* sv, int type)
+PERL_CALLCONV MAGIC*   Perl_mg_find(const SV* sv, int type)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV MAGIC*   Perl_mg_find_mglob(pTHX_ SV* sv)
@@ -2560,7 +2594,7 @@ PERL_CALLCONV MAGIC*      Perl_mg_find_mglob(pTHX_ SV* sv)
 #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \
        assert(sv)
 
-PERL_CALLCONV MAGIC*   Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
+PERL_CALLCONV MAGIC*   Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV int      Perl_mg_free(pTHX_ SV* sv)
@@ -2590,8 +2624,8 @@ PERL_CALLCONV void        Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic)
 #define PERL_ARGS_ASSERT_MG_LOCALIZE   \
        assert(sv); assert(nsv)
 
-PERL_CALLCONV void     Perl_mg_magical(pTHX_ SV* sv)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void     Perl_mg_magical(SV* sv)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_MG_MAGICAL    \
        assert(sv)
 
@@ -2605,8 +2639,8 @@ PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv)
 #define PERL_ARGS_ASSERT_MG_SIZE       \
        assert(sv)
 
-PERL_CALLCONV void     Perl_mini_mktime(pTHX_ struct tm *ptm)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void     Perl_mini_mktime(struct tm *ptm)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_MINI_MKTIME   \
        assert(ptm)
 
@@ -2688,7 +2722,7 @@ PERL_CALLCONV OP *        Perl_my_attrs(pTHX_ OP *o, OP *attrs)
        assert(o)
 
 PERL_CALLCONV void     Perl_my_clearenv(pTHX);
-PERL_CALLCONV int      Perl_my_dirfd(pTHX_ DIR* dir);
+PERL_CALLCONV int      Perl_my_dirfd(DIR* dir);
 PERL_CALLCONV_NO_RET void      Perl_my_exit(pTHX_ U32 status)
                        __attribute__noreturn__;
 
@@ -3116,10 +3150,20 @@ PERL_CALLCONV void      Perl_op_null(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_OP_NULL       \
        assert(o)
 
+PERL_CALLCONV OP*      Perl_op_parent(OP *o)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_OP_PARENT     \
+       assert(o)
+
 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_sibling_splice(OP *parent, OP *start, int del_count, OP* insert)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE     \
+       assert(parent)
+
 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)
@@ -3995,8 +4039,8 @@ PERL_CALLCONV UV  Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags)
 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS  \
        assert(sv)
 
-PERL_CALLCONV int      Perl_sv_backoff(pTHX_ SV *const sv)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV int      Perl_sv_backoff(SV *const sv)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_SV_BACKOFF    \
        assert(sv)
 
@@ -4670,6 +4714,7 @@ PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* l
 #define PERL_ARGS_ASSERT_SWASH_INIT    \
        assert(pkg); assert(name); assert(listsv)
 
+PERL_CALLCONV void     Perl_sync_locale(pTHX);
 PERL_CALLCONV void     Perl_sys_init(int* argc, char*** argv)
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(2);
@@ -4815,10 +4860,10 @@ PERL_CALLCONV IV        Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b)
 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \
        assert(a); assert(b)
 
-PERL_CALLCONV U8*      Perl_utf8_hop(pTHX_ const U8 *s, I32 off)
+PERL_CALLCONV U8*      Perl_utf8_hop(const U8 *s, I32 off)
                        __attribute__warn_unused_result__
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_UTF8_HOP      \
        assert(s)
 
@@ -5328,6 +5373,9 @@ STATIC void       S_cv_dump(pTHX_ const CV *cv, const char *title)
 
 #  endif
 #  if defined(PERL_IN_REGCOMP_C)
+STATIC const char *    S_cntrl_to_mnemonic(const U8 c)
+                       __attribute__pure__;
+
 STATIC void    S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
@@ -5354,18 +5402,18 @@ STATIC const regnode*   S_dumpuntil(pTHX_ const regexp *r, const regnode *start, c
 #define PERL_ARGS_ASSERT_DUMPUNTIL     \
        assert(r); assert(start); assert(node); assert(sv)
 
-STATIC void    S_put_byte(pTHX_ SV* sv, int c)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PUT_BYTE      \
-       assert(sv)
-
-STATIC bool    S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap)
+STATIC bool    S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV** bitmap_invlist)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS  \
+#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS  \
        assert(sv); assert(bitmap)
 
-STATIC void    S_put_range(pTHX_ SV* sv, UV start, UV end)
+STATIC void    S_put_code_point(pTHX_ SV* sv, UV c)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PUT_CODE_POINT        \
+       assert(sv)
+
+STATIC void    S_put_range(pTHX_ SV* sv, UV start, const UV end, const bool allow_literals)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PUT_RANGE     \
        assert(sv)
@@ -5879,6 +5927,12 @@ STATIC void      S_gv_magicalize_isa(pTHX_ GV *gv)
 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA     \
        assert(gv)
 
+PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL  \
+       assert(name)
+
+PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags);
 STATIC void    S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -6034,9 +6088,9 @@ STATIC void       S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
 STATIC void    S_unwind_handler_stack(pTHX_ const void *p);
 #endif
 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
-PERL_CALLCONV bool     Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
-                       __attribute__nonnull__(pTHX_6)
-                       __attribute__nonnull__(pTHX_7);
+PERL_CALLCONV bool     Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
+                       __attribute__nonnull__(6)
+                       __attribute__nonnull__(7);
 #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS      \
        assert(posp); assert(lenp)
 
@@ -6093,6 +6147,13 @@ STATIC void      S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flag
 #define PERL_ARGS_ASSERT_BAD_TYPE_PV   \
        assert(t); assert(name); assert(kid)
 
+STATIC void    S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS  \
+       assert(fullname); assert(gv); assert(cv)
+
 STATIC void    S_cop_free(pTHX_ COP *cop)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_COP_FREE      \
@@ -6118,18 +6179,13 @@ STATIC OP*      S_fold_constants(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS        \
        assert(o)
 
-STATIC OP*     S_force_list(pTHX_ OP* arg);
+STATIC OP*     S_force_list(pTHX_ OP* arg, bool nullit);
 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);
-#define PERL_ARGS_ASSERT_GV_ENAME      \
-       assert(gv)
-
 STATIC void    S_inplace_aassign(pTHX_ OP* o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INPLACE_AASSIGN       \
@@ -6211,7 +6267,7 @@ 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_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
+STATIC bool    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_4);
@@ -6248,26 +6304,12 @@ STATIC OP*      S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags)
 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV  \
        assert(o); assert(name)
 
-STATIC OP*     S_too_few_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV  \
-       assert(o); assert(namesv)
-
 STATIC OP*     S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \
        assert(o); assert(name)
 
-STATIC OP*     S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
-       assert(o); assert(namesv)
-
 #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)
@@ -6685,6 +6727,11 @@ STATIC U32       S_add_data(RExC_state_t* const pRExC_state, const char* const s, cons
 #define PERL_ARGS_ASSERT_ADD_DATA      \
        assert(pRExC_state); assert(s)
 
+STATIC AV*     S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADD_MULTI_MATCH       \
+       assert(multi_string)
+
 PERL_STATIC_INLINE void        S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point, bool downgradable)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -6726,7 +6773,7 @@ PERL_STATIC_INLINE IV*    S_get_invlist_previous_index_addr(SV* invlist)
 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR       \
        assert(invlist)
 
-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)
+STATIC STRLEN  S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, SV** substitute_parse)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_4);
 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \
@@ -7052,7 +7099,7 @@ PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list)
 
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV SV*      Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale)
+PERL_CALLCONV SV*      Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV *exclude_list)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA  \
        assert(node)
@@ -7139,10 +7186,10 @@ PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ char** s, UV* uv, const char** err
 #define PERL_ARGS_ASSERT_GROK_BSLASH_X \
        assert(s); assert(uv); assert(error_msg)
 
-PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s)
+PERL_STATIC_INLINE I32 S_regcurly(const char *s)
                        __attribute__warn_unused_result__
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1);
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_REGCURLY      \
        assert(s)
 
@@ -7378,6 +7425,11 @@ STATIC void      S_not_a_number(pTHX_ SV *const 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);
@@ -7394,6 +7446,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)
 
+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)
@@ -7545,7 +7603,7 @@ STATIC void       S_incline(pTHX_ const char *s)
 #define PERL_ARGS_ASSERT_INCLINE       \
        assert(s)
 
-STATIC int     S_intuit_method(pTHX_ char *s, GV *gv, CV *cv)
+STATIC int     S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INTUIT_METHOD \
        assert(s)
@@ -7724,7 +7782,7 @@ STATIC SV*        S_swatch_get(pTHX_ SV* swash, UV start, UV span)
 #define PERL_ARGS_ASSERT_SWATCH_GET    \
        assert(swash)
 
-STATIC U8      S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp)
+STATIC U8      S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp)
                        __attribute__warn_unused_result__;
 
 #endif