This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[perl #123223] Make PADNAME a separate type
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 8844932..d6a855a 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -42,6 +42,9 @@ PERL_CALLCONV void    Perl_Slab_Free(pTHX_ void *op)
 #define PERL_ARGS_ASSERT_SLAB_FREE     \
        assert(op)
 
+PERL_CALLCONV SV*      Perl__get_encoding(pTHX)
+                       __attribute__pure__;
+
 PERL_CALLCONV bool     Perl__is_in_locale_category(pTHX_ const bool compiling, const int category);
 PERL_CALLCONV bool     Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
                        __attribute__warn_unused_result__;
@@ -651,6 +654,12 @@ PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_SPLIT      \
        assert(o)
 
+PERL_CALLCONV OP *     Perl_ck_stringify(pTHX_ OP *o)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_STRINGIFY  \
+       assert(o)
+
 PERL_CALLCONV OP *     Perl_ck_subr(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -700,9 +709,6 @@ PERL_CALLCONV const COP*    Perl_closest_cop(pTHX_ const COP *cop, const OP *o, con
 #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 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       \
@@ -901,6 +907,16 @@ PERL_CALLCONV char*        Perl_delimcpy(char* to, const char* toend, const char* from,
        assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
 
 PERL_CALLCONV void     Perl_despatch_signals(pTHX);
+PERL_CALLCONV_NO_RET OP*       Perl_die(pTHX_ const char* pat, ...)
+                       __attribute__noreturn__
+                       __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+
+PERL_CALLCONV_NO_RET OP*       Perl_die_sv(pTHX_ SV *baseex)
+                       __attribute__noreturn__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DIE_SV        \
+       assert(baseex)
+
 PERL_CALLCONV_NO_RET void      Perl_die_unwind(pTHX_ SV* msv)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1);
@@ -1831,7 +1847,7 @@ PERL_CALLCONV U32 Perl_intro_my(pTHX);
 PERL_CALLCONV OP*      Perl_invert(pTHX_ OP* cmd)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV bool     Perl_io_close(pTHX_ IO* io, bool not_implicit)
+PERL_CALLCONV bool     Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IO_CLOSE      \
        assert(io)
@@ -1852,9 +1868,14 @@ PERL_CALLCONV bool       Perl_isIDFIRST_lazy(pTHX_ const char* p)
 #define PERL_ARGS_ASSERT_ISIDFIRST_LAZY        \
        assert(p)
 
-PERL_CALLCONV bool     Perl_is_ascii_string(const U8 *s, STRLEN len)
+/* PERL_CALLCONV bool  Perl_is_ascii_string(pTHX_ const U8 *s, STRLEN len)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV bool     Perl_is_invariant_string(const U8 *s, STRLEN len)
+                       __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_IS_ASCII_STRING       \
+#define PERL_ARGS_ASSERT_IS_INVARIANT_STRING   \
        assert(s)
 
 PERL_CALLCONV I32      Perl_is_lvalue_sub(pTHX)
@@ -2847,6 +2868,9 @@ PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV OP*      Perl_newDEFSVOP(pTHX)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV void     Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
 PERL_CALLCONV OP*      Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
                        __attribute__malloc__
@@ -2957,6 +2981,24 @@ PERL_CALLCONV OP*        Perl_newOP(pTHX_ I32 optype, I32 flags)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV PADNAMELIST *    Perl_newPADNAMELIST(pTHX_ size_t max)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV PADNAME *        Perl_newPADNAMEouter(pTHX_ PADNAME *outer)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEOUTER       \
+       assert(outer)
+
+PERL_CALLCONV PADNAME *        Perl_newPADNAMEpvn(pTHX_ const char *s, STRLEN len)
+                       __attribute__malloc__
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEPVN \
+       assert(s)
+
 PERL_CALLCONV OP*      Perl_newPMOP(pTHX_ I32 type, I32 flags)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -2985,12 +3027,12 @@ PERL_CALLCONV SV*       Perl_newRV(pTHX_ SV *const sv)
 #define PERL_ARGS_ASSERT_NEWRV \
        assert(sv)
 
-PERL_CALLCONV SV*      Perl_newRV_noinc(pTHX_ SV *const sv)
+PERL_CALLCONV SV*      Perl_newRV_noinc(pTHX_ SV *const tmpRef)
                        __attribute__malloc__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_NEWRV_NOINC   \
-       assert(sv)
+       assert(tmpRef)
 
 PERL_CALLCONV OP*      Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop)
                        __attribute__malloc__
@@ -3109,6 +3151,12 @@ PERL_CALLCONV CV*        Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const c
 #define PERL_ARGS_ASSERT_NEWXS \
        assert(subaddr); assert(filename)
 
+PERL_CALLCONV CV *     Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_NEWXS_DEFFILE \
+       assert(name); assert(subaddr)
+
 PERL_CALLCONV CV *     Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -3116,10 +3164,9 @@ PERL_CALLCONV CV *       Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr,
        assert(subaddr); assert(filename)
 
 PERL_CALLCONV CV *     Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char *const filename, const char *const proto, SV **const_svp, U32 flags)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS       \
-       assert(subaddr); assert(filename)
+       assert(subaddr)
 
 PERL_CALLCONV void     Perl_new_collate(pTHX_ const char* newcoll);
 PERL_CALLCONV void     Perl_new_ctype(pTHX_ const char* newctype)
@@ -3158,6 +3205,13 @@ PERL_CALLCONV char*      Perl_ninstr(const char* big, const char* bigend, const char*
 #define PERL_ARGS_ASSERT_NINSTR        \
        assert(big); assert(bigend); assert(little); assert(lend)
 
+PERL_CALLCONV_NO_RET void      Perl_noperl_die(const char* pat, ...)
+                       __attribute__noreturn__
+                       __attribute__format__(__printf__,1,2)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NOPERL_DIE    \
+       assert(pat)
+
 PERL_CALLCONV int      Perl_nothreadhook(pTHX);
 PERL_CALLCONV OP*      Perl_oopsAV(pTHX_ OP* o)
                        __attribute__warn_unused_result__
@@ -3178,14 +3232,14 @@ PERL_CALLCONV void      Perl_op_clear(pTHX_ OP* o)
 #define PERL_ARGS_ASSERT_OP_CLEAR      \
        assert(o)
 
-PERL_CALLCONV SV*      Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
-                       __attribute__warn_unused_result__;
-
 PERL_CALLCONV OP*      Perl_op_contextualize(pTHX_ OP* o, I32 context)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE      \
        assert(o)
 
+PERL_CALLCONV OP*      Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP* o)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV void     Perl_op_dump(pTHX_ const OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_DUMP       \
@@ -3313,6 +3367,27 @@ PERL_CALLCONV PAD **     Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *va
 #define PERL_ARGS_ASSERT_PADLIST_STORE \
        assert(padlist)
 
+PERL_CALLCONV void     Perl_padname_free(pTHX_ PADNAME *pn)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAME_FREE  \
+       assert(pn)
+
+PERL_CALLCONV PADNAME *        Perl_padnamelist_fetch(pTHX_ PADNAMELIST *pnl, SSize_t key)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FETCH     \
+       assert(pnl)
+
+PERL_CALLCONV void     Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FREE      \
+       assert(pnl)
+
+PERL_CALLCONV PADNAME **       Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_STORE     \
+       assert(pnl)
+
 PERL_CALLCONV OP*      Perl_parse_arithexpr(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_barestmt(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_block(pTHX_ U32 flags);
@@ -3433,10 +3508,9 @@ PERL_CALLCONV char*      Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, S
        assert(dsv); assert(pv)
 
 PERL_CALLCONV char*    Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)
-                       __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_PV_ESCAPE     \
-       assert(dsv); assert(str)
+       assert(str)
 
 PERL_CALLCONV char*    Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)
                        __attribute__nonnull__(pTHX_1)
@@ -3620,12 +3694,6 @@ PERL_CALLCONV void       Perl_reginitcolors(pTHX);
 PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p)
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV void     Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_REGPROP       \
-       assert(sv); assert(o)
-
 PERL_CALLCONV void     Perl_repeatcpy(char* to, const char* from, I32 len, IV count)
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(2);
@@ -5151,11 +5219,12 @@ PERL_CALLCONV void      Perl_write_to_stderr(pTHX_ SV* msv)
 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR       \
        assert(msv)
 
-PERL_CALLCONV void     Perl_xs_apiversion_bootcheck(pTHX_ SV *module, const char *api_p, STRLEN api_len)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK       \
-       assert(module); assert(api_p)
+PERL_CALLCONV void     Perl_xs_boot_epilog(pTHX_ const U32 ax);
+PERL_CALLCONV I32      Perl_xs_handshake(const U32 key, void * v_my_perl, const char * file, ...)
+                       __attribute__nonnull__(2)
+                       __attribute__nonnull__(3);
+#define PERL_ARGS_ASSERT_XS_HANDSHAKE  \
+       assert(v_my_perl); assert(file)
 
 PERL_CALLCONV void     Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
                        __attribute__nonnull__(pTHX_3);
@@ -5220,16 +5289,6 @@ PERL_CALLCONV void*      Perl_my_cxt_init(pTHX_ int *index, size_t size)
 
 #endif
 #if !(defined(_MSC_VER))
-PERL_CALLCONV_NO_RET OP*       Perl_die(pTHX_ const char* pat, ...)
-                       __attribute__noreturn__
-                       __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
-
-PERL_CALLCONV_NO_RET OP*       Perl_die_sv(pTHX_ SV *baseex)
-                       __attribute__noreturn__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DIE_SV        \
-       assert(baseex)
-
 PERL_CALLCONV_NO_RET int       Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1)
@@ -5237,20 +5296,6 @@ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
        assert(sv); assert(mg)
 
-PERL_CALLCONV_NO_RET char*     Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
-                       __attribute__noreturn__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SCREAMINSTR   \
-       assert(bigstr); assert(littlestr); assert(old_posp)
-
-#  if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV_NO_RET OP*       Perl_die_nocontext(const char* pat, ...)
-                       __attribute__noreturn__
-                       __attribute__format__null_ok__(__printf__,1,2);
-
-#  endif
 #endif
 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
 PERL_CALLCONV char*    Perl_my_bzero(char* loc, I32 len)
@@ -5428,6 +5473,11 @@ PERL_CALLCONV void       Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
        assert(sv)
 
 PERL_CALLCONV SV*      Perl_pad_sv(pTHX_ PADOFFSET po);
+PERL_CALLCONV void     Perl_set_padlist(CV * cv, PADLIST * padlist)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SET_PADLIST   \
+       assert(cv)
+
 #  if defined(PERL_IN_PAD_C)
 STATIC void    S_cv_dump(pTHX_ const CV *cv, const char *title)
                        __attribute__nonnull__(pTHX_1)
@@ -5748,6 +5798,10 @@ PERL_CALLCONV void       Perl_deb_nocontext(const char* pat, ...)
 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \
        assert(pat)
 
+PERL_CALLCONV_NO_RET OP*       Perl_die_nocontext(const char* pat, ...)
+                       __attribute__noreturn__
+                       __attribute__format__null_ok__(__printf__,1,2);
+
 PERL_CALLCONV char*    Perl_form_nocontext(const char* pat, ...)
                        __attribute__format__(__printf__,1,2)
                        __attribute__nonnull__(1);
@@ -5824,11 +5878,6 @@ PERL_CALLCONV void       Perl_warner_nocontext(U32 err, const char* pat, ...)
 #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT      \
        assert(pat)
 
-#  if defined(_MSC_VER)
-PERL_CALLCONV OP*      Perl_die_nocontext(const char* pat, ...)
-                       __attribute__format__null_ok__(__printf__,1,2);
-
-#  endif
 #endif
 #if defined(PERL_IMPLICIT_SYS)
 PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP)
@@ -6280,9 +6329,6 @@ STATIC OP *       S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
 #define PERL_ARGS_ASSERT_MY_KID        \
        assert(imopsp)
 
-STATIC OP*     S_newDEFSVOP(pTHX)
-                       __attribute__warn_unused_result__;
-
 STATIC OP*     S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_NEWGIVWHENOP  \
@@ -6307,11 +6353,6 @@ STATIC OP*       S_no_fh_allowed(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \
        assert(o)
 
-STATIC void    S_null_listop_in_list_context(pTHX_ OP* o)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_NULL_LISTOP_IN_LIST_CONTEXT   \
-       assert(o)
-
 PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_INTEGERIZE \
@@ -6390,23 +6431,23 @@ PERL_CALLCONV void      Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_
 
 #endif
 #if defined(PERL_IN_PAD_C)
-STATIC PADOFFSET       S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash)
+STATIC PADOFFSET       S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_ALLOC_NAME        \
-       assert(namesv)
+       assert(name)
 
-STATIC void    S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash)
+STATIC void    S_pad_check_dup(pTHX_ PADNAME *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 *namepv, STRLEN namelen, U32 flags, 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, PADNAME** out_name, int *out_flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_4)
                        __attribute__nonnull__(pTHX_8)
                        __attribute__nonnull__(pTHX_9);
 #define PERL_ARGS_ASSERT_PAD_FINDLEX   \
-       assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags)
+       assert(namepv); assert(cv); assert(out_name); assert(out_flags)
 
 STATIC void    S_pad_reset(pTHX);
 #endif
@@ -6465,7 +6506,7 @@ PERL_STATIC_NO_RET void   S_usage(pTHX)
 
 #endif
 #if defined(PERL_IN_PP_C)
-STATIC void    S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
+STATIC size_t  S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_DO_CHOMP      \
@@ -6603,10 +6644,9 @@ STATIC void      S_do_oddball(pTHX_ SV **oddkey, SV **firstkey)
 #define PERL_ARGS_ASSERT_DO_ODDBALL    \
        assert(oddkey); assert(firstkey)
 
-STATIC SV*     S_method_common(pTHX_ SV* meth, U32* hashp)
-                       __attribute__warn_unused_result__
+PERL_STATIC_INLINE HV* S_opmethod_stash(pTHX_ SV* meth)
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_METHOD_COMMON \
+#define PERL_ARGS_ASSERT_OPMETHOD_STASH        \
        assert(meth)
 
 #endif
@@ -7192,6 +7232,12 @@ PERL_CALLCONV SV*        Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, co
        assert(node)
 
 PERL_CALLCONV void     Perl__load_PL_utf8_foldclosures(pTHX);
+PERL_CALLCONV void     Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_REGPROP       \
+       assert(sv); assert(o)
+
 #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)
@@ -7830,13 +7876,14 @@ STATIC bool     S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U
 
 #endif
 #if defined(PERL_IN_UTF8_C)
-STATIC UV      S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
+STATIC UV      S_check_locale_boundary_crossing(pTHX_ const char * const func_name, const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_4)
+                       __attribute__nonnull__(pTHX_5);
 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING        \
-       assert(p); assert(ustrp); assert(lenp)
+       assert(func_name); assert(p); assert(ustrp); assert(lenp)
 
 PERL_STATIC_INLINE bool        S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname, SV* const invlist)
                        __attribute__warn_unused_result__
@@ -8005,9 +8052,24 @@ PERL_CALLCONV OP*        Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv)
 
 PERL_CALLCONV PADLIST *        Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
                        __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_PADLIST_DUP   \
-       assert(param)
+       assert(srcpad); assert(param)
+
+PERL_CALLCONV PADNAME *        Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAME_DUP   \
+       assert(src); assert(param)
+
+PERL_CALLCONV PADNAMELIST *    Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAMELIST_DUP       \
+       assert(srcpad); assert(param)
 
 PERL_CALLCONV yy_parser*       Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param)
                        __attribute__nonnull__(pTHX_2);
@@ -8119,6 +8181,8 @@ PERL_CALLCONV SSize_t     Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count
 #define PERL_ARGS_ASSERT_PERLIO_READ   \
        assert(vbuf)
 
+PERL_CALLCONV void     Perl_PerlIO_restore_errno(pTHX_ PerlIO *f);
+PERL_CALLCONV void     Perl_PerlIO_save_errno(pTHX_ PerlIO *f);
 PERL_CALLCONV int      Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
 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);
@@ -8186,27 +8250,12 @@ PERL_CALLCONV int       Perl_do_spawn_nowait(pTHX_ char* cmd)
 
 #endif
 #if defined(_MSC_VER)
-PERL_CALLCONV OP*      Perl_die(pTHX_ const char* pat, ...)
-                       __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
-
-PERL_CALLCONV OP*      Perl_die_sv(pTHX_ SV *baseex)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DIE_SV        \
-       assert(baseex)
-
 PERL_CALLCONV int      Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET    \
        assert(sv); assert(mg)
 
-PERL_CALLCONV char*    Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SCREAMINSTR   \
-       assert(bigstr); assert(littlestr); assert(old_posp)
-
 #endif
 #ifdef PERL_CORE
 #  include "pp_proto.h"
Unnamed repository; edit this file 'description' to name the repository.