handy.h: Don't call _uni fcns if have applicable macro

[perl5.git] / proto.h

diff --git a/proto.h b/proto.h
index fe234d3..17fbdd8 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -23,26 +23,6 @@ PERL_CALLCONV int    Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
        assert(stash)
 
 PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);
-PERL_CALLCONV void     Perl__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST      \
-       assert(invlist)
-
-PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
-                       __attribute__warn_unused_result__;
-
-PERL_CALLCONV HV*      Perl__swash_inversion_hash(pTHX_ SV* const swash)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
-       assert(swash)
-
-PERL_CALLCONV SV*      Perl__swash_to_invlist(pTHX_ SV* const swash)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__SWASH_TO_INVLIST     \
-       assert(swash)
-
 PERL_CALLCONV UV       Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -334,6 +314,13 @@ PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_EACH       \
        assert(o)
 
+PERL_CALLCONV OP*      Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \
+       assert(entersubop); assert(namegv); assert(protosv)
+
 PERL_CALLCONV OP*      Perl_ck_entersub_args_list(pTHX_ OP *entersubop)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \
@@ -557,12 +544,6 @@ PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_TRUNC      \
        assert(o)
 
-PERL_CALLCONV OP *     Perl_ck_unpack(pTHX_ OP *o)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_UNPACK     \
-       assert(o)
-
 PERL_CALLCONV void     Perl_ck_warner(pTHX_ U32 err, const char* pat, ...)
                        __attribute__format__(__printf__,pTHX_2,pTHX_3)
                        __attribute__nonnull__(pTHX_2);
@@ -580,6 +561,27 @@ PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w);
 PERL_CALLCONV OP*      Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV const char *     Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_COP_FETCH_LABEL       \
+       assert(cop)
+
+PERL_CALLCONV void     Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_COP_STORE_LABEL       \
+       assert(cop); assert(label)
+
+PERL_CALLCONV SV *     Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CORE_PROTOTYPE        \
+       assert(name)
+
+PERL_CALLCONV OP *     Perl_coresub_op(pTHX_ SV *coreargssv, const int code, const int opnum)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CORESUB_OP    \
+       assert(coreargssv)
+
 PERL_CALLCONV PERL_CONTEXT*    Perl_create_eval_scope(pTHX_ U32 flags);
 PERL_CALLCONV void     Perl_croak(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
@@ -957,11 +959,6 @@ PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN
 #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED    \
        assert(name)
 
-PERL_CALLCONV const char *     Perl_fetch_cop_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FETCH_COP_LABEL       \
-       assert(cop)
-
 PERL_CALLCONV SV*      Perl_filter_add(pTHX_ filter_t funcp, SV* datasv);
 PERL_CALLCONV void     Perl_filter_del(pTHX_ filter_t funcp)
                        __attribute__nonnull__(pTHX_1);
@@ -974,10 +971,20 @@ PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen)
 #define PERL_ARGS_ASSERT_FILTER_READ   \
        assert(buf_sv)
 
+PERL_CALLCONV void     Perl_finalize_optree(pTHX_ OP* o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FINALIZE_OPTREE       \
+       assert(o)
+
 PERL_CALLCONV CV*      Perl_find_runcv(pTHX_ U32 *db_seqp)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV SV*      Perl_find_rundefsv(pTHX);
+PERL_CALLCONV SV*      Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FIND_RUNDEFSV2        \
+       assert(cv)
+
 PERL_CALLCONV PADOFFSET        Perl_find_rundefsvoffset(pTHX)
                        __attribute__deprecated__;
 
@@ -1513,12 +1520,6 @@ PERL_CALLCONV bool       Perl_is_ascii_string(const U8 *s, STRLEN len)
 #define PERL_ARGS_ASSERT_IS_ASCII_STRING       \
        assert(s)
 
-PERL_CALLCONV bool     Perl_is_gv_magical_sv(pTHX_ SV *const name_sv, U32 flags)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_GV_MAGICAL_SV      \
-       assert(name_sv)
-
 PERL_CALLCONV I32      Perl_is_lvalue_sub(pTHX)
                        __attribute__warn_unused_result__;
 
@@ -2286,7 +2287,6 @@ PERL_CALLCONV void        Perl_mini_mktime(pTHX_ struct tm *ptm)
 #define PERL_ARGS_ASSERT_MINI_MKTIME   \
        assert(ptm)
 
-PERL_CALLCONV OP*      Perl_mod(pTHX_ OP* o, I32 type);
 PERL_CALLCONV int      Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len);
 PERL_CALLCONV void *   Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size);
 PERL_CALLCONV const char*      Perl_moreswitches(pTHX_ const char* s)
@@ -2381,13 +2381,6 @@ PERL_CALLCONV I32        Perl_my_fflush_all(pTHX);
 PERL_CALLCONV Pid_t    Perl_my_fork(void);
 /* PERL_CALLCONV I32   Perl_my_lstat(pTHX); */
 PERL_CALLCONV I32      Perl_my_lstat_flags(pTHX_ const U32 flags);
-PERL_CALLCONV I32      Perl_my_pclose(pTHX_ PerlIO* ptr);
-PERL_CALLCONV PerlIO*  Perl_my_popen(pTHX_ const char* cmd, const char* mode)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MY_POPEN      \
-       assert(cmd); assert(mode)
-
 PERL_CALLCONV PerlIO*  Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
@@ -2807,14 +2800,24 @@ PERL_CALLCONV void      Perl_packlist(pTHX_ SV *cat, const char *pat, const char *pat
 #define PERL_ARGS_ASSERT_PACKLIST      \
        assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist)
 
-PERL_CALLCONV PADOFFSET        Perl_pad_add_anon(pTHX_ SV* sv, OPCODE op_type)
+PERL_CALLCONV PADOFFSET        Perl_pad_add_anon(pTHX_ CV* func, I32 optype)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_ADD_ANON  \
-       assert(sv)
+       assert(func)
 
-PERL_CALLCONV PADOFFSET        Perl_pad_add_name(pTHX_ const char *name, const STRLEN len, const U32 flags, HV *typestash, HV *ourstash)
+PERL_CALLCONV PADOFFSET        Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash)
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PAD_ADD_NAME  \
+#define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV       \
+       assert(name)
+
+PERL_CALLCONV PADOFFSET        Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN      \
+       assert(namepv)
+
+PERL_CALLCONV PADOFFSET        Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV       \
        assert(name)
 
 PERL_CALLCONV PADOFFSET        Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
@@ -2822,10 +2825,22 @@ PERL_CALLCONV void      Perl_pad_block_start(pTHX_ int full);
 PERL_CALLCONV HV*      Perl_pad_compname_type(pTHX_ const PADOFFSET po)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV PADOFFSET        Perl_pad_findmy(pTHX_ const char* name, STRLEN len, U32 flags)
+PERL_CALLCONV PADOFFSET        Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PAD_FINDMY    \
+#define PERL_ARGS_ASSERT_PAD_FINDMY_PV \
+       assert(name)
+
+PERL_CALLCONV PADOFFSET        Perl_pad_findmy_pvn(pTHX_ const char* namepv, STRLEN namelen, U32 flags)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_FINDMY_PVN        \
+       assert(namepv)
+
+PERL_CALLCONV PADOFFSET        Perl_pad_findmy_sv(pTHX_ SV* name, U32 flags)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_FINDMY_SV \
        assert(name)
 
 PERL_CALLCONV void     Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
@@ -3524,12 +3539,6 @@ PERL_CALLCONV bool       Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv)
 #define PERL_ARGS_ASSERT_STASHPV_HVNAME_MATCH  \
        assert(c); assert(hv)
 
-PERL_CALLCONV void     Perl_store_cop_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_STORE_COP_LABEL       \
-       assert(cop); assert(label)
-
 PERL_CALLCONV NV       Perl_str_to_version(pTHX_ SV *sv)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -4419,7 +4428,8 @@ PERL_CALLCONV void        Perl_vivify_defelem(pTHX_ SV* sv)
 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM        \
        assert(sv)
 
-PERL_CALLCONV void     Perl_vivify_ref(pTHX_ SV* sv, U32 to_what)
+PERL_CALLCONV SV*      Perl_vivify_ref(pTHX_ SV* sv, U32 to_what)
+                       __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_VIVIFY_REF    \
        assert(sv)
@@ -4493,6 +4503,9 @@ PERL_CALLCONV void        Perl_warner(pTHX_ U32 err, const char* pat, ...)
 #define PERL_ARGS_ASSERT_WARNER        \
        assert(pat)
 
+PERL_CALLCONV I32      Perl_was_lvalue_sub(pTHX)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV void     Perl_watch(pTHX_ char** addr)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_WATCH \
@@ -4685,6 +4698,15 @@ STATIC PerlIO *  S_doopen_pm(pTHX_ SV *name)
 
 #  endif
 #endif
+#if !defined(PERL_IMPLICIT_SYS)
+PERL_CALLCONV I32      Perl_my_pclose(pTHX_ PerlIO* ptr);
+PERL_CALLCONV PerlIO*  Perl_my_popen(pTHX_ const char* cmd, const char* mode)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MY_POPEN      \
+       assert(cmd); assert(mode)
+
+#endif
 #if !defined(PERL_IS_MINIPERL)
 #  if defined(PERL_IN_PERL_C)
 STATIC SV *    S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem)
@@ -5003,8 +5025,6 @@ PERL_CALLCONV void        Perl_pending_Slabs_to_ro(pTHX);
 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
 /* PERL_CALLCONV bool  Perl_do_exec(pTHX_ const char* cmd)
                        __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_DO_EXEC       \
-       assert(cmd)
 
 #endif
 #if defined(PERL_DONT_CREATE_GVSV)
@@ -5444,6 +5464,7 @@ STATIC AV*        S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level)
 STATIC NV      S_mulexp10(NV value, I32 exponent);
 #endif
 #if defined(PERL_IN_OP_C)
+PERL_STATIC_INLINE bool        S_aassign_common_vars(pTHX_ OP* o);
 STATIC void    S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -5474,6 +5495,11 @@ STATIC OP *      S_dup_attrlist(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_DUP_ATTRLIST  \
        assert(o)
 
+STATIC void    S_finalize_op(pTHX_ OP* o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FINALIZE_OP   \
+       assert(o)
+
 STATIC void    S_find_and_forget_pmops(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \
@@ -5491,17 +5517,17 @@ STATIC const char*      S_gv_ename(pTHX_ GV *gv)
 #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       \
+       assert(o)
+
 STATIC bool    S_is_handle_constructor(const OP *o, I32 numargs)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \
        assert(o)
 
-STATIC OP*     S_is_inplace_av(pTHX_ OP* o, OP* oright)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_INPLACE_AV \
-       assert(o)
-
 STATIC I32     S_is_list_assignment(pTHX_ const OP *o)
                        __attribute__warn_unused_result__;
 
@@ -5532,7 +5558,7 @@ STATIC OP*        S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp)
 #define PERL_ARGS_ASSERT_NEW_LOGOP     \
        assert(firstp); assert(otherp)
 
-STATIC void    S_no_bareword_allowed(pTHX_ const OP *o)
+STATIC void    S_no_bareword_allowed(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED   \
        assert(o)
@@ -5543,6 +5569,16 @@ STATIC OP*       S_no_fh_allowed(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \
        assert(o)
 
+PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OP_INTEGERIZE \
+       assert(o)
+
+PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OP_STD_INIT   \
+       assert(o)
+
 STATIC OP*     S_opt_scalarhv(pTHX_ OP* rep_op)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OPT_SCALARHV  \
@@ -5565,10 +5601,7 @@ STATIC void      S_process_special_blocks(pTHX_ const char *const fullname, GV *const
 STATIC OP*     S_ref_array_or_hash(pTHX_ OP* cond);
 STATIC OP*     S_refkids(pTHX_ OP* o, I32 type);
 STATIC bool    S_scalar_mod_type(const OP *o, I32 type)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE       \
-       assert(o)
+                       __attribute__warn_unused_result__;
 
 STATIC OP*     S_scalarboolean(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
@@ -5596,7 +5629,6 @@ STATIC OP*        S_too_few_arguments(pTHX_ OP *o, const char* name)
        assert(o); assert(name)
 
 STATIC OP*     S_too_many_arguments(pTHX_ OP *o, const char* name)
-                       __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS    \
@@ -5611,23 +5643,23 @@ STATIC void     S_forget_pmop(pTHX_ PMOP *const o, U32 flags)
 #  endif
 #endif
 #if defined(PERL_IN_PAD_C)
-STATIC PADOFFSET       S_pad_add_name_sv(pTHX_ SV *namesv, const U32 flags, HV *typestash, HV *ourstash)
+STATIC PADOFFSET       S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash)
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV       \
+#define PERL_ARGS_ASSERT_PAD_ALLOC_NAME        \
        assert(namesv)
 
-STATIC void    S_pad_check_dup(pTHX_ SV *name, const U32 flags, const HV *ourstash)
+STATIC void    S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \
        assert(name)
 
-STATIC PADOFFSET       S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
+STATIC PADOFFSET       S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_6)
-                       __attribute__nonnull__(pTHX_7);
+                       __attribute__nonnull__(pTHX_4)
+                       __attribute__nonnull__(pTHX_8)
+                       __attribute__nonnull__(pTHX_9);
 #define PERL_ARGS_ASSERT_PAD_FINDLEX   \
-       assert(name); assert(cv); assert(out_name_sv); assert(out_flags)
+       assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags)
 
 STATIC void    S_pad_reset(pTHX);
 #endif
@@ -5724,7 +5756,7 @@ STATIC void       S_destroy_matcher(pTHX_ PMOP* matcher)
 #define PERL_ARGS_ASSERT_DESTROY_MATCHER       \
        assert(matcher)
 
-STATIC OP*     S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other);
+STATIC OP*     S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied);
 STATIC OP*     S_docatch(pTHX_ OP *o)
                        __attribute__warn_unused_result__;
 
@@ -5992,32 +6024,6 @@ PERL_STATIC_INLINE UV*   S__invlist_array_init(pTHX_ SV* const invlist, const bool
 #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT   \
        assert(invlist)
 
-STATIC void    S__invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION \
-       assert(a); assert(b); assert(i)
-
-STATIC void    S__invlist_invert(pTHX_ SV* const invlist)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__INVLIST_INVERT       \
-       assert(invlist)
-
-STATIC void    S__invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT     \
-       assert(a); assert(b); assert(result)
-
-STATIC void    S__invlist_union(pTHX_ SV* const a, SV* const b, SV** output)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT__INVLIST_UNION        \
-       assert(a); assert(b); assert(output)
-
 STATIC void    S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -6301,6 +6307,59 @@ 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
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
+PERL_CALLCONV void     Perl__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST      \
+       assert(invlist)
+
+PERL_CALLCONV void     Perl__invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION \
+       assert(a); assert(b); assert(i)
+
+PERL_CALLCONV void     Perl__invlist_invert(pTHX_ SV* const invlist)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_INVERT       \
+       assert(invlist)
+
+PERL_CALLCONV void     Perl__invlist_invert_prop(pTHX_ SV* const invlist)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_INVERT_PROP  \
+       assert(invlist)
+
+PERL_CALLCONV void     Perl__invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT     \
+       assert(a); assert(b); assert(result)
+
+PERL_CALLCONV void     Perl__invlist_union(pTHX_ SV* const a, SV* const b, SV** output)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT__INVLIST_UNION        \
+       assert(a); assert(b); assert(output)
+
+PERL_CALLCONV SV*      Perl__new_invlist(pTHX_ IV initial_size)
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV HV*      Perl__swash_inversion_hash(pTHX_ SV* const swash)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
+       assert(swash)
+
+PERL_CALLCONV SV*      Perl__swash_to_invlist(pTHX_ SV* const swash)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__SWASH_TO_INVLIST     \
+       assert(swash)
+
+#endif
 #if defined(PERL_IN_REGEXEC_C)
 STATIC char*   S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo)
                        __attribute__warn_unused_result__
@@ -7123,7 +7182,7 @@ PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv)
 #define PERL_ARGS_ASSERT_NEWPADOP      \
        assert(sv)
 
-PERL_CALLCONV AV*      Perl_padlist_dup(pTHX_ AV *const srcpad, CLONE_PARAMS *const param)
+PERL_CALLCONV AV*      Perl_padlist_dup(pTHX_ AV *srcpad, CLONE_PARAMS *param)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_PADLIST_DUP   \