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
perldelta for 4ded55f35 (lexical constants)
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 01d1e12..7f4942e 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -32,10 +32,13 @@ PERL_CALLCONV void  Perl_Slab_Free(pTHX_ void *op)
 #define PERL_ARGS_ASSERT_SLAB_FREE     \
        assert(op)
 
-PERL_CALLCONV bool     Perl__is_utf8__perl_idstart(pTHX_ const U8 *p)
+PERL_CALLCONV bool     Perl__is_uni_perl_idstart(pTHX_ UV c)
+                       __attribute__warn_unused_result__;
+
+PERL_CALLCONV bool     Perl__is_utf8_perl_idstart(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__IS_UTF8__PERL_IDSTART        \
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
        assert(p)
 
 PERL_CALLCONV UV       Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const U8 flags)
@@ -640,7 +643,13 @@ PERL_CALLCONV_NO_RET void  Perl_croak(pTHX_ const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
 
-PERL_CALLCONV_NO_RET void      Perl_croak_no_modify(pTHX)
+PERL_STATIC_NO_RET void        S_croak_memory_wrap(void)
+                       __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void      Perl_croak_no_mem(void)
+                       __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void      Perl_croak_no_modify(void)
                        __attribute__noreturn__;
 
 PERL_CALLCONV_NO_RET void      Perl_croak_sv(pTHX_ SV *baseex)
@@ -649,10 +658,10 @@ PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex)
 #define PERL_ARGS_ASSERT_CROAK_SV      \
        assert(baseex)
 
-PERL_CALLCONV_NO_RET void      Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params)
+PERL_CALLCONV_NO_RET void      Perl_croak_xs_usage(const CV *const cv, const char *const params)
                        __attribute__noreturn__
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
+                       __attribute__nonnull__(1)
+                       __attribute__nonnull__(2);
 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE        \
        assert(cv); assert(params)
 
@@ -1123,8 +1132,10 @@ PERL_CALLCONV void       Perl_get_db_sub(pTHX_ SV **svp, CV *cv)
 #define PERL_ARGS_ASSERT_GET_DB_SUB    \
        assert(cv)
 
-PERL_CALLCONV UV       Perl_get_hash_seed(pTHX)
-                       __attribute__warn_unused_result__;
+PERL_CALLCONV void     Perl_get_hash_seed(pTHX_ unsigned char *seed_buffer)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_HASH_SEED \
+       assert(seed_buffer)
 
 PERL_CALLCONV HV*      Perl_get_hv(pTHX_ const char *name, I32 flags)
                        __attribute__nonnull__(pTHX_1);
@@ -1670,6 +1681,14 @@ PERL_CALLCONV bool       Perl_is_uni_alnum_lc(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_alnumc_lc(pTHX_ UV c)
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
 PERL_CALLCONV bool     Perl_is_uni_alpha(pTHX_ UV c)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
@@ -1679,22 +1698,32 @@ PERL_CALLCONV bool      Perl_is_uni_alpha_lc(pTHX_ UV c)
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_ascii(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_ascii_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_blank(pTHX_ UV c)
+                       __attribute__deprecated__
+                       __attribute__warn_unused_result__
+                       __attribute__pure__;
+
+PERL_CALLCONV bool     Perl_is_uni_blank_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_cntrl(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_cntrl_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -1719,6 +1748,7 @@ PERL_CALLCONV bool        Perl_is_uni_idfirst(pTHX_ UV c)
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_idfirst_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -1747,10 +1777,12 @@ PERL_CALLCONV bool      Perl_is_uni_punct_lc(pTHX_ UV c)
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_space(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_space_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -1763,29 +1795,25 @@ PERL_CALLCONV bool      Perl_is_uni_upper_lc(pTHX_ UV c)
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_xdigit(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV bool     Perl_is_uni_xdigit_lc(pTHX_ UV c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
-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_regular_begin(pTHX_ const U8 *p)
+PERL_CALLCONV bool     Perl_is_utf8_alnum(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_REGULAR_BEGIN       \
+#define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \
        assert(p)
 
-PERL_CALLCONV bool     Perl_is_utf8_alnum(pTHX_ const U8 *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_ALNUM \
+#define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_alpha(pTHX_ const U8 *p)
@@ -1795,12 +1823,14 @@ PERL_CALLCONV bool      Perl_is_utf8_alpha(pTHX_ const U8 *p)
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_ascii(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_blank(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_BLANK \
@@ -1819,6 +1849,7 @@ PERL_CALLCONV STRLEN      Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
        assert(buf); assert(buf_end)
 
 PERL_CALLCONV bool     Perl_is_utf8_cntrl(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \
@@ -1837,12 +1868,14 @@ PERL_CALLCONV bool      Perl_is_utf8_graph(pTHX_ const U8 *p)
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_idcont(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_idfirst(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST       \
@@ -1861,18 +1894,21 @@ PERL_CALLCONV bool      Perl_is_utf8_mark(pTHX_ const U8 *p)
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_perl_space(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __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__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD     \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT   \
@@ -1891,6 +1927,7 @@ PERL_CALLCONV bool        Perl_is_utf8_punct(pTHX_ const U8 *p)
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_space(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \
@@ -1918,18 +1955,21 @@ PERL_CALLCONV bool      Perl_is_utf8_upper(pTHX_ const U8 *p)
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xdigit(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT        \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xidcont(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT       \
        assert(p)
 
 PERL_CALLCONV bool     Perl_is_utf8_xidfirst(pTHX_ const U8 *p)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST      \
@@ -3939,7 +3979,7 @@ PERL_CALLCONV void        Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flag
        assert(sv)
 
 PERL_CALLCONV void     Perl_sv_free(pTHX_ SV *const sv);
-PERL_CALLCONV void     Perl_sv_free2(pTHX_ SV *const sv)
+PERL_CALLCONV void     Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_SV_FREE2      \
        assert(sv)
@@ -4446,6 +4486,7 @@ PERL_CALLCONV UV  Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_lower_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4456,6 +4497,7 @@ PERL_CALLCONV UV  Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_title_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4466,6 +4508,7 @@ PERL_CALLCONV UV  Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp)
        assert(p); assert(lenp)
 
 PERL_CALLCONV U32      Perl_to_uni_upper_lc(pTHX_ U32 c)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -4847,15 +4890,6 @@ PERL_CALLCONV void       Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop
        assert(idop)
 
 #endif
-#if !(defined(USE_ITHREADS))
-#  if defined(PERL_IN_OP_C)
-STATIC void    S_forget_pmop(pTHX_ PMOP *const o)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP   \
-       assert(o)
-
-#  endif
-#endif
 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
 PERL_CALLCONV char*    Perl_my_bzero(char* loc, I32 len)
                        __attribute__nonnull__(1);
@@ -5224,17 +5258,14 @@ PERL_CALLCONV MEM_SIZE  Perl_malloced_size(void *p)
 #endif
 #if defined(MYSWAP)
 PERL_CALLCONV long     Perl_my_htonl(pTHX_ long l)
-                       __attribute__malloc__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV long     Perl_my_ntohl(pTHX_ long l)
-                       __attribute__malloc__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
 PERL_CALLCONV short    Perl_my_swap(pTHX_ short s)
-                       __attribute__malloc__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 
@@ -5242,6 +5273,13 @@ PERL_CALLCONV short      Perl_my_swap(pTHX_ short s)
 #if defined(NO_MATHOMS)
 /* PERL_CALLCONV void  Perl_sv_nounlocking(pTHX_ SV *sv); */
 #endif
+#if defined(PERL_ANY_COW)
+PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_SETSV_COW  \
+       assert(sstr)
+
+#endif
 #if defined(PERL_CORE)
 PERL_CALLCONV void     Perl_opslab_force_free(pTHX_ OPSLAB *slab)
                        __attribute__nonnull__(pTHX_1);
@@ -5258,6 +5296,12 @@ PERL_CALLCONV void       Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
 #define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD     \
        assert(slab)
 
+PERL_CALLCONV void     Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS      \
+       assert(parser); assert(slab)
+
 #  if defined(PERL_DEBUG_READONLY_OPS)
 PERL_CALLCONV void     Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
                        __attribute__nonnull__(pTHX_1);
@@ -5504,36 +5548,6 @@ 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 bool        S_grok_bslash_x(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_X \
-       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)
@@ -5626,7 +5640,7 @@ STATIC void       S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store)
 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK        \
        assert(hv); assert(needs_copy); assert(needs_store)
 
-PERL_CALLCONV_NO_RET STATIC void       S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
+PERL_STATIC_NO_RET void        S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_4);
@@ -5790,6 +5804,11 @@ STATIC OP*       S_fold_constants(pTHX_ OP *o)
        assert(o)
 
 STATIC OP*     S_force_list(pTHX_ OP* arg);
+STATIC void    S_forget_pmop(pTHX_ PMOP *const o)
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FORGET_PMOP   \
+       assert(o)
+
 STATIC OP*     S_gen_constant_list(pTHX_ OP* o);
 STATIC SV*     S_gv_ename(pTHX_ GV *gv)
                        __attribute__nonnull__(pTHX_1);
@@ -5922,13 +5941,6 @@ STATIC OP*       S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
        assert(o); assert(namesv)
 
-#  if defined(USE_ITHREADS)
-STATIC void    S_forget_pmop(pTHX_ PMOP *const o, U32 flags)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP   \
-       assert(o)
-
-#  endif
 #endif
 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C)
 PERL_CALLCONV void     Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp)
@@ -5992,10 +6004,10 @@ STATIC SV*      S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags)
 #define PERL_ARGS_ASSERT_MAYBERELOCATE \
        assert(dir)
 
-PERL_CALLCONV_NO_RET STATIC void       S_minus_v(pTHX)
+PERL_STATIC_NO_RET void        S_minus_v(pTHX)
                        __attribute__noreturn__;
 
-PERL_CALLCONV_NO_RET STATIC void       S_my_exit_jump(pTHX)
+PERL_STATIC_NO_RET void        S_my_exit_jump(pTHX)
                        __attribute__noreturn__;
 
 STATIC void    S_nuke_stacks(pTHX);
@@ -6006,10 +6018,10 @@ STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool
        assert(scriptname); assert(suidscript)
 
 STATIC void*   S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
-PERL_CALLCONV_NO_RET STATIC void       S_run_body(pTHX_ I32 oldscope)
+PERL_STATIC_NO_RET void        S_run_body(pTHX_ I32 oldscope)
                        __attribute__noreturn__;
 
-PERL_CALLCONV_NO_RET STATIC void       S_usage(pTHX)
+PERL_STATIC_NO_RET void        S_usage(pTHX)
                        __attribute__noreturn__;
 
 #endif
@@ -6146,12 +6158,11 @@ STATIC void     S_save_lines(pTHX_ AV *array, SV *sv)
 
 #endif
 #if defined(PERL_IN_PP_HOT_C)
-STATIC void    S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
+STATIC void    S_do_oddball(pTHX_ SV **oddkey, SV **firstkey)
                        __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
+                       __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_DO_ODDBALL    \
-       assert(hash); assert(relem); assert(firstrelem)
+       assert(oddkey); assert(firstkey)
 
 STATIC SV*     S_method_common(pTHX_ SV* meth, U32* hashp)
                        __attribute__warn_unused_result__
@@ -6336,12 +6347,6 @@ STATIC SV*       S__new_invlist_C_array(pTHX_ UV* list)
 #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY  \
        assert(list)
 
-STATIC void    S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_ADD_ALTERNATE \
-       assert(alternate_ptr); assert(string)
-
 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
                        __attribute__warn_unused_result__;
 
@@ -6359,11 +6364,6 @@ PERL_STATIC_INLINE void  S_alloc_maybe_populate_EXACT(pTHX_ struct RExC_state_t *
 #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT    \
        assert(pRExC_state); assert(node); assert(flagp)
 
-STATIC void    S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state)
-                       __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CHECKPOSIXCC  \
-       assert(pRExC_state)
-
 STATIC void    S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with)
                        __attribute__nonnull__(1)
                        __attribute__nonnull__(2);
@@ -6522,7 +6522,7 @@ STATIC char *     S_nextchar(pTHX_ struct RExC_state_t *pRExC_state)
 #define PERL_ARGS_ASSERT_NEXTCHAR      \
        assert(pRExC_state)
 
-PERL_CALLCONV_NO_RET STATIC void       S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
+PERL_STATIC_NO_RET void        S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
                        __attribute__noreturn__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2);
@@ -6590,7 +6590,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 I32     S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, SV *free_me)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_REGPPOSIXCC   \
        assert(pRExC_state)
@@ -6633,13 +6633,6 @@ STATIC I32       S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp
 
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-PERL_CALLCONV SV*      Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
-                       __attribute__nonnull__(pTHX_1)
-                       __attribute__nonnull__(pTHX_2)
-                       __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT__CORE_SWASH_INIT      \
-       assert(pkg); assert(name); assert(listsv)
-
 PERL_STATIC_INLINE UV* S__get_invlist_len_addr(pTHX_ SV* invlist)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6683,6 +6676,45 @@ PERL_CALLCONV HV*        Perl__swash_inversion_hash(pTHX_ SV* const swash)
        assert(swash)
 
 #endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV SV*      Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT__CORE_SWASH_INIT      \
+       assert(pkg); assert(name); assert(listsv)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_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 bool        S_grok_bslash_x(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_X \
+       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_REGCOMP_C) || defined(PERL_IN_UTF8_C)
 PERL_CALLCONV SV*      Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end)
                        __attribute__warn_unused_result__;
@@ -6740,7 +6772,7 @@ PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash)
 
 #endif
 #if defined(PERL_IN_REGEXEC_C)
-STATIC SV*     S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp)
+STATIC SV*     S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2);
 #define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH   \
@@ -6755,6 +6787,9 @@ 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 bool    S_isFOO_lc(pTHX_ const U8 classnum, const U8 character)
+                       __attribute__warn_unused_result__;
+
 PERL_STATIC_INLINE bool        S_is_utf8_X_LVT(pTHX_ const U8 *p)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
@@ -6792,7 +6827,7 @@ STATIC U8*        S_reghopmaybe3(U8 *s, I32 off, const U8 *lim)
 #define PERL_ARGS_ASSERT_REGHOPMAYBE3  \
        assert(s); assert(lim)
 
-STATIC bool    S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, STRLEN *lenp, bool const do_utf8sv_is_utf8)
+STATIC bool    S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, bool const utf8_target)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_2)
                        __attribute__nonnull__(pTHX_3);
@@ -7070,6 +7105,13 @@ STATIC char*     S_force_word(pTHX_ char *start, int token, int check_keyword, int a
 #define PERL_ARGS_ASSERT_FORCE_WORD    \
        assert(start)
 
+PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME        \
+       assert(s); assert(e)
+
 STATIC void    S_incline(pTHX_ const char *s)
                        __attribute__nonnull__(pTHX_1);
 #define PERL_ARGS_ASSERT_INCLINE       \
@@ -7090,7 +7132,7 @@ STATIC I32        S_lop(pTHX_ I32 f, int x, char *s)
 #define PERL_ARGS_ASSERT_LOP   \
        assert(s)
 
-PERL_CALLCONV_NO_RET STATIC void       S_missingterm(pTHX_ char *s)
+PERL_STATIC_NO_RET void        S_missingterm(pTHX_ char *s)
                        __attribute__noreturn__;
 
 STATIC SV*     S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen)
@@ -7243,13 +7285,13 @@ STATIC UV       S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV res
 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING        \
        assert(p); assert(ustrp); assert(lenp)
 
-STATIC STRLEN  S_is_utf8_char_slow(const U8 *s, const STRLEN len)
+PERL_STATIC_INLINE STRLEN      S_is_utf8_char_slow(const U8 *s, const STRLEN len)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(1);
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW     \
        assert(s)
 
-STATIC bool    S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
+PERL_STATIC_INLINE bool        S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1)
                        __attribute__nonnull__(pTHX_2)
@@ -7282,6 +7324,18 @@ PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, con
 #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1       \
        assert(p); assert(lenp)
 
+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_regular_begin(pTHX_ const U8 *p)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_REGULAR_BEGIN       \
+       assert(p)
+
 #endif
 #if defined(PERL_IN_UTIL_C)
 STATIC bool    S_ckwarn_common(pTHX_ U32 w);
@@ -7297,9 +7351,6 @@ STATIC SV *       S_with_queued_errors(pTHX_ SV *ex)
 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS    \
        assert(ex)
 
-PERL_CALLCONV_NO_RET STATIC char *     S_write_no_mem(pTHX)
-                       __attribute__noreturn__;
-
 #  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)
@@ -7505,13 +7556,6 @@ PERL_CALLCONV long       Perl_my_letohl(long n);
 #if defined(PERL_NEED_MY_LETOHS)
 PERL_CALLCONV short    Perl_my_letohs(short n);
 #endif
-#if defined(PERL_OLD_COPY_ON_WRITE)
-PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
-                       __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_SETSV_COW  \
-       assert(sstr)
-
-#endif
 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
 STATIC void    S_pidgone(pTHX_ Pid_t pid, int status);
 #endif
@@ -7734,6 +7778,14 @@ PERL_CALLCONV SSize_t    Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_
        assert(vbuf)
 
 #endif
+#if defined(WIN32)
+PERL_CALLCONV_NO_RET void      win32_croak_not_implemented(const char * fname)
+                       __attribute__noreturn__
+                       __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED   \
+       assert(fname)
+
+#endif
 #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS)
 PERL_CALLCONV int      Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp)
                        __attribute__nonnull__(pTHX_2)
Unnamed repository; edit this file 'description' to name the repository.