This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regcomp.c: Put two static functions in embed.fnc
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 8cc3281..5436f59 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -1,16 +1,16 @@
-/*  -*- buffer-read-only: t -*-
+/* -*- buffer-read-only: t -*-
  *
  *    proto.h
  *
- *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- *    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, by Larry Wall and others
+ *    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 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.
  *
  * !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
  * This file is built by regen/embed.pl from data in embed.fnc,
- * regen/embed.pl, pp.sym, intrpvar.h, and perlvars.h.
+ * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h.
  * Any changes made here will be lost!
  *
  * Edit those files and run 'make regen_headers' to effect changes.
@@ -23,6 +23,26 @@ 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_ HV* const invlist, const UV start, const UV end)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST      \
+       assert(invlist)
+
+PERL_CALLCONV HV*      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 HV*      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 PADOFFSET        Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_ALLOCMY       \
@@ -34,6 +54,11 @@ 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 SV *     Perl_amagic_deref_call(pTHX_ SV *ref, int method)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL     \
+       assert(ref)
+
 PERL_CALLCONV I32      Perl_apply(pTHX_ I32 type, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -176,6 +201,12 @@ PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk)
 PERL_CALLCONV void     Perl_boot_core_PerlIO(pTHX);
 PERL_CALLCONV void     Perl_boot_core_UNIVERSAL(pTHX);
 PERL_CALLCONV void     Perl_boot_core_mro(pTHX);
+PERL_CALLCONV int      Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_BYTES_CMP_UTF8        \
+       assert(b); assert(u)
+
 PERL_CALLCONV U8*      Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -238,6 +269,11 @@ PERL_CALLCONV U32  Perl_cast_ulong(pTHX_ NV f)
 PERL_CALLCONV UV       Perl_cast_uv(pTHX_ NV f)
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV bool     Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT      \
+       assert(s)
+
 PERL_CALLCONV OP *     Perl_ck_anoncode(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -407,6 +443,12 @@ PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o)
 #define PERL_ARGS_ASSERT_CK_OPEN       \
        assert(o)
 
+PERL_CALLCONV OP *     Perl_ck_push(pTHX_ OP *o)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_PUSH       \
+       assert(o)
+
 PERL_CALLCONV OP *     Perl_ck_readline(pTHX_ OP *o)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -565,6 +607,18 @@ PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o)
 #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME        \
        assert(o)
 
+PERL_CALLCONV void     Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER    \
+       assert(ppaddr); assert(xop)
+
+PERL_CALLCONV const XOP *      Perl_custom_op_xop(pTHX_ const OP *o)
+                       __attribute__pure__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CUSTOM_OP_XOP \
+       assert(o)
+
 PERL_CALLCONV void     Perl_cv_ckproto_len(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN        \
@@ -672,17 +726,6 @@ PERL_CALLCONV int  Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
 #define PERL_ARGS_ASSERT_DO_BINMODE    \
        assert(fp)
 
-PERL_CALLCONV I32      Perl_do_chomp(pTHX_ SV* sv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DO_CHOMP      \
-       assert(sv)
-
-PERL_CALLCONV void     Perl_do_chop(pTHX_ SV *astr, SV *sv)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_DO_CHOP       \
-       assert(astr); assert(sv)
-
 PERL_CALLCONV bool     Perl_do_close(pTHX_ GV* gv, bool not_implicit);
 PERL_CALLCONV void     Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
                        __attribute__nonnull__(pTHX_2);
@@ -721,7 +764,6 @@ PERL_CALLCONV void  Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp)
 #define PERL_ARGS_ASSERT_DO_JOIN       \
        assert(sv); assert(delim); assert(mark); assert(sp)
 
-PERL_CALLCONV OP*      Perl_do_kv(pTHX);
 PERL_CALLCONV void     Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -897,6 +939,11 @@ PERL_CALLCONV char*        Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bige
 #define PERL_ARGS_ASSERT_FBM_INSTR     \
        assert(big); assert(bigend); assert(littlestr)
 
+PERL_CALLCONV bool     Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen)
+                       __attribute__nonnull__(pTHX_1);
+#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       \
@@ -933,6 +980,13 @@ PERL_CALLCONV I32  Perl_foldEQ(const char* a, const char* b, I32 len)
 #define PERL_ARGS_ASSERT_FOLDEQ        \
        assert(a); assert(b)
 
+PERL_CALLCONV I32      Perl_foldEQ_latin1(const char* a, const char* b, I32 len)
+                       __attribute__pure__
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \
+       assert(a); assert(b)
+
 PERL_CALLCONV I32      Perl_foldEQ_locale(const char* a, const char* b, I32 len)
                        __attribute__pure__
                        __attribute__nonnull__(1)
@@ -1028,18 +1082,6 @@ PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flag
 #define PERL_ARGS_ASSERT_GROK_BIN      \
        assert(start); assert(len_p); assert(flags)
 
-PERL_CALLCONV char     Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning)
-                       __attribute__warn_unused_result__;
-
-PERL_CALLCONV bool     Perl_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
-                       __attribute__warn_unused_result__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
-       assert(s); assert(uv); assert(len); assert(error_msg)
-
 PERL_CALLCONV UV       Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -1262,13 +1304,13 @@ PERL_CALLCONV void      Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter)
 #define PERL_ARGS_ASSERT_HV_EITER_SET  \
        assert(hv)
 
-PERL_CALLCONV void     Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len)
+PERL_CALLCONV void     Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_HV_ENAME_ADD  \
        assert(hv); assert(name)
 
-PERL_CALLCONV void     Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len)
+PERL_CALLCONV void     Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE       \
@@ -1403,7 +1445,8 @@ PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv)
 /* PERL_CALLCONV SV**  Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */
 /* 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 void  hv_undef(pTHX_ HV *hv); */
+PERL_CALLCONV void     Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags);
 /* PERL_CALLCONV I32   ibcmp(pTHX_ const char* a, const char* b, I32 len)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2); */
@@ -2165,6 +2208,9 @@ PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
 PERL_CALLCONV MAGIC*   Perl_mg_find(pTHX_ const SV* sv, int type)
                        __attribute__warn_unused_result__;
 
+PERL_CALLCONV MAGIC*   Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV int      Perl_mg_free(pTHX_ SV* sv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_MG_FREE       \
@@ -2211,6 +2257,7 @@ 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)
@@ -2234,10 +2281,11 @@ PERL_CALLCONV SV*       Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta,
 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA  \
        assert(smeta); assert(which)
 
-/* PERL_CALLCONV void  mro_isa_changed_in(pTHX_ HV* stash)
-                       __attribute__nonnull__(pTHX_1); */
+PERL_CALLCONV void     Perl_mro_isa_changed_in(pTHX_ HV* stash)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN    \
+       assert(stash)
 
-PERL_CALLCONV void     Perl_mro_isa_changed_in3(pTHX_ HV* stash, const char *stashname, STRLEN stashname_len);
 PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_MRO_META_INIT \
@@ -2248,7 +2296,11 @@ PERL_CALLCONV void       Perl_mro_method_changed_in(pTHX_ HV* stash)
 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \
        assert(stash)
 
-PERL_CALLCONV void     Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV *gv, const char *newname, I32 newname_len);
+PERL_CALLCONV void     Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED     \
+       assert(gv)
+
 PERL_CALLCONV void     Perl_mro_register(pTHX_ const struct mro_alg *mro)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_MRO_REGISTER  \
@@ -2512,7 +2564,7 @@ PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
-PERL_CALLCONV CV*      Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
+/* PERL_CALLCONV CV*   Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */
 PERL_CALLCONV SV*      Perl_newSV(pTHX_ const STRLEN len)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -2766,16 +2818,15 @@ PERL_CALLCONV void      Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
 
 PERL_CALLCONV void     Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust);
 PERL_CALLCONV void     Perl_pad_tidy(pTHX_ padtidy_type type);
-PERL_CALLCONV void     Perl_pad_undef(pTHX_ CV* cv)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PAD_UNDEF     \
-       assert(cv)
-
+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);
+PERL_CALLCONV OP*      Perl_parse_fullexpr(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_fullstmt(pTHX_ U32 flags);
 PERL_CALLCONV SV*      Perl_parse_label(pTHX_ U32 flags);
+PERL_CALLCONV OP*      Perl_parse_listexpr(pTHX_ U32 flags);
 PERL_CALLCONV OP*      Perl_parse_stmtseq(pTHX_ U32 flags);
+PERL_CALLCONV OP*      Perl_parse_termexpr(pTHX_ U32 flags);
 PERL_CALLCONV U32      Perl_parse_unicode_opts(pTHX_ const char **popt)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS    \
@@ -2826,367 +2877,6 @@ PERL_CALLCONV void      Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...)
 #define PERL_ARGS_ASSERT_POPULATE_ISA  \
        assert(name)
 
-PERL_CALLCONV OP *     Perl_pp_aassign(pTHX);
-PERL_CALLCONV OP *     Perl_pp_abs(pTHX);
-PERL_CALLCONV OP *     Perl_pp_accept(pTHX);
-PERL_CALLCONV OP *     Perl_pp_add(pTHX);
-PERL_CALLCONV OP *     Perl_pp_aeach(pTHX);
-PERL_CALLCONV OP *     Perl_pp_aelem(pTHX);
-PERL_CALLCONV OP *     Perl_pp_aelemfast(pTHX);
-PERL_CALLCONV OP *     Perl_pp_akeys(pTHX);
-PERL_CALLCONV OP *     Perl_pp_alarm(pTHX);
-PERL_CALLCONV OP *     Perl_pp_and(pTHX);
-PERL_CALLCONV OP *     Perl_pp_andassign(pTHX);
-PERL_CALLCONV OP *     Perl_pp_anoncode(pTHX);
-PERL_CALLCONV OP *     Perl_pp_anonhash(pTHX);
-PERL_CALLCONV OP *     Perl_pp_anonlist(pTHX);
-PERL_CALLCONV OP *     Perl_pp_aslice(pTHX);
-PERL_CALLCONV OP *     Perl_pp_atan2(pTHX);
-PERL_CALLCONV OP *     Perl_pp_av2arylen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_avalues(pTHX);
-PERL_CALLCONV OP *     Perl_pp_backtick(pTHX);
-PERL_CALLCONV OP *     Perl_pp_bind(pTHX);
-PERL_CALLCONV OP *     Perl_pp_binmode(pTHX);
-PERL_CALLCONV OP *     Perl_pp_bit_and(pTHX);
-PERL_CALLCONV OP *     Perl_pp_bit_or(pTHX);
-PERL_CALLCONV OP *     Perl_pp_bit_xor(pTHX);
-PERL_CALLCONV OP *     Perl_pp_bless(pTHX);
-PERL_CALLCONV OP *     Perl_pp_boolkeys(pTHX);
-PERL_CALLCONV OP *     Perl_pp_break(pTHX);
-PERL_CALLCONV OP *     Perl_pp_caller(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chmod(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chomp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chown(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_chroot(pTHX);
-PERL_CALLCONV OP *     Perl_pp_close(pTHX);
-PERL_CALLCONV OP *     Perl_pp_closedir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_complement(pTHX);
-PERL_CALLCONV OP *     Perl_pp_concat(pTHX);
-PERL_CALLCONV OP *     Perl_pp_cond_expr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_connect(pTHX);
-PERL_CALLCONV OP *     Perl_pp_const(pTHX);
-PERL_CALLCONV OP *     Perl_pp_continue(pTHX);
-PERL_CALLCONV OP *     Perl_pp_cos(pTHX);
-PERL_CALLCONV OP *     Perl_pp_crypt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dbmclose(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dbmopen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dbstate(pTHX);
-PERL_CALLCONV OP *     Perl_pp_defined(pTHX);
-PERL_CALLCONV OP *     Perl_pp_delete(pTHX);
-PERL_CALLCONV OP *     Perl_pp_die(pTHX);
-PERL_CALLCONV OP *     Perl_pp_divide(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dofile(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dor(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dorassign(pTHX);
-PERL_CALLCONV OP *     Perl_pp_dump(pTHX);
-PERL_CALLCONV OP *     Perl_pp_each(pTHX);
-PERL_CALLCONV OP *     Perl_pp_egrent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ehostent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enetent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enter(pTHX);
-PERL_CALLCONV OP *     Perl_pp_entereval(pTHX);
-PERL_CALLCONV OP *     Perl_pp_entergiven(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enteriter(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enterloop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_entersub(pTHX);
-PERL_CALLCONV OP *     Perl_pp_entertry(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enterwhen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_enterwrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_eof(pTHX);
-PERL_CALLCONV OP *     Perl_pp_eprotoent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_epwent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_eq(pTHX);
-PERL_CALLCONV OP *     Perl_pp_eservent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_exec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_exists(pTHX);
-PERL_CALLCONV OP *     Perl_pp_exit(pTHX);
-PERL_CALLCONV OP *     Perl_pp_exp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fcntl(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fileno(pTHX);
-PERL_CALLCONV OP *     Perl_pp_flip(pTHX);
-PERL_CALLCONV OP *     Perl_pp_flock(pTHX);
-PERL_CALLCONV OP *     Perl_pp_flop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fork(pTHX);
-PERL_CALLCONV OP *     Perl_pp_formline(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftatime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftbinary(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftblk(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftchr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftctime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fteexec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fteowned(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fteread(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftewrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftfile(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftis(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftlink(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftmtime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftpipe(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftrexec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftrowned(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftrread(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftrwrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftsgid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftsize(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftsock(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftsuid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftsvtx(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fttext(pTHX);
-PERL_CALLCONV OP *     Perl_pp_fttty(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ftzero(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ge(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gelem(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getc(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getlogin(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getpeername(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getpgrp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getppid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getpriority(pTHX);
-PERL_CALLCONV OP *     Perl_pp_getsockname(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ggrent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ggrgid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ggrnam(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ghbyaddr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ghbyname(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ghostent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_glob(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gmtime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gnbyaddr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gnbyname(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gnetent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_goto(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gpbyname(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gpbynumber(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gprotoent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gpwent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gpwnam(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gpwuid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_grepstart(pTHX);
-PERL_CALLCONV OP *     Perl_pp_grepwhile(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gsbyname(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gsbyport(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gservent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gsockopt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_gvsv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_helem(pTHX);
-PERL_CALLCONV OP *     Perl_pp_hex(pTHX);
-PERL_CALLCONV OP *     Perl_pp_hintseval(pTHX);
-PERL_CALLCONV OP *     Perl_pp_hslice(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_add(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_divide(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_eq(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_ge(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_gt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_le(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_lt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_modulo(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_multiply(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_ncmp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_ne(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_negate(pTHX);
-PERL_CALLCONV OP *     Perl_pp_i_subtract(pTHX);
-PERL_CALLCONV OP *     Perl_pp_index(pTHX);
-PERL_CALLCONV OP *     Perl_pp_int(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ioctl(pTHX);
-PERL_CALLCONV OP *     Perl_pp_iter(pTHX);
-PERL_CALLCONV OP *     Perl_pp_join(pTHX);
-PERL_CALLCONV OP *     Perl_pp_keys(pTHX);
-PERL_CALLCONV OP *     Perl_pp_kill(pTHX);
-PERL_CALLCONV OP *     Perl_pp_last(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lc(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lcfirst(pTHX);
-PERL_CALLCONV OP *     Perl_pp_le(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leave(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leaveeval(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavegiven(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leaveloop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavesub(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavesublv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavetry(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavewhen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_leavewrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_left_shift(pTHX);
-PERL_CALLCONV OP *     Perl_pp_length(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lineseq(pTHX);
-PERL_CALLCONV OP *     Perl_pp_link(pTHX);
-PERL_CALLCONV OP *     Perl_pp_list(pTHX);
-PERL_CALLCONV OP *     Perl_pp_listen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_localtime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lock(pTHX);
-PERL_CALLCONV OP *     Perl_pp_log(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lslice(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lstat(pTHX);
-PERL_CALLCONV OP *     Perl_pp_lt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_mapstart(pTHX);
-PERL_CALLCONV OP *     Perl_pp_mapwhile(pTHX);
-PERL_CALLCONV OP *     Perl_pp_match(pTHX);
-PERL_CALLCONV OP *     Perl_pp_method(pTHX);
-PERL_CALLCONV OP *     Perl_pp_method_named(pTHX);
-PERL_CALLCONV OP *     Perl_pp_mkdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_modulo(pTHX);
-PERL_CALLCONV OP *     Perl_pp_msgctl(pTHX);
-PERL_CALLCONV OP *     Perl_pp_msgget(pTHX);
-PERL_CALLCONV OP *     Perl_pp_msgrcv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_msgsnd(pTHX);
-PERL_CALLCONV OP *     Perl_pp_multiply(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ncmp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ne(pTHX);
-PERL_CALLCONV OP *     Perl_pp_negate(pTHX);
-PERL_CALLCONV OP *     Perl_pp_next(pTHX);
-PERL_CALLCONV OP *     Perl_pp_nextstate(pTHX);
-PERL_CALLCONV OP *     Perl_pp_not(pTHX);
-PERL_CALLCONV OP *     Perl_pp_null(pTHX);
-PERL_CALLCONV OP *     Perl_pp_oct(pTHX);
-PERL_CALLCONV OP *     Perl_pp_once(pTHX);
-PERL_CALLCONV OP *     Perl_pp_open(pTHX);
-PERL_CALLCONV OP *     Perl_pp_open_dir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_or(pTHX);
-PERL_CALLCONV OP *     Perl_pp_orassign(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ord(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pack(pTHX);
-PERL_CALLCONV OP *     Perl_pp_padany(pTHX);
-PERL_CALLCONV OP *     Perl_pp_padav(pTHX);
-PERL_CALLCONV OP *     Perl_pp_padhv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_padsv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pipe_op(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pos(pTHX);
-PERL_CALLCONV OP *     Perl_pp_postdec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_postinc(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pow(pTHX);
-PERL_CALLCONV OP *     Perl_pp_predec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_preinc(pTHX);
-PERL_CALLCONV OP *     Perl_pp_print(pTHX);
-PERL_CALLCONV OP *     Perl_pp_prototype(pTHX);
-PERL_CALLCONV OP *     Perl_pp_prtf(pTHX);
-PERL_CALLCONV OP *     Perl_pp_push(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pushmark(pTHX);
-PERL_CALLCONV OP *     Perl_pp_pushre(pTHX);
-PERL_CALLCONV OP *     Perl_pp_qr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_quotemeta(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rand(pTHX);
-PERL_CALLCONV OP *     Perl_pp_range(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rcatline(pTHX);
-PERL_CALLCONV OP *     Perl_pp_read(pTHX);
-PERL_CALLCONV OP *     Perl_pp_readdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_readline(pTHX);
-PERL_CALLCONV OP *     Perl_pp_readlink(pTHX);
-PERL_CALLCONV OP *     Perl_pp_recv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_redo(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ref(pTHX);
-PERL_CALLCONV OP *     Perl_pp_refgen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_regcmaybe(pTHX);
-PERL_CALLCONV OP *     Perl_pp_regcomp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_regcreset(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rename(pTHX);
-PERL_CALLCONV OP *     Perl_pp_repeat(pTHX);
-PERL_CALLCONV OP *     Perl_pp_require(pTHX);
-PERL_CALLCONV OP *     Perl_pp_reset(pTHX);
-PERL_CALLCONV OP *     Perl_pp_return(pTHX);
-PERL_CALLCONV OP *     Perl_pp_reverse(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rewinddir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_right_shift(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rindex(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rmdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rv2av(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rv2cv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rv2gv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rv2hv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_rv2sv(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sassign(pTHX);
-PERL_CALLCONV OP *     Perl_pp_say(pTHX);
-PERL_CALLCONV OP *     Perl_pp_scalar(pTHX);
-PERL_CALLCONV OP *     Perl_pp_schomp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_schop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_scmp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_scope(pTHX);
-PERL_CALLCONV OP *     Perl_pp_seek(pTHX);
-PERL_CALLCONV OP *     Perl_pp_seekdir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_select(pTHX);
-PERL_CALLCONV OP *     Perl_pp_semctl(pTHX);
-PERL_CALLCONV OP *     Perl_pp_semget(pTHX);
-PERL_CALLCONV OP *     Perl_pp_semop(pTHX);
-PERL_CALLCONV OP *     Perl_pp_send(pTHX);
-PERL_CALLCONV OP *     Perl_pp_seq(pTHX);
-PERL_CALLCONV OP *     Perl_pp_setpgrp(pTHX);
-PERL_CALLCONV OP *     Perl_pp_setpriority(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sge(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sgrent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sgt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shift(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shmctl(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shmget(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shmread(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shmwrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shostent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_shutdown(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sin(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sle(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sleep(pTHX);
-PERL_CALLCONV OP *     Perl_pp_slt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_smartmatch(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sne(pTHX);
-PERL_CALLCONV OP *     Perl_pp_snetent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_socket(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sockpair(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sort(pTHX);
-PERL_CALLCONV OP *     Perl_pp_splice(pTHX);
-PERL_CALLCONV OP *     Perl_pp_split(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sprintf(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sprotoent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_spwent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sqrt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_srand(pTHX);
-PERL_CALLCONV OP *     Perl_pp_srefgen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sselect(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sservent(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ssockopt(pTHX);
-PERL_CALLCONV OP *     Perl_pp_stat(pTHX);
-PERL_CALLCONV OP *     Perl_pp_stringify(pTHX);
-PERL_CALLCONV OP *     Perl_pp_stub(pTHX);
-PERL_CALLCONV OP *     Perl_pp_study(pTHX);
-PERL_CALLCONV OP *     Perl_pp_subst(pTHX);
-PERL_CALLCONV OP *     Perl_pp_substcont(pTHX);
-PERL_CALLCONV OP *     Perl_pp_substr(pTHX);
-PERL_CALLCONV OP *     Perl_pp_subtract(pTHX);
-PERL_CALLCONV OP *     Perl_pp_symlink(pTHX);
-PERL_CALLCONV OP *     Perl_pp_syscall(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sysopen(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sysread(pTHX);
-PERL_CALLCONV OP *     Perl_pp_sysseek(pTHX);
-PERL_CALLCONV OP *     Perl_pp_system(pTHX);
-PERL_CALLCONV OP *     Perl_pp_syswrite(pTHX);
-PERL_CALLCONV OP *     Perl_pp_tell(pTHX);
-PERL_CALLCONV OP *     Perl_pp_telldir(pTHX);
-PERL_CALLCONV OP *     Perl_pp_tie(pTHX);
-PERL_CALLCONV OP *     Perl_pp_tied(pTHX);
-PERL_CALLCONV OP *     Perl_pp_time(pTHX);
-PERL_CALLCONV OP *     Perl_pp_tms(pTHX);
-PERL_CALLCONV OP *     Perl_pp_trans(pTHX);
-PERL_CALLCONV OP *     Perl_pp_truncate(pTHX);
-PERL_CALLCONV OP *     Perl_pp_uc(pTHX);
-PERL_CALLCONV OP *     Perl_pp_ucfirst(pTHX);
-PERL_CALLCONV OP *     Perl_pp_umask(pTHX);
-PERL_CALLCONV OP *     Perl_pp_undef(pTHX);
-PERL_CALLCONV OP *     Perl_pp_unlink(pTHX);
-PERL_CALLCONV OP *     Perl_pp_unpack(pTHX);
-PERL_CALLCONV OP *     Perl_pp_unshift(pTHX);
-PERL_CALLCONV OP *     Perl_pp_unstack(pTHX);
-PERL_CALLCONV OP *     Perl_pp_untie(pTHX);
-PERL_CALLCONV OP *     Perl_pp_utime(pTHX);
-PERL_CALLCONV OP *     Perl_pp_values(pTHX);
-PERL_CALLCONV OP *     Perl_pp_vec(pTHX);
-PERL_CALLCONV OP *     Perl_pp_wait(pTHX);
-PERL_CALLCONV OP *     Perl_pp_waitpid(pTHX);
-PERL_CALLCONV OP *     Perl_pp_wantarray(pTHX);
-PERL_CALLCONV OP *     Perl_pp_warn(pTHX);
-PERL_CALLCONV OP *     Perl_pp_xor(pTHX);
 PERL_CALLCONV REGEXP*  Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_PREGCOMP      \
@@ -3435,8 +3125,9 @@ PERL_CALLCONV void        Perl_repeatcpy(char* to, const char* from, I32 len, I32 count
 #define PERL_ARGS_ASSERT_REPEATCPY     \
        assert(to); assert(from)
 
-PERL_CALLCONV void     Perl_report_evil_fh(pTHX_ const GV *gv, const IO *io, I32 op);
+PERL_CALLCONV void     Perl_report_evil_fh(pTHX_ const GV *gv);
 PERL_CALLCONV void     Perl_report_uninit(pTHX_ const SV *uninit_sv);
+PERL_CALLCONV void     Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have);
 PERL_CALLCONV void     Perl_require_pv(pTHX_ const char* pv)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REQUIRE_PV    \
@@ -3976,10 +3667,11 @@ PERL_CALLCONV void      Perl_sv_clear(pTHX_ SV *const orig_sv)
        assert(orig_sv)
 
 PERL_CALLCONV I32      Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2);
-PERL_CALLCONV I32      Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const I32 flags);
+PERL_CALLCONV I32      Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
 PERL_CALLCONV I32      Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
-PERL_CALLCONV I32      Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const I32 flags);
+PERL_CALLCONV I32      Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
 PERL_CALLCONV OP*      Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
+                       __attribute__deprecated__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3)
@@ -3987,6 +3679,14 @@ PERL_CALLCONV OP*        Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *co
 #define PERL_ARGS_ASSERT_SV_COMPILE_2OP        \
        assert(sv); assert(startop); assert(code); assert(padp)
 
+PERL_CALLCONV OP*      Perl_sv_compile_2op_is_broken(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_SV_COMPILE_2OP_IS_BROKEN      \
+       assert(sv); assert(startop); assert(code); assert(padp)
+
 PERL_CALLCONV void     Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -4022,7 +3722,7 @@ PERL_CALLCONV void        Perl_sv_dump(pTHX_ SV* sv)
        assert(sv)
 
 /* PERL_CALLCONV I32   sv_eq(pTHX_ SV* sv1, SV* sv2); */
-PERL_CALLCONV I32      Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const I32 flags);
+PERL_CALLCONV I32      Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags);
 /* PERL_CALLCONV void  Perl_sv_force_normal(pTHX_ SV *sv)
                        __attribute__nonnull__(pTHX_1); */
 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL       \
@@ -4349,6 +4049,11 @@ PERL_CALLCONV int        Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
 #define PERL_ARGS_ASSERT_SV_UNMAGIC    \
        assert(sv)
 
+PERL_CALLCONV int      Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_UNMAGICEXT \
+       assert(sv)
+
 /* PERL_CALLCONV void  Perl_sv_unref(pTHX_ SV* sv)
                        __attribute__nonnull__(pTHX_1); */
 #define PERL_ARGS_ASSERT_SV_UNREF      \
@@ -4489,6 +4194,14 @@ PERL_CALLCONV void       Perl_taint_proper(pTHX_ const char* f, const char *const s)
 #define PERL_ARGS_ASSERT_TAINT_PROPER  \
        assert(s)
 
+PERL_CALLCONV OP *     Perl_tied_method(pTHX_ const char *const methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_TIED_METHOD   \
+       assert(methname); assert(sp); assert(sv); assert(mg)
+
 PERL_CALLCONV void     Perl_tmps_grow(pTHX_ I32 n);
 PERL_CALLCONV UV       Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp)
                        __attribute__nonnull__(pTHX_2)
@@ -4939,7 +4652,7 @@ STATIC int        S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype)
 #endif
 #if !defined(PERL_DISABLE_PMC)
 #  if defined(PERL_IN_PP_CTL_C)
-STATIC PerlIO *        S_doopen_pm(pTHX_ const char *name, const STRLEN namelen)
+STATIC PerlIO *        S_doopen_pm(pTHX_ SV *name)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_DOOPEN_PM     \
@@ -5468,6 +5181,27 @@ STATIC I32       S_do_trans_simple_utf8(pTHX_ SV * const sv)
        assert(sv)
 
 #endif
+#if defined(PERL_IN_DQUOTE_STATIC_C)
+STATIC char    S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
+                       __attribute__warn_unused_result__;
+
+STATIC bool    S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
+       assert(s); assert(uv); assert(len); assert(error_msg)
+
+PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s)
+                       __attribute__warn_unused_result__
+                       __attribute__pure__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_REGCURLY      \
+       assert(s)
+
+#endif
 #if defined(PERL_IN_DUMP_C)
 STATIC CV*     S_deb_curcv(pTHX_ const I32 ix);
 STATIC void    S_debprof(pTHX_ const OP *o)
@@ -5635,13 +5369,22 @@ STATIC void     S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
 #define PERL_ARGS_ASSERT_SAVE_MAGIC    \
        assert(sv)
 
-STATIC void    S_unwind_handler_stack(pTHX_ const void *p)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK  \
-       assert(p)
-
+STATIC void    S_unwind_handler_stack(pTHX_ const void *p);
 #endif
 #if defined(PERL_IN_MRO_C)
+STATIC void    S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV      \
+       assert(isa); assert(name)
+
+STATIC void    S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \
+       assert(stashes); assert(seen_stashes); assert(namesv)
+
 STATIC AV*     S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS        \
@@ -5896,6 +5639,12 @@ STATIC void      S_usage(pTHX_ const char *name)
 
 #endif
 #if defined(PERL_IN_PP_C)
+STATIC void    S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_DO_CHOMP      \
+       assert(retval); assert(sv)
+
 STATIC OP*     S_do_delete_local(pTHX);
 STATIC SV*     S_refto(pTHX_ SV* sv)
                        __attribute__warn_unused_result__
@@ -5915,7 +5664,7 @@ PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co
 
 #endif
 #if defined(PERL_IN_PP_CTL_C)
-STATIC PerlIO *        S_check_type_and_open(pTHX_ const char *name)
+STATIC PerlIO *        S_check_type_and_open(pTHX_ SV *name)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN   \
@@ -6187,14 +5936,6 @@ STATIC SV *      S_space_join_names_mortal(pTHX_ char *const *array)
 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL       \
        assert(array)
 
-STATIC OP *    S_tied_handle_method(pTHX_ const char *const methname, SV **sp, IO *const io, MAGIC *const mg, const U32 flags, ...)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3)
-                       __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_TIED_HANDLE_METHOD    \
-       assert(methname); assert(sp); assert(io); assert(mg)
-
 #endif
 #if defined(PERL_IN_REGCOMP_C)
 STATIC U32     S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s)
@@ -6204,6 +5945,12 @@ STATIC U32       S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s)
 #define PERL_ARGS_ASSERT_ADD_DATA      \
        assert(pRExC_state); assert(s)
 
+STATIC HV*     S_add_range_to_invlist(pTHX_ HV* const invlist, const UV start, const UV end)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_ADD_RANGE_TO_INVLIST  \
+       assert(invlist)
+
 STATIC void    S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_CHECKPOSIXCC  \
@@ -6246,6 +5993,69 @@ STATIC void      S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charc
 #define PERL_ARGS_ASSERT_CL_OR \
        assert(pRExC_state); assert(cl); assert(or_with)
 
+PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ HV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
+       assert(invlist)
+
+PERL_STATIC_INLINE void        S_invlist_destroy(pTHX_ HV* const invlist)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_DESTROY       \
+       assert(invlist)
+
+STATIC void    S_invlist_extend(pTHX_ HV* const invlist, const UV len)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_EXTEND        \
+       assert(invlist)
+
+STATIC HV*     S_invlist_intersection(pTHX_ HV* const a, HV* const b)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_INVLIST_INTERSECTION  \
+       assert(a); assert(b)
+
+PERL_STATIC_INLINE UV  S_invlist_len(pTHX_ HV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_LEN   \
+       assert(invlist)
+
+PERL_STATIC_INLINE UV  S_invlist_max(pTHX_ HV* const invlist)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_MAX   \
+       assert(invlist)
+
+PERL_STATIC_INLINE void        S_invlist_set_array(pTHX_ HV* const invlist, const UV* const array)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_INVLIST_SET_ARRAY     \
+       assert(invlist); assert(array)
+
+PERL_STATIC_INLINE void        S_invlist_set_len(pTHX_ HV* const invlist, const UV len)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_SET_LEN       \
+       assert(invlist)
+
+PERL_STATIC_INLINE void        S_invlist_set_max(pTHX_ HV* const invlist, const UV max)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_SET_MAX       \
+       assert(invlist)
+
+PERL_STATIC_INLINE void        S_invlist_trim(pTHX_ HV* const invlist)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_TRIM  \
+       assert(invlist)
+
+STATIC HV*     S_invlist_union(pTHX_ HV* const a, HV* const b)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_INVLIST_UNION \
+       assert(a); assert(b)
+
 STATIC U32     S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, I32 *min, U32 flags, regnode *val, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -6378,6 +6188,20 @@ STATIC void      S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct s
 #define PERL_ARGS_ASSERT_SCAN_COMMIT   \
        assert(pRExC_state); assert(data); assert(minlenp)
 
+PERL_STATIC_INLINE U8  S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT      \
+       assert(pRExC_state); assert(node); assert(nonbitmap_ptr)
+
+STATIC U8      S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \
+       assert(pRExC_state); assert(node); assert(nonbitmap_ptr)
+
 STATIC I32     S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -6501,6 +6325,11 @@ STATIC void      S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN fr
 #define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT    \
        assert(func); assert(sv)
 
+STATIC bool    S_curse(pTHX_ SV * const sv, const bool check_refcnt)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CURSE \
+       assert(sv)
+
 STATIC I32     S_expect_number(pTHX_ char **const pattern)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6660,11 +6489,6 @@ STATIC void      S_checkcomma(pTHX_ const char *s, const char *name, const char *what
        assert(s); assert(name); assert(what)
 
 STATIC int     S_deprecate_commaless_var_list(pTHX);
-STATIC bool    S_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED    \
-       assert(name)
-
 STATIC char *  S_filter_gets(pTHX_ SV *sv, STRLEN append)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6854,11 +6678,6 @@ STATIC void      S_start_force(pTHX_ int where);
 #  endif
 #endif
 #if defined(PERL_IN_UNIVERSAL_C)
-STATIC HV *    S_get_isa_hash(pTHX_ HV *const stash)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_ISA_HASH  \
-       assert(stash)
-
 STATIC bool    S_isa_lookup(pTHX_ HV *stash, const char * const name)
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -7376,5 +7195,9 @@ PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd)
        assert(cmd)
 
 #endif
+#ifdef PERL_CORE
+#  include "pp_proto.h"
+#endif
 END_EXTERN_C
+
 /* ex: set ro: */