*/
START_EXTERN_C
+PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch)
+ __attribute__deprecated__
+ __attribute__warn_unused_result__
+ __attribute__pure__;
+
PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_AMUPDATE \
assert(stash)
-PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode);
-PERL_CALLCONV_NO_RET void Perl_croak_memory_wrap(void)
- __attribute__noreturn__;
+PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch)
+ __attribute__deprecated__
+ __attribute__warn_unused_result__
+ __attribute__pure__;
+PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode);
PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz)
__attribute__malloc__
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_SLAB_FREE \
assert(op)
+PERL_CALLCONV SV* Perl__get_encoding(pTHX)
+ __attribute__pure__;
+
+PERL_CALLCONV bool Perl__is_in_locale_category(pTHX_ const bool compiling, const int category);
PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT__IS_UTF8_FOO \
assert(p)
+PERL_STATIC_INLINE STRLEN S__is_utf8_char_slow(const U8 *s, const U8 *e)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_SLOW \
+ assert(s); assert(e)
+
+PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_IDCONT \
+ assert(p)
+
+PERL_CALLCONV bool Perl__is_utf8_idstart(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_IDSTART \
+ assert(p)
+
PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#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)
+PERL_CALLCONV bool Perl__is_utf8_xidcont(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_XIDCONT \
+ assert(p)
+
+PERL_CALLCONV bool Perl__is_utf8_xidstart(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__IS_UTF8_XIDSTART \
+ assert(p)
+
+PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \
assert(p); assert(lenp)
-PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags, bool* tainted_ptr)
+PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \
assert(p); assert(ustrp)
-PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr)
+PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \
assert(p); assert(ustrp)
-PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr)
+PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \
assert(p); assert(ustrp)
-PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, const bool flags, bool* tainted_ptr)
+PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \
assert(p); assert(ustrp)
+PERL_CALLCONV void Perl__warn_problematic_locale(void);
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(ref)
PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method);
+PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest)
+ __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \
+ assert(dest)
+
PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \
assert(avp); assert(val)
-PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
+PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_DELETE \
assert(av)
-PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, I32 key)
+PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_EXISTS \
assert(av)
-PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, I32 key)
+PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_EXTEND \
assert(av)
-PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, I32 key, SSize_t *maxp, SV ***allocp, SV ***arrayp)
+PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp)
__attribute__nonnull__(pTHX_3)
__attribute__nonnull__(pTHX_4)
__attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \
assert(maxp); assert(allocp); assert(arrayp)
-PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval)
+PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_FETCH \
assert(av)
-PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, I32 fill)
+PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_FILL \
assert(av)
#define PERL_ARGS_ASSERT_AV_ITER_P \
assert(av)
-PERL_CALLCONV I32 Perl_av_len(pTHX_ AV *av)
+PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_LEN \
assert(av)
-PERL_CALLCONV AV* Perl_av_make(pTHX_ I32 size, SV **strp)
+PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_AV_MAKE \
#define PERL_ARGS_ASSERT_AV_SHIFT \
assert(av)
-PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val)
+PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_STORE \
assert(av)
-/* PERL_CALLCONV I32 Perl_av_tindex(pTHX_ AV *av)
+/* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1); */
-PERL_STATIC_INLINE I32 S_av_top_index(pTHX_ AV *av)
+PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_TOP_INDEX \
#define PERL_ARGS_ASSERT_AV_UNDEF \
assert(av)
-PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, I32 num)
+PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_UNSHIFT \
assert(av)
#define PERL_ARGS_ASSERT_CANDO \
assert(statbufp)
-PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f)
+PERL_CALLCONV I32 Perl_cast_i32(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f)
+PERL_CALLCONV IV Perl_cast_iv(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f)
+PERL_CALLCONV U32 Perl_cast_ulong(NV f)
__attribute__warn_unused_result__;
-PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f)
+PERL_CALLCONV UV Perl_cast_uv(NV f)
__attribute__warn_unused_result__;
PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len)
#define PERL_ARGS_ASSERT_CK_ANONCODE \
assert(o)
+PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_BACKTICK \
+ assert(o)
+
PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_DELETE \
assert(o)
-PERL_CALLCONV OP * Perl_ck_die(pTHX_ OP *o)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_DIE \
- assert(o)
-
PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_EXISTS \
assert(o)
-PERL_CALLCONV OP * Perl_ck_exit(pTHX_ OP *o)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_EXIT \
- assert(o)
-
PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_OPEN \
assert(o)
+PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_PROTOTYPE \
+ assert(o)
+
PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_READLINE \
assert(o)
+PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_REFASSIGN \
+ assert(o)
+
PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_SPLIT \
assert(o)
+PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CK_STRINGIFY \
+ assert(o)
+
PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w);
PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w);
-PERL_CALLCONV OP* Perl_convert(pTHX_ I32 optype, I32 flags, OP* o)
- __attribute__warn_unused_result__;
+PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CLOSEST_COP \
+ assert(cop)
PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags)
__attribute__nonnull__(pTHX_1);
__attribute__noreturn__
__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
+PERL_STATIC_NO_RET void S_croak_memory_wrap(void)
+ __attribute__noreturn__;
+
PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void)
__attribute__noreturn__;
#define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \
assert(o)
+PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \
+ assert(o)
+
PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \
assert(ppaddr); assert(xop)
-PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o)
+/* 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)
+ __attribute__nonnull__(pTHX_1); */
PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CV_CLONE_INTO \
assert(proto); assert(target)
-PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
+PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv)
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv)
__attribute__warn_unused_result__;
PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv)
#define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \
assert(cv); assert(ckfun_p); assert(ckobj_p)
+PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_NAME \
+ assert(cv)
+
PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \
assert(cv); assert(ckfun); assert(ckobj)
+PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 flags)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \
+ assert(cv); assert(ckfun); assert(ckobj)
+
PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CV_UNDEF \
assert(cv)
+PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV* cv, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \
+ assert(cv)
+
+PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CVGV_FROM_HEK \
+ assert(cv)
+
PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CVGV_SET \
PERL_CALLCONV void Perl_debprofdump(pTHX);
PERL_CALLCONV I32 Perl_debstack(pTHX);
PERL_CALLCONV I32 Perl_debstackptrs(pTHX);
+PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DEFELEM_TARGET \
+ assert(sv)
+
PERL_CALLCONV void Perl_delete_eval_scope(pTHX);
PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen)
__attribute__nonnull__(1)
assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
PERL_CALLCONV void Perl_despatch_signals(pTHX);
-PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...)
+PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...)
+ __attribute__noreturn__
__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
-PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex)
+PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex)
+ __attribute__noreturn__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DIE_SV \
assert(baseex)
#define PERL_ARGS_ASSERT_DO_OPEN \
assert(gv); assert(name)
+PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_DO_OPEN6 \
+ assert(gv); assert(oname)
+
PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_DO_OPEN9 \
assert(gv); assert(name); assert(svs)
+PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_DO_OPEN_RAW \
+ assert(gv); assert(oname)
+
PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
PERL_CALLCONV I32 Perl_dowantarray(pTHX)
__attribute__warn_unused_result__;
+PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_DRAND48_INIT_R \
+ assert(random_state)
+
+PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_DRAND48_R \
+ assert(random_state)
+
PERL_CALLCONV void Perl_dump_all(pTHX);
PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl);
PERL_CALLCONV void Perl_dump_eval(pTHX);
PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv);
PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp);
+PERL_CALLCONV UV Perl_grok_atou(const char* pv, const char** endptr)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GROK_ATOU \
+ assert(pv)
+
PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_GROK_HEX \
assert(start); assert(len_p); assert(flags)
+PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char** sp, const char *send)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GROK_INFNAN \
+ assert(sp); assert(send)
+
PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GROK_NUMBER \
assert(pv)
+PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \
+ assert(pv)
+
PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \
assert(namesv)
-PERL_CALLCONV void Perl_gv_check(pTHX_ const HV* stash)
+PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_CHECK \
assert(stash)
#define PERL_ARGS_ASSERT_GV_NAME_SET \
assert(gv); assert(name)
+PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_OVERRIDE \
+ assert(name)
+
+PERL_CALLCONV void Perl_gv_setref(pTHX_ SV *const dstr, SV *const sstr)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GV_SETREF \
+ assert(dstr); assert(sstr)
+
PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_STASHPV \
#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \
assert(hv)
-PERL_CALLCONV I32* Perl_hv_placeholders_p(pTHX_ HV *hv)
+PERL_CALLCONV SSize_t* Perl_hv_placeholders_p(pTHX_ HV *hv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \
PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd)
__attribute__warn_unused_result__;
-PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit)
+PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_IO_CLOSE \
assert(io)
-PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p)
+PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p)
__attribute__deprecated__
__attribute__warn_unused_result__
__attribute__pure__
#define PERL_ARGS_ASSERT_ISALNUM_LAZY \
assert(p)
-PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p)
+PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p)
__attribute__deprecated__
__attribute__warn_unused_result__
__attribute__pure__
#define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \
assert(p)
-PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len)
+/* PERL_CALLCONV bool Perl_is_ascii_string(pTHX_ const U8 *s, STRLEN len)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV bool Perl_is_invariant_string(const U8 *s, STRLEN len)
+ __attribute__warn_unused_result__
__attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_IS_ASCII_STRING \
+#define PERL_ARGS_ASSERT_IS_INVARIANT_STRING \
assert(s)
PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX)
__attribute__warn_unused_result__;
+PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \
+ assert(pv); assert(what); assert(op_name)
+
PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c)
__attribute__deprecated__
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_IS_UTF8_CHAR \
assert(s)
-PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
+/* PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end)
__attribute__nonnull__(1)
- __attribute__nonnull__(2);
+ __attribute__nonnull__(2); */
#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \
assert(buf); assert(buf_end)
#define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \
assert(p)
+PERL_CALLCONV bool Perl_isinfnan(NV nv);
+PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_ISINFNANSV \
+ assert(sv)
+
PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_JMAYBE \
#define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \
assert(sv); assert(mg)
+PERL_CALLCONV int Perl_magic_getdebugvar(pTHX_ SV* sv, MAGIC* mg)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR \
+ assert(sv); assert(mg)
+
PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \
assert(sv); assert(mg)
-PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...)
+PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \
assert(sv); assert(mg)
+PERL_CALLCONV int Perl_magic_setdebugvar(pTHX_ SV* sv, MAGIC* mg)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR \
+ assert(sv); assert(mg)
+
PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MAGIC_SETISA \
assert(sv); assert(mg)
+PERL_CALLCONV int Perl_magic_setlvref(pTHX_ SV* sv, MAGIC* mg)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_SETLVREF \
+ assert(sv); assert(mg)
+
PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV void Perl_markstack_grow(pTHX);
+PERL_CALLCONV I32 * Perl_markstack_grow(pTHX);
PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...)
__attribute__format__(__printf__,pTHX_1,pTHX_2)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MG_COPY \
assert(sv); assert(nsv)
-PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type)
+PERL_CALLCONV MAGIC* Perl_mg_find(const SV* sv, int type)
__attribute__warn_unused_result__;
-PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
+PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_MG_FIND_MGLOB \
+ assert(sv)
+
+PERL_CALLCONV MAGIC* Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl)
__attribute__warn_unused_result__;
PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv)
#define PERL_ARGS_ASSERT_MG_LOCALIZE \
assert(sv); assert(nsv)
-PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void Perl_mg_magical(SV* sv)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_MG_MAGICAL \
assert(sv)
#define PERL_ARGS_ASSERT_MG_SIZE \
assert(sv)
-PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm)
- __attribute__nonnull__(pTHX_1);
+PERL_CALLCONV void Perl_mini_mktime(struct tm *ptm)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_MINI_MKTIME \
assert(ptm)
#define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \
assert(smeta); assert(which); assert(data)
+PERL_CALLCONV SV* Perl_multideref_stringify(pTHX_ const OP* o, CV *cv)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY \
+ assert(o); assert(cv)
+
PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MY_ATOF \
assert(o)
PERL_CALLCONV void Perl_my_clearenv(pTHX);
-PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir);
+PERL_CALLCONV int Perl_my_dirfd(DIR* dir);
PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status)
__attribute__noreturn__;
PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
/* PERL_CALLCONV I32 Perl_my_stat(pTHX); */
PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags);
+PERL_CALLCONV char* Perl_my_strerror(pTHX_ const int errnum);
PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
+ __attribute__format__(__strftime__,pTHX_1,0)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MY_STRFTIME \
assert(fmt)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV CV* Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block);
-PERL_CALLCONV CV* Perl_newATTRSUB_flags(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, U32 flags);
+/* PERL_CALLCONV CV* newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */
+PERL_CALLCONV CV* Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv);
/* PERL_CALLCONV AV* Perl_newAV(pTHX)
__attribute__warn_unused_result__; */
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV OP* Perl_newDEFSVOP(pTHX)
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV OP* Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP* dynamic_meth)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_NEWMETHOP \
+ assert(dynamic_meth)
+
+PERL_CALLCONV OP* Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV* const_meth)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \
+ assert(const_meth)
+
PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_NEWMYSUB \
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV PADNAMELIST * Perl_newPADNAMELIST(size_t max)
+ __attribute__malloc__
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \
+ assert(outer)
+
+PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NEWPADNAMEPVN \
+ assert(s)
+
PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags)
__attribute__malloc__
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_NEWRV \
assert(sv)
-PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv)
+PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const tmpRef)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEWRV_NOINC \
- assert(sv)
+ assert(tmpRef)
PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop)
__attribute__malloc__
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible)
+ __attribute__malloc__
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \
+ assert(av)
+
PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek)
__attribute__malloc__
__attribute__warn_unused_result__;
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV OP* Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP* first, UNOP_AUX_item *aux)
+ __attribute__malloc__
+ __attribute__warn_unused_result__;
+
PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block)
__attribute__malloc__
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_NEWXS \
assert(subaddr); assert(filename)
+PERL_CALLCONV CV * Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_NEWXS_DEFFILE \
+ assert(name); assert(subaddr)
+
PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
assert(subaddr); assert(filename)
PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char *const filename, const char *const proto, SV **const_svp, U32 flags)
- __attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \
- assert(subaddr); assert(filename)
+ assert(subaddr)
PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll);
PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype)
#define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \
assert(bits)
-PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv)
+PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv, bool nomagicopen)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEXTARGV \
assert(gv)
#define PERL_ARGS_ASSERT_NINSTR \
assert(big); assert(bigend); assert(little); assert(lend)
+PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...)
+ __attribute__noreturn__
+ __attribute__format__(__printf__,1,2)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_NOPERL_DIE \
+ assert(pat)
+
PERL_CALLCONV int Perl_nothreadhook(pTHX);
PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o)
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_OP_CLEAR \
assert(o)
-PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
- __attribute__warn_unused_result__;
-
PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \
assert(o)
+PERL_CALLCONV OP* Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP* o)
+ __attribute__warn_unused_result__;
+
PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_OP_DUMP \
#define PERL_ARGS_ASSERT_OP_NULL \
assert(o)
+PERL_CALLCONV OP* Perl_op_parent(OP *o)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_OP_PARENT \
+ assert(o)
+
PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last);
PERL_CALLCONV void Perl_op_refcnt_lock(pTHX);
PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX);
PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o);
+PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE \
+ assert(parent)
+
PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o);
PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_PACK_CAT \
assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list)
+PERL_CALLCONV void Perl_package(pTHX_ OP* o)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PACKAGE \
+ assert(o)
+
PERL_CALLCONV void Perl_package_version(pTHX_ OP* v)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PACKAGE_VERSION \
#define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \
assert(name)
+PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV* func)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \
+ assert(func)
+
PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full);
PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po)
#define PERL_ARGS_ASSERT_PADLIST_STORE \
assert(padlist)
+PERL_CALLCONV void Perl_padname_free(pTHX_ PADNAME *pn)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAME_FREE \
+ assert(pn)
+
+PERL_CALLCONV PADNAME * Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \
+ assert(pnl)
+
+PERL_CALLCONV void Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_FREE \
+ assert(pnl)
+
+PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADNAMELIST_STORE \
+ assert(pnl)
+
PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags);
PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags);
PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags);
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_subsignature(pTHX)
+ __attribute__warn_unused_result__;
+
PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags);
PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt)
__attribute__nonnull__(pTHX_1);
assert(my_perl)
PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm);
-PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor)
+PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, bool isreg, I32 floor)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PMRUNTIME \
#define PERL_ARGS_ASSERT_PREGCOMP \
assert(pattern)
-PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave)
+PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
assert(dsv); assert(pv)
PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags)
- __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PV_ESCAPE \
- assert(dsv); assert(str)
+ assert(str)
PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_RE_COMPILE \
assert(pattern)
-PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data)
+PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, const char* const strbeg, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_RE_INTUIT_START \
- assert(rx); assert(strpos); assert(strend)
+ assert(rx); assert(strbeg); assert(strpos); assert(strend)
PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGDUMP \
assert(r)
-PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, I32 minend, SV *sv, void *data, U32 flags)
+PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p)
__attribute__warn_unused_result__;
-PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_REGPROP \
- assert(sv); assert(o)
-
PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_SAVE_I8 \
assert(bytep)
-PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, I32 key)
+PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SAVE_ADELETE \
assert(av)
-/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr)
+/* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3); */
-PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, I32 idx, SV **sptr, const U32 flags)
+PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \
assert(av); assert(sptr)
+PERL_CALLCONV void Perl_save_aliased_sv(pTHX_ GV* gv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SAVE_ALIASED_SV \
+ assert(gv)
+
PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad);
PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SAVE_SPTR \
assert(sptr)
+PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN* ptr)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SAVE_STRLEN \
+ assert(ptr)
+
PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SAVE_SVREF \
#define PERL_ARGS_ASSERT_SCAN_VSTRING \
assert(s); assert(e); assert(sv)
-PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SCREAMINSTR \
- assert(bigstr); assert(littlestr); assert(old_posp)
-
PERL_CALLCONV U32 Perl_seed(pTHX);
+PERL_CALLCONV void Perl_set_caret_X(pTHX);
PERL_CALLCONV void Perl_set_context(void *t)
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_SET_CONTEXT \
#define PERL_ARGS_ASSERT_SORTSV_FLAGS \
assert(cmp)
-PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, int n)
+PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, SSize_t n)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_STACK_GROW \
/* PERL_CALLCONV bool sv_2bool(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1); */
-PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *const sv, const I32 flags)
+PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \
assert(sv)
#define PERL_ARGS_ASSERT_SV_2IO \
assert(sv)
-/* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv); */
-PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags);
-PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv);
-PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SV_2NUM \
+/* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1); */
+#define PERL_ARGS_ASSERT_SV_2IV \
+ assert(sv)
+
+PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_2IV_FLAGS \
+ assert(sv)
+
+PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv);
+PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_2NUM \
+ assert(sv)
+
+PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_2NV_FLAGS \
+ assert(sv)
+
+/* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
+ __attribute__nonnull__(pTHX_1); */
+#define PERL_ARGS_ASSERT_SV_2PV \
+ assert(sv)
+
+PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_2PV_FLAGS \
assert(sv)
-PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags);
-/* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */
-PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags);
/* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1); */
#define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \
assert(sv)
-/* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv); */
-PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags);
-PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv)
+/* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1); */
+#define PERL_ARGS_ASSERT_SV_2UV \
+ assert(sv)
+
+PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags)
__attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_2UV_FLAGS \
+ assert(sv)
+
+PERL_CALLCONV int Perl_sv_backoff(SV *const sv)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_SV_BACKOFF \
assert(sv)
assert(sv)
PERL_CALLCONV void Perl_sv_free_arenas(pTHX);
+PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv)
+ __attribute__pure__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SV_GET_BACKREFS \
+ assert(sv)
+
PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_MAGICEXT \
assert(sv)
+PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \
+ assert(sv)
+
/* PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
__attribute__malloc__
__attribute__warn_unused_result__; */
#define PERL_ARGS_ASSERT_SV_POS_B2U \
assert(offsetp)
+PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \
+ assert(sv)
+
PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_POS_U2B \
#define PERL_ARGS_ASSERT_SWASH_INIT \
assert(pkg); assert(name); assert(listsv)
+PERL_CALLCONV void Perl_sync_locale(pTHX);
PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#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, ...)
+PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *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)
#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 SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix);
/* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3); */
#define PERL_ARGS_ASSERT_UTF8_DISTANCE \
assert(a); assert(b)
-PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off)
+PERL_CALLCONV U8* Perl_utf8_hop(const U8 *s, I32 off)
__attribute__warn_unused_result__
__attribute__pure__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_UTF8_HOP \
assert(s)
#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \
assert(s)
-PERL_CALLCONV UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+/* PERL_CALLCONV UV utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \
- assert(s); assert(send)
+ __attribute__nonnull__(pTHX_2); */
PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
__attribute__deprecated__
assert(s)
PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen)
+ __attribute__deprecated__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \
assert(s); assert(send)
+PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \
+ assert(s)
+
PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \
assert(s)
-PERL_CALLCONV U8* Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
+PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_UTILIZE \
+ assert(idop)
+
+/* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv)
+ __attribute__nonnull__(pTHX_1); */
+
+/* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
+ __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS \
+#define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \
assert(d)
-/* PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
- __attribute__nonnull__(pTHX_1); */
+PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv)
+ __attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \
assert(d)
#define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \
assert(d)
+PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \
+ assert(s)
+
PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
+ __attribute__deprecated__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \
assert(s)
+PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_VALIDATE_PROTO \
+ assert(name)
+
PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_WRITE_TO_STDERR \
assert(msv)
-PERL_CALLCONV void Perl_xs_apiversion_bootcheck(pTHX_ SV *module, const char *api_p, STRLEN api_len)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK \
- assert(module); assert(api_p)
-
-PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \
- assert(xs_p)
+PERL_CALLCONV void Perl_xs_boot_epilog(pTHX_ const U32 ax);
+PERL_CALLCONV I32 Perl_xs_handshake(const U32 key, void * v_my_perl, const char * file, ...)
+ __attribute__nonnull__(2)
+ __attribute__nonnull__(3);
+#define PERL_ARGS_ASSERT_XS_HANDSHAKE \
+ assert(v_my_perl); assert(file)
PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s)
__attribute__nonnull__(pTHX_1);
# endif
# endif
#endif
-#if !(defined(EBCDIC))
-/* PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
- __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \
- assert(s)
-
-/* PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
- __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \
- assert(d)
-
-/* PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
- __attribute__nonnull__(pTHX_1); */
-#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \
- assert(s)
-
-#endif
#if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
PERL_CALLCONV Signal_t Perl_csighandler(int sig);
PERL_CALLCONV Signal_t Perl_sighandler(int sig);
# endif
#endif
-#if !(defined(PERL_MAD))
-PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV void Perl_package(pTHX_ OP* o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PACKAGE \
- assert(o)
-
-PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_UTILIZE \
- assert(idop)
+#if !(defined(WIN32))
+/* PERL_CALLCONV char* my_setlocale(pTHX_ int category, const char* locale)
+ __attribute__pure__; */
#endif
#if !(defined(_MSC_VER))
# endif
#endif
+#if !defined(PERL_EXT_RE_BUILD)
+# if defined(PERL_IN_REGCOMP_C)
+PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
+ assert(invlist)
+
+PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
+ assert(invlist)
+
+PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
+ assert(invlist)
+
+PERL_STATIC_INLINE void S_invlist_set_previous_index(SV* const invlist, const IV index)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \
+ assert(invlist)
+
+PERL_STATIC_INLINE void S_invlist_trim(SV* const invlist)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_TRIM \
+ assert(invlist)
+
+# endif
+#endif
#if !defined(PERL_IMPLICIT_SYS)
PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr);
PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode)
assert(buffer); assert(pat)
#endif
+#if !defined(USE_QUADMATH)
+# if defined(PERL_IN_NUMERIC_C)
+STATIC NV S_mulexp10(NV value, I32 exponent);
+# endif
+#endif
#if !defined(WIN32)
PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report)
__attribute__nonnull__(pTHX_1);
assert(sv)
PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po);
+PERL_CALLCONV void Perl_set_padlist(CV * cv, PADLIST * padlist)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SET_PADLIST \
+ assert(cv)
+
# if defined(PERL_IN_PAD_C)
STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_DUMPUNTIL \
assert(r); assert(start); assert(node); assert(sv)
-STATIC void S_put_byte(pTHX_ SV* sv, int c)
+STATIC bool S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV** bitmap_invlist)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \
+ assert(sv); assert(bitmap)
+
+STATIC void S_put_code_point(pTHX_ SV* sv, UV c)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PUT_CODE_POINT \
+ assert(sv)
+
+STATIC void S_put_range(pTHX_ SV* sv, UV start, const UV end, const bool allow_literals)
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PUT_BYTE \
+#define PERL_ARGS_ASSERT_PUT_RANGE \
assert(sv)
STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
-STATIC U8 S_regtail_study(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
+STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
+STATIC U8 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
# endif
# if defined(PERL_IN_TOKE_C)
STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s)
+ __attribute__format__(__printf__,pTHX_1,0)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PRINTBUF \
assert(sv)
#endif
-#if defined(DUMP_FDS)
-PERL_CALLCONV void Perl_dump_fds(pTHX_ char* s)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_DUMP_FDS \
- assert(s)
-
-#endif
-#if defined(EBCDIC)
-PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \
- assert(s)
-
-PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \
- assert(d)
-
-PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \
- assert(s)
-
-#endif
#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \
assert(parser); assert(slab)
+PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SHOULD_WARN_NL \
+ assert(pv)
+
# if defined(PERL_DEBUG_READONLY_OPS)
PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
__attribute__nonnull__(pTHX_1);
# endif
#endif
+#if defined(PERL_CORE) || defined (PERL_EXT)
+PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \
+ assert(sv); assert(pv)
+
+#endif
#if defined(PERL_CR_FILTER)
# if defined(PERL_IN_TOKE_C)
STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen);
# endif
#endif
+#if defined(PERL_DEBUG_READONLY_COW)
+PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_BUF_TO_RO \
+ assert(sv)
+
+# if defined(PERL_IN_SV_C)
+STATIC void S_sv_buf_to_rw(pTHX_ SV *sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_BUF_TO_RW \
+ assert(sv)
+
+# endif
+#endif
#if defined(PERL_DEBUG_READONLY_OPS)
PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DEB_NOCONTEXT \
assert(pat)
-PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...)
+PERL_CALLCONV_NO_RET OP* Perl_die_nocontext(const char* pat, ...)
+ __attribute__noreturn__
__attribute__format__null_ok__(__printf__,1,2);
PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...)
STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective)
__attribute__warn_unused_result__;
+STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_OPENN_CLEANUP \
+ assert(gv); assert(io); assert(mode); assert(oname)
+
+STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_6);
+#define PERL_ARGS_ASSERT_OPENN_SETUP \
+ assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype)
+
#endif
#if defined(PERL_IN_DOOP_C)
STATIC I32 S_do_trans_complex(pTHX_ SV * const sv)
assert(pm)
STATIC UV S_sequence_num(pTHX_ const OP *o);
-# if defined(PERL_MAD)
-STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
- __attribute__format__(__printf__,pTHX_3,pTHX_4)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_ATTR \
- assert(file); assert(pat)
-
-# endif
#endif
#if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C)
PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv)
#endif
#if defined(PERL_IN_GV_C)
+STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \
+ assert(stash); assert(name)
+
+PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags);
STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \
assert(gv)
+STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \
+ assert(name)
+
+STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, bool addmg, const svtype sv_type)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_GV_MAGICALIZE \
+ assert(gv); assert(stash); assert(name)
+
STATIC void S_gv_magicalize_isa(pTHX_ GV *gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \
assert(gv)
+PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \
+ assert(name)
+
+PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags);
+STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \
+ assert(gv); assert(name)
+
+STATIC bool S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \
+ assert(stash); assert(gv); assert(name); assert(len); assert(nambeg)
+
STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_HV_AUXINIT \
assert(hv)
+STATIC struct xpvhv_aux* S_hv_auxinit_internal(struct xpvhv_aux *iter)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL \
+ assert(iter)
+
STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash);
STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry)
__attribute__nonnull__(pTHX_1)
__attribute__malloc__
__attribute__warn_unused_result__;
-STATIC U32 S_ptr_hash(PTRV u);
+PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u);
STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \
assert(hv); assert(indexp)
#endif
-#if defined(PERL_IN_LOCALE_C)
-# if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE)
-STATIC char* S_stdize_locale(pTHX_ char* locs)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
- assert(locs)
+#if defined(PERL_IN_MALLOC_C)
+STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \
+ assert(nbytes_p)
-# endif
#endif
#if defined(PERL_IN_MG_C)
-STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, int n, SV *val)
+STATIC void S_fixup_errno_string(pTHX_ SV* sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \
+ assert(sv)
+
+STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \
assert(sv); assert(mg); assert(meth)
-STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
+STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
assert(sv); assert(mg); assert(meth)
STATIC void S_restore_magic(pTHX_ const void *p);
-STATIC void S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
+STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
__attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SAVE_MAGIC \
+#define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \
assert(sv)
STATIC void S_unwind_handler_stack(pTHX_ const void *p);
#endif
#if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C)
-PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
- __attribute__nonnull__(pTHX_6)
- __attribute__nonnull__(pTHX_7);
+PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp)
+ __attribute__nonnull__(6)
+ __attribute__nonnull__(7);
#define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \
assert(posp); assert(lenp)
#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, U32 flags)
+STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \
assert(stash)
#endif
-#if defined(PERL_IN_NUMERIC_C)
-STATIC NV S_mulexp10(NV value, I32 exponent);
-#endif
#if defined(PERL_IN_OP_C)
PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o);
STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
#define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \
assert(stash); assert(target); assert(imopsp)
-STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid)
+STATIC I32 S_assignment_type(pTHX_ const OP *o)
+ __attribute__warn_unused_result__;
+
+STATIC void S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
- assert(t); assert(name); assert(kid)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_BAD_TYPE_GV \
+ assert(gv); assert(kid); assert(t)
-STATIC void S_bad_type_sv(pTHX_ I32 n, const char *t, SV *namesv, U32 flags, const OP *kid)
+STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_BAD_TYPE_SV \
- assert(t); assert(namesv); assert(kid)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
+ assert(t); assert(o); assert(kid)
+
+STATIC void S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \
+ assert(fullname); assert(gv); assert(cv)
STATIC void S_cop_free(pTHX_ COP *cop)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_FOLD_CONSTANTS \
assert(o)
-STATIC OP* S_force_list(pTHX_ OP* arg);
+STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit);
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);
-#define PERL_ARGS_ASSERT_GV_ENAME \
- assert(gv)
-
STATIC void S_inplace_aassign(pTHX_ OP* o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INPLACE_AASSIGN \
#define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \
assert(o)
-STATIC I32 S_is_list_assignment(pTHX_ const OP *o)
- __attribute__warn_unused_result__;
-
STATIC OP* S_listkids(pTHX_ OP* o);
STATIC bool S_looks_like_bool(pTHX_ const OP* o)
__attribute__nonnull__(pTHX_1);
assert(o)
STATIC OP* S_modkids(pTHX_ OP *o, I32 type);
+STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \
+ assert(proto); assert(attrs); assert(name)
+
STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_MY_KID \
assert(imopsp)
-STATIC OP* S_newDEFSVOP(pTHX)
- __attribute__warn_unused_result__;
-
STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_NEWGIVWHENOP \
assert(block)
+PERL_STATIC_INLINE OP* S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP* dynamic_meth, SV* const_meth);
STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_3)
#define PERL_ARGS_ASSERT_PMTRANS \
assert(o); assert(expr); assert(repl)
-STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
+STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \
assert(o); assert(name)
-STATIC OP* S_too_few_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV \
- assert(o); assert(namesv)
-
STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \
assert(o); assert(name)
-STATIC OP* S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags)
- __attribute__warn_unused_result__
+# if defined(USE_ITHREADS)
+PERL_STATIC_INLINE void S_op_relocate_sv(pTHX_ SV** svp, PADOFFSET* targp)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
- assert(o); assert(namesv)
+#define PERL_ARGS_ASSERT_OP_RELOCATE_SV \
+ assert(svp); assert(targp)
+# 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)
#endif
#if defined(PERL_IN_PAD_C)
-STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash)
+STATIC PADOFFSET S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \
- assert(namesv)
+ assert(name)
-STATIC void S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash)
+STATIC void S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PAD_CHECK_DUP \
assert(name)
-STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags)
+STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, PADNAME** out_name, int *out_flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_4)
__attribute__nonnull__(pTHX_8)
__attribute__nonnull__(pTHX_9);
#define PERL_ARGS_ASSERT_PAD_FINDLEX \
- assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags)
+ assert(namepv); assert(cv); assert(out_name); assert(out_flags)
STATIC void S_pad_reset(pTHX);
#endif
#endif
#if defined(PERL_IN_PP_C)
-STATIC void S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
+STATIC size_t S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_DO_CHOMP \
#endif
#if defined(PERL_IN_PP_CTL_C)
-STATIC SV ** S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_ADJUST_STACK_ON_LEAVE \
- assert(newsp); assert(sp); assert(mark)
-
STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock)
__attribute__warn_unused_result__;
+STATIC SV ** S_leave_common(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags, bool lvalue)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_LEAVE_COMMON \
+ assert(newsp); assert(sp); assert(mark)
+
STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize)
__attribute__warn_unused_result__;
-STATIC bool S_path_is_absolute(const char *name)
+PERL_STATIC_INLINE bool S_path_is_searchable(const char *name)
__attribute__warn_unused_result__
__attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_PATH_IS_ABSOLUTE \
+#define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \
assert(name)
STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen)
#define PERL_ARGS_ASSERT_DO_ODDBALL \
assert(oddkey); assert(firstkey)
-STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp)
- __attribute__warn_unused_result__
+PERL_STATIC_INLINE HV* S_opmethod_stash(pTHX_ SV* meth)
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_METHOD_COMMON \
+#define PERL_ARGS_ASSERT_OPMETHOD_STASH \
assert(meth)
#endif
#if defined(PERL_IN_PP_PACK_C)
-STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1)
- __attribute__nonnull__(3);
-#define PERL_ARGS_ASSERT_BYTES_TO_UNI \
- assert(start); assert(dest)
-
STATIC int S_div128(pTHX_ SV *pnum, bool *done)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MUL128 \
assert(sv)
+STATIC char * S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(3);
+#define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \
+ assert(start); assert(dest)
+
STATIC bool S_need_utf8(const char *pat, const char *patend)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_AMAGIC_CMP \
assert(str1); assert(str2)
-STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
- assert(str1); assert(str2)
-
STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_NCMP \
assert(a); assert(b)
+# if defined(USE_LOCALE_COLLATE)
+STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \
+ assert(str1); assert(str2)
+
+# endif
#endif
#if defined(PERL_IN_PP_SYS_C)
STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_DOFORM \
- assert(cv); assert(gv); assert(retop)
+ assert(cv); assert(gv)
STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \
assert(invlist)
-PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0)
+PERL_STATIC_INLINE UV* S__invlist_array_init(SV* const invlist, const bool will_have_0)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \
assert(invlist)
-STATIC SV* S__new_invlist_C_array(pTHX_ UV* list)
+STATIC SV* S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \
- assert(list)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT__MAKE_EXACTF_INVLIST \
+ assert(pRExC_state); assert(node)
+
+STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \
+ assert(pRExC_state); assert(invlist)
PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
__attribute__warn_unused_result__;
-STATIC U32 S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s)
+STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
- __attribute__nonnull__(3);
+ __attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_ADD_DATA \
assert(pRExC_state); assert(s)
-PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ struct RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point)
+STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \
+ assert(multi_string)
+
+PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point, bool downgradable)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \
assert(pRExC_state); assert(node); assert(flagp)
-STATIC void S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with)
- __attribute__nonnull__(1)
- __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_AND \
- assert(cl); assert(and_with)
-
-STATIC void S_cl_anything(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
- __attribute__nonnull__(1)
- __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_ANYTHING \
- assert(pRExC_state); assert(cl)
-
-STATIC void S_cl_init(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl)
- __attribute__nonnull__(1)
- __attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_CL_INIT \
- assert(pRExC_state); assert(cl)
+STATIC const char * S_cntrl_to_mnemonic(const U8 c)
+ __attribute__pure__;
-STATIC int S_cl_is_anything(const struct regnode_charclass_class *cl)
- __attribute__warn_unused_result__
+PERL_STATIC_INLINE U8 S_compute_EXACTish(RExC_state_t *pRExC_state)
__attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_CL_IS_ANYTHING \
- assert(cl)
-
-STATIC void S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
- __attribute__nonnull__(1)
- __attribute__nonnull__(2)
- __attribute__nonnull__(3);
-#define PERL_ARGS_ASSERT_CL_OR \
- assert(pRExC_state); assert(cl); assert(or_with)
-
-PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ struct RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \
assert(pRExC_state)
-STATIC bool S_could_it_be_a_POSIX_class(pTHX_ struct RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
+STATIC regnode * S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \
+ assert(pRExC_state); assert(source)
+
+STATIC bool S_could_it_be_a_POSIX_class(RExC_state_t *pRExC_state)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \
assert(pRExC_state)
-PERL_STATIC_INLINE UV* S_get_invlist_iter_addr(pTHX_ SV* invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
- assert(invlist)
-
-PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
- assert(invlist)
-
-PERL_STATIC_INLINE UV* S_get_invlist_version_id_addr(pTHX_ SV* invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_VERSION_ID_ADDR \
- assert(invlist)
+STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \
+ assert(pRExC_state); assert(node)
-PERL_STATIC_INLINE UV* S_get_invlist_zero_addr(pTHX_ SV* invlist)
+PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_ZERO_ADDR \
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \
assert(invlist)
-STATIC bool S_grok_bslash_N(pTHX_ struct RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict)
+STATIC STRLEN S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, SV** substitute_parse)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_handle_regex_sets(pTHX_ struct RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse)
+STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3)
__attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \
assert(pRExC_state); assert(flagp); assert(oregcomp_parse)
-PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
- assert(invlist)
-
PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_EXTEND \
assert(invlist)
-PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV S_invlist_highest(SV* const invlist)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \
assert(invlist)
-PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \
- assert(invlist)
-
-PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist)
- __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \
assert(invlist)
-PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist)
- __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE void S_invlist_iterinit(SV* invlist)
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_INVLIST_ITERINIT \
assert(invlist)
-STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end)
+STATIC bool S_invlist_iternext(SV* invlist, UV* start, UV* end)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2)
+ __attribute__nonnull__(3);
#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \
assert(invlist); assert(start); assert(end)
-PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV S_invlist_max(SV* const invlist)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_INVLIST_MAX \
assert(invlist)
-PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
- assert(invlist)
-
-PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len)
+PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \
assert(invlist)
-PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \
- assert(invlist)
-
-PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_TRIM \
- assert(invlist)
+STATIC bool S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc)
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
+#define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT \
+ assert(pRExC_state); assert(ssc)
-STATIC U32 S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *has_exactf_sharp_s, U32 flags, regnode *val, U32 depth)
+STATIC U32 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_JOIN_EXACT \
- assert(pRExC_state); assert(scan); assert(min_subtract); assert(has_exactf_sharp_s)
+ assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char)
-STATIC I32 S_make_trie(pTHX_ struct RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
+STATIC I32 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
#define PERL_ARGS_ASSERT_MAKE_TRIE \
assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail)
-STATIC void S_make_trie_failtable(pTHX_ struct RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \
- assert(pRExC_state); assert(source); assert(stclass)
-
-STATIC char * S_nextchar(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEXTCHAR \
assert(pRExC_state)
-STATIC void S_parse_lparen_question_flags(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \
assert(pRExC_state)
-PERL_STATIC_NO_RET void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
- __attribute__noreturn__
+STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \
+ assert(node); assert(invlist_ptr)
+
+PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...)
+ __attribute__noreturn__
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_RE_CROAK2 \
assert(pat1); assert(pat2)
-STATIC regnode* S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)
+STATIC regnode* S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REG \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op)
+STATIC regnode* S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_REG2LANODE \
+ assert(pRExC_state)
+
+STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REG_NODE \
assert(pRExC_state)
#define PERL_ARGS_ASSERT_REG_RECODE \
assert(encp)
-STATIC SV * S_reg_scan_name(pTHX_ struct RExC_state_t *pRExC_state, U32 flags)
+STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REG_SCAN_NAME \
assert(pRExC_state)
-STATIC bool S_reg_skipcomment(pTHX_ struct RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
+PERL_STATIC_INLINE char * S_reg_skipcomment(RExC_state_t *pRExC_state, char * p)
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \
- assert(pRExC_state)
+ assert(pRExC_state); assert(p)
-STATIC regnode* S_reganode(pTHX_ struct RExC_state_t *pRExC_state, U8 op, U32 arg)
+STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGANODE \
assert(pRExC_state)
-STATIC regnode* S_regatom(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
+STATIC regnode* S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGATOM \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
+STATIC regnode* S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGBRANCH \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, SV** ret_invlist)
+STATIC regnode* S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, SV** ret_invlist)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGCLASS \
assert(pRExC_state); assert(flagp)
-STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
+STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGINSERT \
assert(pRExC_state); assert(opnd)
-STATIC char * S_regpatws(struct RExC_state_t *pRExC_state, char *p, const bool recognize_comment)
+STATIC regnode* S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len, const char* const name)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_REGNODE_GUTS \
+ assert(pRExC_state); assert(name)
+
+STATIC char * S_regpatws(RExC_state_t *pRExC_state, char *p, const bool recognize_comment)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_REGPATWS \
assert(pRExC_state); assert(p)
-STATIC regnode* S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
+STATIC regnode* S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGPIECE \
assert(pRExC_state); assert(flagp)
-PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, const bool strict)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGPPOSIXCC \
assert(pRExC_state)
-STATIC void S_regtail(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
+STATIC void S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGTAIL \
assert(pRExC_state); assert(p); assert(val)
-STATIC STRLEN S_reguni(pTHX_ const struct RExC_state_t *pRExC_state, UV uv, char *s)
+STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf)
__attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_REGUNI \
- assert(pRExC_state); assert(s)
+#define PERL_ARGS_ASSERT_SCAN_COMMIT \
+ assert(pRExC_state); assert(data); assert(minlenp)
-STATIC char * S_regwhite(struct RExC_state_t *pRExC_state, char *p)
+STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const only_utf8_locale_list, SV* const swash, const bool has_user_defined_property)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SET_ANYOF_ARG \
+ assert(pRExC_state); assert(node)
+
+PERL_STATIC_INLINE void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_ADD_RANGE \
+ assert(ssc)
+
+STATIC void S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_SSC_AND \
+ assert(pRExC_state); assert(ssc); assert(and_with)
+
+STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_ANYTHING \
+ assert(ssc)
+
+PERL_STATIC_INLINE void S_ssc_clear_locale(regnode_ssc *ssc)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \
+ assert(ssc)
+
+PERL_STATIC_INLINE void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SSC_CP_AND \
+ assert(ssc)
+
+STATIC void S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_FINALIZE \
+ assert(pRExC_state); assert(ssc)
+
+STATIC void S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_INIT \
+ assert(pRExC_state); assert(ssc)
+
+PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_INTERSECTION \
+ assert(ssc); assert(invlist)
+
+STATIC int S_ssc_is_anything(const regnode_ssc *ssc)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \
+ assert(ssc)
+
+STATIC int S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
__attribute__nonnull__(2);
-#define PERL_ARGS_ASSERT_REGWHITE \
- assert(pRExC_state); assert(p)
+#define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \
+ assert(pRExC_state); assert(ssc)
-STATIC void S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct scan_data_t *data, I32 *minlenp, int is_inf)
+STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_SCAN_COMMIT \
- assert(pRExC_state); assert(data); assert(minlenp)
+#define PERL_ARGS_ASSERT_SSC_OR \
+ assert(pRExC_state); assert(ssc); assert(or_with)
+
+PERL_STATIC_INLINE void S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SSC_UNION \
+ assert(ssc); assert(invlist)
-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)
+STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
#endif
-#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-PERL_STATIC_INLINE UV* S__get_invlist_len_addr(pTHX_ SV* invlist)
+#if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C)
+PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT__INVLIST_DUMP \
+ assert(file); assert(indent); assert(invlist)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C)
+PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__GET_INVLIST_LEN_ADDR \
- assert(invlist)
+#define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \
+ assert(list)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV *exclude_list)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \
+ assert(node)
+PERL_CALLCONV void Perl__load_PL_utf8_foldclosures(pTHX);
+PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_REGPROP \
+ assert(sv); assert(o)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \
assert(swash)
-PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp)
+PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \
assert(invlist)
#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \
assert(invlist)
-PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist)
+PERL_STATIC_INLINE UV S__invlist_len(SV* const invlist)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT__INVLIST_LEN \
assert(invlist)
-PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
+PERL_CALLCONV IV Perl__invlist_search(SV* const invlist, const UV cp)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT__INVLIST_SEARCH \
assert(invlist)
#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
assert(swash)
+PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(SV* invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \
+ assert(invlist)
+
+PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_INVLIST_ARRAY \
+ assert(invlist)
+
#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)
#define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \
assert(s)
-STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
+STATIC char S_grok_bslash_c(pTHX_ const char source, const bool output_warning)
__attribute__warn_unused_result__;
STATIC bool S_grok_bslash_o(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8)
#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
assert(s); assert(uv); assert(error_msg)
-PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped)
+PERL_STATIC_INLINE I32 S_regcurly(const char *s)
__attribute__warn_unused_result__
__attribute__pure__
- __attribute__nonnull__(pTHX_1);
+ __attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_REGCURLY \
assert(s)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3); */
-PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, bool complement_b, SV** i)
+PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \
#define PERL_ARGS_ASSERT__INVLIST_INVERT \
assert(invlist)
-PERL_CALLCONV void Perl__invlist_invert_prop(pTHX_ SV* const invlist)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__INVLIST_INVERT_PROP \
- assert(invlist)
-
-PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_4);
+PERL_CALLCONV void Perl__invlist_populate_swatch(SV* const invlist, const UV start, const UV end, U8* swatch)
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(4);
#define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \
assert(invlist); assert(swatch)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3); */
-PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, bool complement_b, SV** output)
+PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \
PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size)
__attribute__warn_unused_result__;
+PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \
+ assert(other_elements_ptr)
+
PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#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)
+STATIC PL_SB_enum S_advance_one_SB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target)
__attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \
- assert(node)
+#define PERL_ARGS_ASSERT_ADVANCE_ONE_SB \
+ assert(curpos); assert(strend)
+
+STATIC PL_WB_enum S_advance_one_WB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_ADVANCE_ONE_WB \
+ assert(curpos); assert(strend)
-STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo, bool is_utf_pat)
+STATIC PL_SB_enum S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_BACKUP_ONE_SB \
+ assert(strbeg); assert(curpos)
+
+STATIC PL_WB_enum S_backup_one_WB(pTHX_ PL_WB_enum * previous, const U8 * const strbeg, U8 ** curpos, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_BACKUP_ONE_WB \
+ assert(previous); assert(strbeg); assert(curpos)
+
+STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \
assert(character)
-STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
+STATIC bool S_isGCB(const PL_GCB_enum before, const PL_GCB_enum after)
+ __attribute__warn_unused_result__;
+
+STATIC bool S_isSB(pTHX_ PL_SB_enum before, PL_SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target)
__attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
+#define PERL_ARGS_ASSERT_ISSB \
+ assert(strbeg); assert(curpos); assert(strend)
+
+STATIC bool S_isWB(pTHX_ PL_WB_enum previous, PL_WB_enum before, PL_WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_6);
+#define PERL_ARGS_ASSERT_ISWB \
+ assert(strbeg); assert(curpos); assert(strend)
+
+STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \
assert(rex); assert(scan)
#define PERL_ARGS_ASSERT_REGCPPUSH \
assert(rex)
-STATIC U8* S_reghop3(U8 *s, I32 off, const U8 *lim)
+STATIC U8* S_reghop3(U8 *s, SSize_t off, const U8 *lim)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
__attribute__nonnull__(3);
#define PERL_ARGS_ASSERT_REGHOP3 \
assert(s); assert(lim)
-STATIC U8* S_reghopmaybe3(U8 *s, I32 off, const U8 *lim)
+STATIC U8* S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(3)
+ __attribute__nonnull__(4);
+#define PERL_ARGS_ASSERT_REGHOP4 \
+ assert(s); assert(llim); assert(rlim)
+
+STATIC U8* S_reghopmaybe3(U8 *s, SSize_t off, const U8 *lim)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
__attribute__nonnull__(3);
#define PERL_ARGS_ASSERT_REGHOPMAYBE3 \
assert(s); assert(lim)
-STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, bool const utf8_target)
+STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_REGINCLASS \
- assert(n); assert(p)
+ assert(n); assert(p); assert(p_end)
-STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
+STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_REGMATCH \
assert(reginfo); assert(startpos); assert(prog)
-STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth, bool is_utf8_pat)
+STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \
assert(prog)
-# if defined(XXX_dmq)
-STATIC U8* S_reghop4(U8 *s, I32 off, const U8 *llim, const U8 *rlim)
- __attribute__warn_unused_result__
- __attribute__nonnull__(1)
- __attribute__nonnull__(3)
- __attribute__nonnull__(4);
-#define PERL_ARGS_ASSERT_REGHOP4 \
- assert(s); assert(llim); assert(rlim)
-
-# endif
#endif
#if defined(PERL_IN_SCOPE_C)
STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type);
#define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \
assert(val)
-STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top);
+STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool match, const char **desc_p)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \
+ assert(desc_p)
+
STATIC bool S_glob_2number(pTHX_ GV* const gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GLOB_2NUMBER \
#define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \
assert(dstr); assert(sstr)
-STATIC void S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \
- assert(dstr); assert(sstr)
-
STATIC SV * S_more_sv(pTHX);
STATIC void S_not_a_number(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NOT_A_NUMBER \
assert(sv)
+STATIC void S_not_incrementable(pTHX_ SV *const sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \
+ assert(sv)
+
STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv)
__attribute__warn_unused_result__
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_SV_ADD_ARENA \
assert(ptr)
+STATIC const char * S_sv_display(pTHX_ SV *const sv, char *tmpbuf, STRLEN tmpbuf_size)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_DISPLAY \
+ assert(sv); assert(tmpbuf)
+
STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_FORCE_VERSION \
assert(s)
-STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_tick)
+STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_FORCE_WORD \
assert(start)
#define PERL_ARGS_ASSERT_INCLINE \
assert(s)
-STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv)
+STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INTUIT_METHOD \
assert(s)
assert(s); assert(d); assert(e)
STATIC int S_pending_ident(pTHX);
-STATIC void S_readpipe_override(pTHX);
STATIC char* S_scan_const(pTHX_ char *start)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SCAN_HEREDOC \
assert(s)
-STATIC char* S_scan_ident(pTHX_ char *s, const char *send, char *dest, STRLEN destlen, I32 ck_uni)
+STATIC char* S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SCAN_IDENT \
- assert(s); assert(send); assert(dest)
+ assert(s); assert(dest)
STATIC char* S_scan_inputsymbol(pTHX_ char *start)
__attribute__warn_unused_result__
#define PERL_ARGS_ASSERT_SCAN_PAT \
assert(start)
-STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching)
+STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SCAN_STR \
#define PERL_ARGS_ASSERT_SCAN_WORD \
assert(s); assert(dest); assert(slp)
-STATIC char* S_skipspace(pTHX_ char *s)
+STATIC char* S_skipspace_flags(pTHX_ char *s, U32 flags)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE \
+#define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \
assert(s)
STATIC I32 S_sublex_done(pTHX)
#define PERL_ARGS_ASSERT_YYWARN \
assert(s)
-# if defined(PERL_MAD)
-STATIC void S_curmad(pTHX_ char slot, SV *sv);
-STATIC char* S_skipspace0(pTHX_ char *s)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE0 \
- assert(s)
-
-STATIC char* S_skipspace1(pTHX_ char *s)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE1 \
- assert(s)
-
-STATIC char* S_skipspace2(pTHX_ char *s, SV **sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SKIPSPACE2 \
- assert(s)
-
-STATIC void S_start_force(pTHX_ int where);
-# endif
#endif
#if defined(PERL_IN_UNIVERSAL_C)
STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags)
#define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
assert(p); assert(ustrp); assert(lenp)
-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)
-
-PERL_STATIC_INLINE 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, SV* const invlist)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_IS_UTF8_COMMON \
assert(p); assert(swash); assert(swashname)
+STATIC U8* S_swash_scan_list_line(pTHX_ U8* l, U8* const lend, UV* min, UV* max, UV* val, const bool wants_value, const U8* const typestr)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5)
+ __attribute__nonnull__(pTHX_7);
+#define PERL_ARGS_ASSERT_SWASH_SCAN_LIST_LINE \
+ assert(l); assert(lend); assert(min); assert(max); assert(val); assert(typestr)
+
STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SWATCH_GET \
assert(swash)
-STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp)
+STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp)
__attribute__warn_unused_result__;
#endif
#endif
#if defined(PERL_IN_UTIL_C)
STATIC bool S_ckwarn_common(pTHX_ U32 w);
-STATIC const COP* S_closest_cop(pTHX_ const COP *cop, const OP *o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CLOSEST_COP \
- assert(cop)
-
STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn);
STATIC SV* S_mess_alloc(pTHX);
STATIC SV * S_with_queued_errors(pTHX_ SV *ex)
#define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \
assert(ex)
+STATIC void S_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \
+ assert(xs_p)
+
# 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)
# endif
#endif
-#if defined(PERL_MAD)
-PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot);
-PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot);
-PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \
- assert(file)
-
-PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \
- assert(file)
-
-PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp);
-PERL_CALLCONV int Perl_madlex(pTHX);
-PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype);
-PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen);
-PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_NEWMADSV \
- assert(sv)
-
-PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop);
-PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot);
-PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot);
-PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_OP_XMLDUMP \
- assert(o)
-
-PERL_CALLCONV OP* Perl_package(pTHX_ OP* o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_PACKAGE \
- assert(o)
-
-PERL_CALLCONV void Perl_pad_peg(const char* s)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_PAD_PEG \
- assert(s)
-
-PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm);
-PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot);
-PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLPV \
- assert(dsv); assert(pv)
-
-PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLPVN \
- assert(dsv); assert(pv)
-
-PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_CATXMLSV \
- assert(dsv); assert(ssv)
-
-PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SV_XMLPEEK \
- assert(sv)
-
-PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_TOKEN_FREE \
- assert(tk)
-
-PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_TOKEN_GETMAD \
- assert(tk)
-
-PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_UTILIZE \
- assert(idop)
-
-PERL_CALLCONV void Perl_xmldump_all(pTHX);
-PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl);
-PERL_CALLCONV void Perl_xmldump_eval(pTHX);
-PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_FORM \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
- __attribute__format__(__printf__,pTHX_3,pTHX_4)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_INDENT \
- assert(file); assert(pat)
-
-PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \
- assert(stash)
-
-PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \
- assert(stash)
-
-PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_SUB \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \
- assert(gv)
-
-PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3);
-#define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \
- assert(file); assert(pat)
-
-#endif
#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
#endif
assert(f)
#endif
+#if defined(USE_C_BACKTRACE)
+PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int skip)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \
+ assert(fp)
+
+/* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace* bt)
+ __attribute__nonnull__(pTHX_1); */
+
+PERL_CALLCONV Perl_c_backtrace* Perl_get_c_backtrace(pTHX_ int max_depth, int skip);
+PERL_CALLCONV SV* Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip);
+#endif
#if defined(USE_ITHREADS)
PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv)
__attribute__nonnull__(pTHX_1);
PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
__attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PADLIST_DUP \
- assert(param)
+ assert(srcpad); assert(param)
+
+PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAME_DUP \
+ assert(src); assert(param)
+
+PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PADNAMELIST_DUP \
+ assert(srcpad); assert(param)
PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param)
__attribute__nonnull__(pTHX_2);
assert(param)
#endif
+#if defined(USE_LOCALE) && (defined(PERL_IN_LOCALE_C) || defined (PERL_EXT_POSIX))
+PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category);
+#endif
+#if defined(USE_LOCALE) && defined(PERL_IN_LOCALE_C)
+STATIC char* S_stdize_locale(pTHX_ char* locs)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
+ assert(locs)
+
+#endif
#if defined(USE_LOCALE_COLLATE)
PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
assert(sv); assert(nxp)
#endif
-#if defined(USE_PERLIO) && !defined(USE_SFIO)
+#if defined(USE_PERLIO)
PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f);
PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f);
PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f);
PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f);
PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f);
PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f);
-PERL_CALLCONV int Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
+PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f)
__attribute__warn_unused_result__;
-PERL_CALLCONV int Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
+PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f)
__attribute__warn_unused_result__;
PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f);
#define PERL_ARGS_ASSERT_PERLIO_READ \
assert(vbuf)
+PERL_CALLCONV void Perl_PerlIO_restore_errno(pTHX_ PerlIO *f);
+PERL_CALLCONV void Perl_PerlIO_save_errno(pTHX_ PerlIO *f);
PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence);
-PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt);
-PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, int cnt);
+PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt);
+PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt);
PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f);
PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX)
__attribute__warn_unused_result__;
assert(vbuf)
#endif
+#if defined(USE_QUADMATH)
+PERL_CALLCONV bool Perl_quadmath_format_needed(const char* format)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \
+ assert(format)
+
+PERL_CALLCONV const char* Perl_quadmath_format_single(const char* format)
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_QUADMATH_FORMAT_SINGLE \
+ assert(format)
+
+#endif
#if defined(WIN32)
+PERL_CALLCONV char* Perl_my_setlocale(pTHX_ int category, const char* locale)
+ __attribute__pure__;
+
PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname)
__attribute__noreturn__
__attribute__nonnull__(1);