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
regen generated files changed by the previous patch - facility to plug in syntax...
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 4207599..92737e0 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -3,7 +3,7 @@
  *    proto.h
  *
  *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- *    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, by Larry Wall and others
+ *    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -131,7 +131,7 @@ PERL_CALLCONV SV*   Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int di
 #define PERL_ARGS_ASSERT_AMAGIC_CALL   \
        assert(left); assert(right)
 
-PERL_CALLCONV bool     Perl_Gv_AMupdate(pTHX_ HV* stash)
+PERL_CALLCONV int      Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_AMUPDATE   \
        assert(stash)
@@ -335,10 +335,7 @@ PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...)
                        __attribute__format__null_ok__(__printf__,1,2);
 
 PERL_CALLCONV OP*      Perl_die_nocontext(const char* pat, ...)
-                       __attribute__format__(__printf__,1,2)
-                       __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_DIE_NOCONTEXT \
-       assert(pat)
+                       __attribute__format__null_ok__(__printf__,1,2);
 
 PERL_CALLCONV void     Perl_deb_nocontext(const char* pat, ...)
                        __attribute__format__(__printf__,1,2)
@@ -509,33 +506,23 @@ PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o)
 
 PERL_CALLCONV I32      Perl_debstack(pTHX);
 PERL_CALLCONV I32      Perl_debstackptrs(pTHX);
-PERL_CALLCONV char*    Perl_delimcpy(pTHX_ char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4)
-                       __attribute__nonnull__(pTHX_6);
+PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen)
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2)
+                       __attribute__nonnull__(3)
+                       __attribute__nonnull__(4)
+                       __attribute__nonnull__(6);
 #define PERL_ARGS_ASSERT_DELIMCPY      \
        assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
 
 PERL_CALLCONV void     Perl_delete_eval_scope(pTHX);
-PERL_CALLCONV void     Perl_deprecate(pTHX_ const char *const s)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DEPRECATE     \
-       assert(s)
-
-PERL_CALLCONV void     Perl_deprecate_old(pTHX_ const char *const s)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DEPRECATE_OLD \
-       assert(s)
-
 PERL_CALLCONV OP*      Perl_die(pTHX_ const char* pat, ...)
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 
 #if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT)
 STATIC OP*     S_vdie(pTHX_ const char* pat, va_list* args);
 #endif
-PERL_CALLCONV OP*      Perl_die_where(pTHX_ const char* message, STRLEN msglen);
+PERL_CALLCONV OP*      Perl_die_where(pTHX_ SV* msv);
 PERL_CALLCONV void     Perl_dounwind(pTHX_ I32 cxix);
 /* PERL_CALLCONV bool  Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
@@ -742,6 +729,7 @@ PERL_CALLCONV I32   Perl_dowantarray(pTHX)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV void     Perl_dump_all(pTHX);
+PERL_CALLCONV void     Perl_dump_all_perl(pTHX_ bool justperl);
 PERL_CALLCONV void     Perl_dump_eval(pTHX);
 #if defined(DUMP_FDS)
 PERL_CALLCONV void     Perl_dump_fds(pTHX_ char* s)
@@ -771,11 +759,21 @@ PERL_CALLCONV void        Perl_dump_packsubs(pTHX_ const HV* stash)
 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \
        assert(stash)
 
+PERL_CALLCONV void     Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL    \
+       assert(stash)
+
 PERL_CALLCONV void     Perl_dump_sub(pTHX_ const GV* gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_DUMP_SUB      \
        assert(gv)
 
+PERL_CALLCONV void     Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DUMP_SUB_PERL \
+       assert(gv)
+
 PERL_CALLCONV void     Perl_fbm_compile(pTHX_ SV* sv, U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_FBM_COMPILE   \
@@ -832,21 +830,10 @@ PERL_CALLCONV void        Perl_get_db_sub(pTHX_ SV **svp, CV *cv)
 
 PERL_CALLCONV void     Perl_gp_free(pTHX_ GV* gv);
 PERL_CALLCONV GP*      Perl_gp_ref(pTHX_ GP* gp);
-PERL_CALLCONV GV*      Perl_gv_AVadd(pTHX_ GV* gv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_AVADD      \
-       assert(gv)
-
-PERL_CALLCONV GV*      Perl_gv_HVadd(pTHX_ GV* gv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_HVADD      \
-       assert(gv)
-
-PERL_CALLCONV GV*      Perl_gv_IOadd(pTHX_ GV* gv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_IOADD      \
-       assert(gv)
-
+PERL_CALLCONV GV*      Perl_gv_add_by_type(pTHX_ GV *gv, svtype type);
+/* PERL_CALLCONV GV*   Perl_gv_AVadd(pTHX_ GV *gv); */
+/* PERL_CALLCONV GV*   Perl_gv_HVadd(pTHX_ GV *gv); */
+/* PERL_CALLCONV GV*   Perl_gv_IOadd(pTHX_ GV* gv); */
 PERL_CALLCONV GV*      Perl_gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
@@ -1090,17 +1077,17 @@ STATIC struct refcounted_he *   S_refcounted_he_new_common(pTHX_ struct refcounted
 /* PERL_CALLCONV HE*   Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */
 /* PERL_CALLCONV SV**  Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */
 PERL_CALLCONV void     Perl_hv_undef(pTHX_ HV *hv);
-PERL_CALLCONV I32      Perl_ibcmp(pTHX_ const char* a, const char* b, I32 len)
+PERL_CALLCONV I32      Perl_ibcmp(const char* a, const char* b, I32 len)
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_IBCMP \
        assert(a); assert(b)
 
-PERL_CALLCONV I32      Perl_ibcmp_locale(pTHX_ const char* a, const char* b, I32 len)
+PERL_CALLCONV I32      Perl_ibcmp_locale(const char* a, const char* b, I32 len)
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_IBCMP_LOCALE  \
        assert(a); assert(b)
 
@@ -1128,11 +1115,11 @@ PERL_CALLCONV void      Perl_init_tm(pTHX_ struct tm *ptm)
        assert(ptm)
 
 PERL_CALLCONV U32      Perl_intro_my(pTHX);
-PERL_CALLCONV char*    Perl_instr(pTHX_ const char* big, const char* little)
+PERL_CALLCONV char*    Perl_instr(const char* big, const char* little)
                        __attribute__warn_unused_result__
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_INSTR \
        assert(big); assert(little)
 
@@ -1163,10 +1150,6 @@ PERL_CALLCONV bool       Perl_is_uni_alnum(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
-PERL_CALLCONV bool     Perl_is_uni_alnumc(pTHX_ UV c)
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-
 PERL_CALLCONV bool     Perl_is_uni_idfirst(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
@@ -1243,10 +1226,6 @@ PERL_CALLCONV bool       Perl_is_uni_alnum_lc(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
-PERL_CALLCONV bool     Perl_is_uni_alnumc_lc(pTHX_ UV c)
-                       __attribute__warn_unused_result__
-                       __attribute__pure__;
-
 PERL_CALLCONV bool     Perl_is_uni_idfirst_lc(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
@@ -1295,23 +1274,28 @@ PERL_CALLCONV bool      Perl_is_uni_xdigit_lc(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
-PERL_CALLCONV STRLEN   Perl_is_utf8_char(pTHX_ const U8 *s)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV bool     Perl_is_ascii_string(const U8 *s, STRLEN len)
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_IS_ASCII_STRING       \
+       assert(s)
+
+PERL_CALLCONV STRLEN   Perl_is_utf8_char(const U8 *s)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR  \
        assert(s)
 
-PERL_CALLCONV bool     Perl_is_utf8_string(pTHX_ const U8 *s, STRLEN len)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV bool     Perl_is_utf8_string(const U8 *s, STRLEN len)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING        \
        assert(s)
 
-/* PERL_CALLCONV bool  Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **p)
-                       __attribute__nonnull__(pTHX_1); */
+/* PERL_CALLCONV bool  Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p)
+                       __attribute__nonnull__(1); */
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC    \
        assert(s)
 
-PERL_CALLCONV bool     Perl_is_utf8_string_loclen(pTHX_ const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV bool     Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
+                       __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \
        assert(s)
 
@@ -1321,12 +1305,6 @@ PERL_CALLCONV bool       Perl_is_utf8_alnum(pTHX_ const U8 *p)
 #define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \
        assert(p)
 
-PERL_CALLCONV bool     Perl_is_utf8_alnumc(pTHX_ const U8 *p)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC        \
-       assert(p)
-
 PERL_CALLCONV bool     Perl_is_utf8_idfirst(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -1357,6 +1335,18 @@ PERL_CALLCONV bool       Perl_is_utf8_space(pTHX_ const U8 *p)
 #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \
        assert(p)
 
+PERL_CALLCONV bool     Perl_is_utf8_perl_space(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE    \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_perl_word(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD     \
+       assert(p)
+
 PERL_CALLCONV bool     Perl_is_utf8_cntrl(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -1369,6 +1359,12 @@ PERL_CALLCONV bool       Perl_is_utf8_digit(pTHX_ const U8 *p)
 #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \
        assert(p)
 
+PERL_CALLCONV bool     Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT   \
+       assert(p)
+
 PERL_CALLCONV bool     Perl_is_utf8_graph(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -1422,6 +1418,13 @@ PERL_CALLCONV I32        Perl_keyword(pTHX_ const char *name, I32 len, bool all_keyword
 #define PERL_ARGS_ASSERT_KEYWORD       \
        assert(name)
 
+#if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT)
+STATIC OP*     S_opt_scalarhv(pTHX_ OP* rep_op)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPT_SCALARHV  \
+       assert(rep_op)
+
+#endif
 PERL_CALLCONV void     Perl_leave_scope(pTHX_ I32 base);
 PERL_CALLCONV void     Perl_lex_end(pTHX);
 PERL_CALLCONV void     Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, bool new_filter);
@@ -1518,12 +1521,17 @@ PERL_CALLCONV int       Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg)
 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT       \
        assert(sv); assert(mg)
 
-PERL_CALLCONV int      Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg)
+PERL_CALLCONV int      Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_CLEARISA        \
+#define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS      \
        assert(sv); assert(mg)
 
+PERL_CALLCONV int      Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_CLEARISA        \
+       assert(mg)
+
 PERL_CALLCONV int      Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -1731,10 +1739,9 @@ PERL_CALLCONV int        Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg)
        assert(sv); assert(mg)
 
 PERL_CALLCONV int      Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg)
-                       __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_MAGIC_SETSIG  \
-       assert(sv); assert(mg)
+       assert(mg)
 
 PERL_CALLCONV int      Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg)
                        __attribute__nonnull__(pTHX_1)
@@ -2124,9 +2131,9 @@ PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV IO*      Perl_newIO(pTHX)
+/* PERL_CALLCONV IO*   Perl_newIO(pTHX)
                        __attribute__malloc__
-                       __attribute__warn_unused_result__;
+                       __attribute__warn_unused_result__; */
 
 PERL_CALLCONV OP*      Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
                        __attribute__malloc__
@@ -2314,12 +2321,12 @@ PERL_CALLCONV PerlIO*   Perl_nextargv(pTHX_ GV* gv)
 #define PERL_ARGS_ASSERT_NEXTARGV      \
        assert(gv)
 
-PERL_CALLCONV char*    Perl_ninstr(pTHX_ const char* big, const char* bigend, const char* little, const char* lend)
+PERL_CALLCONV char*    Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend)
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2)
+                       __attribute__nonnull__(3)
+                       __attribute__nonnull__(4);
 #define PERL_ARGS_ASSERT_NINSTR        \
        assert(big); assert(bigend); assert(little); assert(lend)
 
@@ -2337,6 +2344,11 @@ PERL_CALLCONV void       Perl_package(pTHX_ OP* o)
        assert(o)
 
 #endif
+PERL_CALLCONV void     Perl_package_version(pTHX_ OP* v)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PACKAGE_VERSION       \
+       assert(v)
+
 PERL_CALLCONV PADOFFSET        Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
 PERL_CALLCONV PADOFFSET        Perl_allocmy(pTHX_ const char *const name)
                        __attribute__nonnull__(pTHX_1);
@@ -2424,17 +2436,17 @@ PERL_CALLCONV I32       Perl_eval_sv(pTHX_ SV* sv, I32 flags)
 #define PERL_ARGS_ASSERT_EVAL_SV       \
        assert(sv)
 
-PERL_CALLCONV SV*      Perl_get_sv(pTHX_ const char* name, I32 create)
+PERL_CALLCONV SV*      Perl_get_sv(pTHX_ const char *name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GET_SV        \
        assert(name)
 
-PERL_CALLCONV AV*      Perl_get_av(pTHX_ const char* name, I32 create)
+PERL_CALLCONV AV*      Perl_get_av(pTHX_ const char *name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GET_AV        \
        assert(name)
 
-PERL_CALLCONV HV*      Perl_get_hv(pTHX_ const char* name, I32 create)
+PERL_CALLCONV HV*      Perl_get_hv(pTHX_ const char *name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GET_HV        \
        assert(name)
@@ -2488,7 +2500,8 @@ PERL_CALLCONV void        Perl_packlist(pTHX_ SV *cat, const char *pat, const char *pat
 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
 STATIC void    S_pidgone(pTHX_ Pid_t pid, int status);
 #endif
-PERL_CALLCONV void     Perl_pmflag(pTHX_ U32* pmfl, int ch)
+PERL_CALLCONV void     Perl_pmflag(pTHX_ U32 *pmfl, int ch)
+                       __attribute__deprecated__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PMFLAG        \
        assert(pmfl)
@@ -2545,10 +2558,10 @@ PERL_CALLCONV void      Perl_pregfree2(pTHX_ REGEXP *rx)
 #define PERL_ARGS_ASSERT_PREGFREE2     \
        assert(rx)
 
-PERL_CALLCONV REGEXP*  Perl_reg_temp_copy(pTHX_ REGEXP* r)
-                       __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV REGEXP*  Perl_reg_temp_copy(pTHX_ REGEXP* ret_x, REGEXP* rx)
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_REG_TEMP_COPY \
-       assert(r)
+       assert(rx)
 
 PERL_CALLCONV void     Perl_regfree_internal(pTHX_ REGEXP *const rx)
                        __attribute__nonnull__(pTHX_1);
@@ -2670,18 +2683,18 @@ PERL_CALLCONV void      Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode*
 #define PERL_ARGS_ASSERT_REGPROP       \
        assert(sv); assert(o)
 
-PERL_CALLCONV void     Perl_repeatcpy(pTHX_ char* to, const char* from, I32 len, I32 count)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+PERL_CALLCONV void     Perl_repeatcpy(char* to, const char* from, I32 len, I32 count)
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_REPEATCPY     \
        assert(to); assert(from)
 
-PERL_CALLCONV char*    Perl_rninstr(pTHX_ const char* big, const char* bigend, const char* little, const char* lend)
+PERL_CALLCONV char*    Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend)
                        __attribute__pure__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2)
+                       __attribute__nonnull__(3)
+                       __attribute__nonnull__(4);
 #define PERL_ARGS_ASSERT_RNINSTR       \
        assert(big); assert(bigend); assert(little); assert(lend)
 
@@ -2748,10 +2761,14 @@ PERL_CALLCONV char*     Perl_savesvpv(pTHX_ SV* sv)
 
 PERL_CALLCONV void     Perl_savestack_grow(pTHX);
 PERL_CALLCONV void     Perl_savestack_grow_cnt(pTHX_ I32 need);
-PERL_CALLCONV void     Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr)
+/* PERL_CALLCONV void  Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr)
+                       __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)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_SAVE_AELEM    \
+#define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS      \
        assert(av); assert(sptr)
 
 PERL_CALLCONV I32      Perl_save_alloc(pTHX_ I32 size, I32 pad);
@@ -2781,6 +2798,12 @@ PERL_CALLCONV void       Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen)
 #define PERL_ARGS_ASSERT_SAVE_DELETE   \
        assert(hv); assert(key)
 
+PERL_CALLCONV void     Perl_save_hdelete(pTHX_ HV *hv, SV *keysv)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SAVE_HDELETE  \
+       assert(hv); assert(keysv)
+
 PERL_CALLCONV void     Perl_save_adelete(pTHX_ AV *av, I32 key)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SAVE_ADELETE  \
@@ -2825,8 +2848,6 @@ PERL_CALLCONV void        Perl_save_hints(pTHX);
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3); */
-#define PERL_ARGS_ASSERT_SAVE_HELEM    \
-       assert(hv); assert(key); assert(sptr)
 
 PERL_CALLCONV void     Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags)
                        __attribute__nonnull__(pTHX_1)
@@ -3014,11 +3035,6 @@ STATIC bool      S_glob_2number(pTHX_ GV* const gv)
 #define PERL_ARGS_ASSERT_GLOB_2NUMBER  \
        assert(gv)
 
-STATIC char*   S_glob_2pv(pTHX_ GV* const gv, STRLEN * const len)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GLOB_2PV      \
-       assert(gv)
-
 #endif
 /* PERL_CALLCONV IV    Perl_sv_2iv(pTHX_ SV *sv); */
 PERL_CALLCONV IV       Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags);
@@ -3700,6 +3716,18 @@ PERL_CALLCONV void       Perl_warner(pTHX_ U32 err, const char* pat, ...)
 #define PERL_ARGS_ASSERT_WARNER        \
        assert(pat)
 
+PERL_CALLCONV void     Perl_ck_warner(pTHX_ U32 err, const char* pat, ...)
+                       __attribute__format__(__printf__,pTHX_2,pTHX_3)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CK_WARNER     \
+       assert(pat)
+
+PERL_CALLCONV void     Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...)
+                       __attribute__format__(__printf__,pTHX_2,pTHX_3)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CK_WARNER_D   \
+       assert(pat)
+
 PERL_CALLCONV void     Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_VWARNER       \
@@ -3715,10 +3743,10 @@ PERL_CALLCONV I32       Perl_whichsig(pTHX_ const char* sig)
 #define PERL_ARGS_ASSERT_WHICHSIG      \
        assert(sig)
 
-PERL_CALLCONV void     Perl_write_to_stderr(pTHX_ const char* message, int msglen)
+PERL_CALLCONV void     Perl_write_to_stderr(pTHX_ SV* msv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR       \
-       assert(message)
+       assert(msv)
 
 PERL_CALLCONV int      Perl_yyerror(pTHX_ const char *const s)
                        __attribute__nonnull__(pTHX_1);
@@ -3976,8 +4004,6 @@ PERL_CALLCONV void        Perl_reginitcolors(pTHX);
 
 /* PERL_CALLCONV STRLEN        sv_utf8_upgrade_nomg(pTHX_ SV *sv)
                        __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG  \
-       assert(sv)
 
 PERL_CALLCONV bool     Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok)
                        __attribute__nonnull__(pTHX_1);
@@ -4032,7 +4058,6 @@ PERL_CALLCONV OP *        Perl_my_attrs(pTHX_ OP *o, OP *attrs)
 #define PERL_ARGS_ASSERT_MY_ATTRS      \
        assert(o)
 
-PERL_CALLCONV void     Perl_boot_core_xsutils(pTHX);
 #if defined(USE_ITHREADS)
 PERL_CALLCONV PERL_CONTEXT*    Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param)
                        __attribute__warn_unused_result__
@@ -4099,6 +4124,15 @@ PERL_CALLCONV MAGIC*     Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)
 #define PERL_ARGS_ASSERT_MG_DUP        \
        assert(param)
 
+#if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT)
+STATIC SV **   S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE   \
+       assert(source); assert(dest); assert(param)
+
+#endif
 PERL_CALLCONV SV*      Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
@@ -4257,6 +4291,11 @@ STATIC void      S_hfreeentries(pTHX_ HV *hv)
 #define PERL_ARGS_ASSERT_HFREEENTRIES  \
        assert(hv)
 
+STATIC I32     S_anonymise_cv(pTHX_ HEK *stash, SV *val)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ANONYMISE_CV  \
+       assert(val)
+
 STATIC HE*     S_new_he(pTHX)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -4763,7 +4802,16 @@ STATIC void      S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp)
        assert(linestr_sv); assert(rsfp)
 
 STATIC void    S_forbid_setid(pTHX_ const char flag, const bool suidscript);
-STATIC void    S_incpush(pTHX_ const char *dir, bool addsubdirs, bool addoldvers, bool usesep, bool canrelocate, bool unshift);
+STATIC void    S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INCPUSH       \
+       assert(dir)
+
+STATIC void    S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INCPUSH_USE_SEP       \
+       assert(p)
+
 STATIC void    S_init_interp(pTHX);
 STATIC void    S_init_ids(pTHX);
 STATIC void    S_init_main_stash(pTHX);
@@ -4790,50 +4838,29 @@ STATIC void     S_usage(pTHX_ const char *name)
 #define PERL_ARGS_ASSERT_USAGE \
        assert(name)
 
-#ifdef DOSUID
-#  ifdef IAMSUID
-STATIC void    S_validate_suid(pTHX_ const char *validarg, int fdscript, bool suidscript, SV* linestr_sv, PerlIO *rsfp)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_4)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_VALIDATE_SUID \
-       assert(validarg); assert(linestr_sv); assert(rsfp)
-
-#  else
-STATIC void    S_validate_suid(pTHX_ const char *validarg, const char *scriptname, int fdscript, SV* linestr_sv, PerlIO *rsfp)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_4)
-                       __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_VALIDATE_SUID \
-       assert(validarg); assert(scriptname); assert(linestr_sv); assert(rsfp)
-
-#  endif
-#else
-#  ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
+#ifndef SETUID_SCRIPTS_ARE_SECURE_NOW
 STATIC void    S_validate_suid(pTHX_ PerlIO *rsfp)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_VALIDATE_SUID \
        assert(rsfp)
 
-#  endif
 #endif
 
-#  if defined(IAMSUID)
-STATIC int     S_fd_on_nosuid_fs(pTHX_ int fd);
-#  endif
 STATIC void*   S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
 STATIC void    S_run_body(pTHX_ I32 oldscope)
                        __attribute__noreturn__;
 
-STATIC SV *    S_incpush_if_exists(pTHX_ SV *dir)
-                       __attribute__nonnull__(pTHX_1);
+STATIC SV *    S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
 #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS     \
-       assert(dir)
+       assert(av); assert(dir); assert(stem)
 
 #endif
 
 #if defined(PERL_IN_PP_C) || defined(PERL_DECL_PROT)
+STATIC OP*     S_do_delete_local(pTHX);
 STATIC SV*     S_refto(pTHX_ SV* sv)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -5194,7 +5221,7 @@ STATIC regnode*   S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U
 #define PERL_ARGS_ASSERT_REGPIECE      \
        assert(pRExC_state); assert(flagp)
 
-STATIC regnode*        S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep)
+STATIC regnode*        S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REG_NAMEDSEQ  \
        assert(pRExC_state)
@@ -5445,11 +5472,6 @@ STATIC char*     S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, cons
 #define PERL_ARGS_ASSERT_FIND_BYCLASS  \
        assert(prog); assert(c); assert(s); assert(strend)
 
-STATIC void    S_swap_match_buff(pTHX_ regexp * prog)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SWAP_MATCH_BUFF       \
-       assert(prog)
-
 STATIC void    S_to_utf8_substr(pTHX_ regexp * prog)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR        \
@@ -5761,6 +5783,18 @@ STATIC char*     S_swallow_bom(pTHX_ U8 *s)
 #define PERL_ARGS_ASSERT_SWALLOW_BOM   \
        assert(s)
 
+#ifndef PERL_NO_UTF16_FILTER
+STATIC I32     S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_UTF16_TEXTFILTER      \
+       assert(sv)
+
+STATIC U8*     S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER  \
+       assert(s)
+
+#endif
 STATIC void    S_checkcomma(pTHX_ const char *s, const char *name, const char *what)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -5815,12 +5849,11 @@ STATIC I32      S_sublex_push(pTHX)
 STATIC I32     S_sublex_start(pTHX)
                        __attribute__warn_unused_result__;
 
-STATIC char *  S_filter_gets(pTHX_ SV *sv, PerlIO *fp, STRLEN append)
+STATIC char *  S_filter_gets(pTHX_ SV *sv, STRLEN append)
                        __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_FILTER_GETS   \
-       assert(sv); assert(fp)
+       assert(sv)
 
 STATIC HV *    S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len)
                        __attribute__warn_unused_result__
@@ -5840,6 +5873,7 @@ STATIC SV*        S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRL
 #define PERL_ARGS_ASSERT_NEW_CONSTANT  \
        assert(key); assert(sv)
 
+STATIC int     S_deprecate_commaless_var_list(pTHX);
 STATIC int     S_ao(pTHX_ int toketype);
 #  if defined(PERL_CR_FILTER)
 STATIC I32     S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
@@ -5871,6 +5905,11 @@ STATIC bool      S_isa_lookup(pTHX_ HV *stash, const char * const name)
 #define PERL_ARGS_ASSERT_ISA_LOOKUP    \
        assert(stash); assert(name)
 
+STATIC HV *    S_get_isa_hash(pTHX_ HV *const stash)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_ISA_HASH  \
+       assert(stash)
+
 #endif
 
 #if defined(PERL_IN_LOCALE_C) || defined(PERL_DECL_PROT)
@@ -5890,12 +5929,12 @@ STATIC const COP*       S_closest_cop(pTHX_ const COP *cop, const OP *o)
        assert(cop)
 
 STATIC SV*     S_mess_alloc(pTHX);
-STATIC const char *    S_vdie_croak_common(pTHX_ const char *pat, va_list *args, STRLEN *msglen, I32* utf8);
-STATIC bool    S_vdie_common(pTHX_ const char *message, STRLEN msglen, I32 utf8, bool warn);
+STATIC SV *    S_vdie_croak_common(pTHX_ const char *pat, va_list *args);
+STATIC bool    S_vdie_common(pTHX_ SV *message, bool warn);
 STATIC char *  S_write_no_mem(pTHX)
                        __attribute__noreturn__;
 
-#if defined(PERL_MEM_LOG) && defined(PERL_MEM_LOG_STDERR)
+#if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
 STATIC void    S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
                        __attribute__nonnull__(4)
                        __attribute__nonnull__(8)
@@ -5953,8 +5992,6 @@ PERL_CALLCONV void        Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const
 
 /* PERL_CALLCONV STRLEN        Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags)
                        __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS \
-       assert(sv)
 
 PERL_CALLCONV STRLEN   Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra)
                        __attribute__nonnull__(pTHX_1);
@@ -5982,10 +6019,9 @@ PERL_CALLCONV int        Perl_my_socketpair(int family, int type, int protocol, int fd[
 PERL_CALLCONV int      Perl_my_dirfd(pTHX_ DIR* dir);
 #ifdef PERL_OLD_COPY_ON_WRITE
 PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
-                       __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_SV_SETSV_COW  \
-       assert(dstr); assert(sstr)
+       assert(sstr)
 
 #endif
 
@@ -6349,11 +6385,10 @@ PERL_CALLCONV void      Perl_dump_sv_child(pTHX_ SV *sv)
 #endif
 
 #ifdef PERL_DONT_CREATE_GVSV
-PERL_CALLCONV GV*      Perl_gv_SVadd(pTHX_ GV* gv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_SVADD      \
-       assert(gv)
-
+/* PERL_CALLCONV GV*   Perl_gv_SVadd(pTHX_ GV *gv); */
+#endif
+#if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT)
+STATIC bool    S_ckwarn_common(pTHX_ U32 w);
 #endif
 PERL_CALLCONV bool     Perl_ckwarn(pTHX_ U32 w);
 PERL_CALLCONV bool     Perl_ckwarn_d(pTHX_ U32 w);
@@ -6454,16 +6489,27 @@ PERL_CALLCONV void      Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const cha
        assert(file); assert(pat)
 
 PERL_CALLCONV void     Perl_xmldump_all(pTHX);
+PERL_CALLCONV void     Perl_xmldump_all_perl(pTHX_ bool justperl);
 PERL_CALLCONV void     Perl_xmldump_packsubs(pTHX_ const HV* stash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS      \
        assert(stash)
 
+PERL_CALLCONV void     Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \
+       assert(stash)
+
 PERL_CALLCONV void     Perl_xmldump_sub(pTHX_ const GV* gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_XMLDUMP_SUB   \
        assert(gv)
 
+PERL_CALLCONV void     Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL      \
+       assert(gv)
+
 PERL_CALLCONV void     Perl_xmldump_form(pTHX_ const GV* gv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_XMLDUMP_FORM  \
@@ -6525,7 +6571,7 @@ PERL_CALLCONV MADPROP*    Perl_newMADsv(pTHX_ char key, SV* sv)
 #define PERL_ARGS_ASSERT_NEWMADSV      \
        assert(sv)
 
-PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, const void* val, I32 vlen);
+PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen);
 PERL_CALLCONV void     Perl_mad_free(pTHX_ MADPROP* mp);
 
 #  if defined(PERL_IN_TOKE_C) || defined(PERL_DECL_PROT)
@@ -6649,10 +6695,12 @@ PERL_CALLCONV struct refcounted_he *    Perl_store_cop_label(pTHX_ struct refcounte
 #define PERL_ARGS_ASSERT_STORE_COP_LABEL       \
        assert(label)
 
-PERL_CALLCONV HV *     Perl_get_isa_hash(pTHX_ HV *const stash)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_ISA_HASH  \
-       assert(stash)
+
+PERL_CALLCONV int      Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD       \
+       assert(keyword_ptr); assert(op_ptr)
 
 
 END_EXTERN_C
Unnamed repository; edit this file 'description' to name the repository.