Update AUTHORS and Porting/checkAUTHORS.pl with new names and aliases

[perl5.git] / proto.h

diff --git a/proto.h b/proto.h
index 983f953..01be297 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -516,23 +516,15 @@ 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_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 void     Perl_die_where(pTHX_ SV* msv)
+                       __attribute__noreturn__;
+
 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)
@@ -951,6 +943,11 @@ PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32
 #define PERL_ARGS_ASSERT_GV_NAME_SET   \
        assert(gv); assert(name)
 
+PERL_CALLCONV void     Perl_gv_try_downgrade(pTHX_ GV* gv)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE      \
+       assert(gv)
+
 PERL_CALLCONV HV*      Perl_gv_stashpv(pTHX_ const char* name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_GV_STASHPV    \
@@ -1345,6 +1342,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);
@@ -1357,6 +1366,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);
@@ -1399,6 +1414,66 @@ PERL_CALLCONV bool       Perl_is_utf8_mark(pTHX_ const U8 *p)
 #define PERL_ARGS_ASSERT_IS_UTF8_MARK  \
        assert(p)
 
+PERL_CALLCONV bool     Perl_is_utf8_X_begin(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN       \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_extend(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND      \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_prepend(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND     \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL  \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_L(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_L   \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_LV(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_LV  \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_LVT(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V    \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_T(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_T   \
+       assert(p)
+
+PERL_CALLCONV bool     Perl_is_utf8_X_V(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_V   \
+       assert(p)
+
 PERL_CALLCONV OP*      Perl_jmaybe(pTHX_ OP *o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_JMAYBE        \
@@ -1410,9 +1485,52 @@ 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)
+
+STATIC OP*     S_is_inplace_av(pTHX_ OP* o, OP* oright)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_INPLACE_AV \
+       assert(o)
+
+#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);
+PERL_CALLCONV bool     Perl_lex_bufutf8(pTHX);
+PERL_CALLCONV char*    Perl_lex_grow_linestr(pTHX_ STRLEN len);
+PERL_CALLCONV void     Perl_lex_stuff_pvn(pTHX_ char* pv, STRLEN len, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_LEX_STUFF_PVN \
+       assert(pv)
+
+PERL_CALLCONV void     Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_LEX_STUFF_SV  \
+       assert(sv)
+
+PERL_CALLCONV void     Perl_lex_unstuff(pTHX_ char* ptr)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_LEX_UNSTUFF   \
+       assert(ptr)
+
+PERL_CALLCONV void     Perl_lex_read_to(pTHX_ char* ptr)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_LEX_READ_TO   \
+       assert(ptr)
+
+PERL_CALLCONV void     Perl_lex_discard_to(pTHX_ char* ptr)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_LEX_DISCARD_TO        \
+       assert(ptr)
+
+PERL_CALLCONV bool     Perl_lex_next_chunk(pTHX_ U32 flags);
+PERL_CALLCONV I32      Perl_lex_peek_unichar(pTHX_ U32 flags);
+PERL_CALLCONV I32      Perl_lex_read_unichar(pTHX_ U32 flags);
+PERL_CALLCONV void     Perl_lex_read_space(pTHX_ U32 flags);
 PERL_CALLCONV void     Perl_op_null(pTHX_ OP* o)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_OP_NULL       \
@@ -2265,6 +2383,11 @@ PERL_CALLCONV const char*        Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv
 #define PERL_ARGS_ASSERT_SCAN_VERSION  \
        assert(s); assert(rv)
 
+PERL_CALLCONV const char*      Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PRESCAN_VERSION       \
+       assert(s)
+
 PERL_CALLCONV SV*      Perl_new_version(pTHX_ SV *ver)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_NEW_VERSION   \
@@ -2335,12 +2458,12 @@ PERL_CALLCONV void      Perl_package_version(pTHX_ OP* v)
        assert(v)
 
 PERL_CALLCONV PADOFFSET        Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
-PERL_CALLCONV PADOFFSET        Perl_allocmy(pTHX_ const char *const name)
+PERL_CALLCONV PADOFFSET        Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_ALLOCMY       \
        assert(name)
 
-PERL_CALLCONV PADOFFSET        Perl_pad_findmy(pTHX_ const char* name)
+PERL_CALLCONV PADOFFSET        Perl_pad_findmy(pTHX_ const char* name, STRLEN len, U32 flags)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_FINDMY    \
@@ -2360,7 +2483,9 @@ PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o)
        assert(o)
 
 PERL_CALLCONV void     Perl_pad_leavemy(pTHX);
+#ifdef DEBUGGING
 PERL_CALLCONV SV*      Perl_pad_sv(pTHX_ PADOFFSET po);
+#endif
 PERL_CALLCONV void     Perl_pad_free(pTHX_ PADOFFSET po);
 #if defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT)
 STATIC void    S_pad_reset(pTHX);
@@ -2485,7 +2610,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)
@@ -2542,10 +2668,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);
@@ -3248,6 +3374,11 @@ PERL_CALLCONV void       Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *
 #define PERL_ARGS_ASSERT_SV_POS_U2B    \
        assert(offsetp)
 
+PERL_CALLCONV STRLEN   Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS      \
+       assert(sv)
+
 PERL_CALLCONV void     Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_SV_POS_B2U    \
@@ -3700,6 +3831,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 +3858,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);
@@ -4247,7 +4390,7 @@ STATIC HV*        S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const
 
 #endif
 
-PERL_CALLCONV void*    Perl_get_arena(pTHX_ const size_t svtype, const U32 misc)
+PERL_CALLCONV void*    Perl_get_arena(pTHX_ const size_t arenasize, const svtype bodytype)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
@@ -5669,6 +5812,11 @@ STATIC char*     S_force_version(pTHX_ char *s, int guessing)
 #define PERL_ARGS_ASSERT_FORCE_VERSION \
        assert(s)
 
+STATIC char*   S_force_strict_version(pTHX_ char *s)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION  \
+       assert(s)
+
 STATIC char*   S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_tick)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_FORCE_WORD    \
@@ -5755,6 +5903,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)
@@ -5809,12 +5969,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__
@@ -5834,6 +5993,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);
@@ -5889,8 +6049,8 @@ 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__;
 
@@ -6054,7 +6214,7 @@ PERL_CALLCONV void        Perl_pad_undef(pTHX_ CV* cv)
 #define PERL_ARGS_ASSERT_PAD_UNDEF     \
        assert(cv)
 
-PERL_CALLCONV PADOFFSET        Perl_pad_add_name(pTHX_ const char *name, HV* typestash, HV* ourstash, bool clone, bool state)
+PERL_CALLCONV PADOFFSET        Perl_pad_add_name(pTHX_ const char *name, const STRLEN len, const U32 flags, HV *typestash, HV *ourstash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_ADD_NAME  \
        assert(name)
@@ -6064,12 +6224,13 @@ PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ SV* sv, OPCODE op_type)
 #define PERL_ARGS_ASSERT_PAD_ADD_ANON  \
        assert(sv)
 
-PERL_CALLCONV void     Perl_pad_check_dup(pTHX_ const char* name, bool is_our, const HV* ourstash)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_3);
+#if defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT)
+STATIC void    S_pad_check_dup(pTHX_ SV *name, const U32 flags, const HV *ourstash)
+                       __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \
-       assert(name); assert(ourstash)
+       assert(name)
 
+#endif
 #ifdef DEBUGGING
 PERL_CALLCONV void     Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
                        __attribute__nonnull__(pTHX_2);
@@ -6110,6 +6271,11 @@ STATIC PADOFFSET S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, in
 #define PERL_ARGS_ASSERT_PAD_FINDLEX   \
        assert(name); assert(cv); assert(out_name_sv); assert(out_flags)
 
+STATIC PADOFFSET       S_pad_add_name_sv(pTHX_ SV *namesv, const U32 flags, HV *typestash, HV *ourstash)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV       \
+       assert(namesv)
+
 #  if defined(DEBUGGING)
 STATIC void    S_cv_dump(pTHX_ const CV *cv, const char *title)
                        __attribute__nonnull__(pTHX_1)
@@ -6136,11 +6302,13 @@ PERL_CALLCONV void      Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val)
 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS      \
        assert(sv)
 
+#ifdef DEBUGGING
 PERL_CALLCONV void     Perl_hv_assert(pTHX_ HV *hv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_HV_ASSERT     \
        assert(hv)
 
+#endif
 
 PERL_CALLCONV SV*      Perl_hv_scalar(pTHX_ HV *hv)
                        __attribute__warn_unused_result__
@@ -6347,6 +6515,9 @@ PERL_CALLCONV void        Perl_dump_sv_child(pTHX_ SV *sv)
 #ifdef PERL_DONT_CREATE_GVSV
 /* 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);
 PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits, STRLEN size)
@@ -6653,6 +6824,13 @@ PERL_CALLCONV struct refcounted_he *     Perl_store_cop_label(pTHX_ struct refcounte
        assert(label)
 
 
+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
 /*
  * ex: set ts=8 sts=4 sw=4 noet: