assert(stash)
PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode);
-PERL_CALLCONV bool Perl__is_utf8__perl_idstart(pTHX_ const U8 *p)
+PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz)
+ __attribute__malloc__
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_FREE \
+ assert(op)
+
+PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c)
+ __attribute__warn_unused_result__;
+
+PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__IS_UTF8__PERL_IDSTART \
+#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \
assert(p)
PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, const U8 flags)
#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)
+ __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)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CK_BITOP \
assert(o)
-PERL_CALLCONV OP * Perl_ck_chdir(pTHX_ OP *o)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CK_CHDIR \
- assert(o)
-
PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
assert(coreargssv)
PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags);
-PERL_CALLCONV void Perl_croak(pTHX_ const char* pat, ...)
+PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...)
__attribute__noreturn__
__attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2);
-PERL_CALLCONV void Perl_croak_no_modify(pTHX)
+PERL_STATIC_NO_RET void S_croak_memory_wrap(void)
__attribute__noreturn__;
-PERL_CALLCONV void Perl_croak_sv(pTHX_ SV *baseex)
+PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void)
+ __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void)
+ __attribute__noreturn__;
+
+PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_CROAK_SV \
assert(baseex)
-PERL_CALLCONV void Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params)
+PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *const params)
__attribute__noreturn__
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
+ __attribute__nonnull__(1)
+ __attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE \
assert(cv); assert(params)
#define PERL_ARGS_ASSERT_CV_CLONE \
assert(proto)
+PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CV_CLONE_INTO \
+ assert(proto); assert(target)
+
PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
__attribute__warn_unused_result__;
+PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_CV_FORGET_SLAB \
+ assert(cv)
+
PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_DIE_SV \
assert(baseex)
-PERL_CALLCONV void Perl_die_unwind(pTHX_ SV* msv)
+PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DIE_UNWIND \
PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp)
__attribute__warn_unused_result__;
+PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp)
+ __attribute__warn_unused_result__;
+
PERL_CALLCONV SV* Perl_find_rundefsv(pTHX);
PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GET_DB_SUB \
assert(cv)
-PERL_CALLCONV UV Perl_get_hash_seed(pTHX)
- __attribute__warn_unused_result__;
+PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char *seed_buffer)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_HASH_SEED \
+ assert(seed_buffer)
PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \
assert(argv)
+PERL_CALLCONV void Perl_init_constants(pTHX);
PERL_CALLCONV void Perl_init_dbargs(pTHX);
PERL_CALLCONV void Perl_init_debugger(pTHX);
PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn);
__attribute__warn_unused_result__
__attribute__pure__;
+PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c)
+ __attribute__warn_unused_result__
+ __attribute__pure__;
+
PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c)
__attribute__warn_unused_result__
__attribute__pure__;
__attribute__warn_unused_result__
__attribute__pure__;
-PERL_CALLCONV bool Perl_is_utf8_X_L(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_L \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_LV(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LV \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_LVT(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_T(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_T \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_V(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_V \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_begin(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_extend(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL \
- assert(p)
-
-PERL_CALLCONV bool Perl_is_utf8_X_prepend(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND \
- assert(p)
-
PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_IS_UTF8_ASCII \
assert(p)
+PERL_CALLCONV bool Perl_is_utf8_blank(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_BLANK \
+ assert(p)
+
PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s)
__attribute__deprecated__
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \
assert(sv); assert(mg)
+PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \
+ assert(sv); assert(mg)
+
PERL_CALLCONV int Perl_magic_clearenv(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 U32 Perl_magic_len(pTHX_ SV* sv, MAGIC* mg)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_LEN \
- assert(sv); assert(mg)
-
PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags, U32 argc, ...)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \
assert(sv); assert(mg)
-PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
+PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MAGIC_SETVEC \
assert(sv); assert(mg)
-PERL_CALLCONV int Perl_magic_setvstring(pTHX_ SV* sv, MAGIC* mg)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_MAGIC_SETVSTRING \
- assert(sv); assert(mg)
-
PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
assert(sv)
PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv)
+ __attribute__deprecated__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MG_LENGTH \
assert(sv)
PERL_CALLCONV void Perl_my_clearenv(pTHX);
PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir);
-PERL_CALLCONV void Perl_my_exit(pTHX_ U32 status)
+PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status)
__attribute__noreturn__;
-PERL_CALLCONV void Perl_my_failure_exit(pTHX)
+PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX)
__attribute__noreturn__;
PERL_CALLCONV I32 Perl_my_fflush_all(pTHX);
__attribute__malloc__
__attribute__warn_unused_result__;
+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 \
+ assert(o)
+
PERL_CALLCONV OP* Perl_newNULLLIST(pTHX)
__attribute__malloc__
__attribute__warn_unused_result__;
__attribute__malloc__
__attribute__warn_unused_result__;
+PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_NEWSTUB \
+ assert(gv)
+
/* PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */
PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len)
__attribute__malloc__
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_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)
__attribute__nonnull__(pTHX_2)
assert(padlist); assert(old_cv); assert(new_cv)
PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po);
-PERL_CALLCONV void Perl_pad_leavemy(pTHX);
+PERL_CALLCONV OP * Perl_pad_leavemy(pTHX);
PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags)
__attribute__malloc__
__attribute__warn_unused_result__;
PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust);
PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type);
+PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_PADLIST_STORE \
+ assert(padlist)
+
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);
#define PERL_ARGS_ASSERT_RE_INTUIT_STRING \
assert(r)
-PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *VOL old_re, int *is_bare_re, U32 rx_flags, U32 pm_flags)
+PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *VOL old_re, bool *is_bare_re, U32 rx_flags, U32 pm_flags)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_RE_OP_COMPILE \
assert(eng)
#define PERL_ARGS_ASSERT_REGDUMP \
assert(r)
-PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* 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)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
-PERL_CALLCONV OP* Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
- __attribute__deprecated__
+/* PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_SV_COMPILE_2OP \
- assert(sv); assert(startop); assert(code); assert(padp)
-
-PERL_CALLCONV OP* Perl_sv_compile_2op_is_broken(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_SV_COMPILE_2OP_IS_BROKEN \
- assert(sv); assert(startop); assert(code); assert(padp)
+ __attribute__nonnull__(pTHX_2); */
+#define PERL_ARGS_ASSERT_SV_COPYPV \
+ assert(dsv); assert(ssv)
-PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
+PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_COPYPV \
+#define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \
assert(dsv); assert(ssv)
+/* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2); */
+
PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv);
PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv);
PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv)
assert(sv)
PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv);
-PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv)
+PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_FREE2 \
assert(sv)
#define PERL_ARGS_ASSERT_SV_GETS \
assert(sv); assert(fp)
-PERL_CALLCONV bool Perl_sv_gmagical_2iv_please(pTHX_ SV *sv)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SV_GMAGICAL_2IV_PLEASE \
- assert(sv)
-
PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_GROW \
PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv);
PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv);
+PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \
+ assert(sv)
+
PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_MAGIC \
#define PERL_ARGS_ASSERT_SV_MAGICEXT \
assert(sv)
-PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
+/* PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
+ __attribute__malloc__
+ __attribute__warn_unused_result__; */
+
+PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags)
__attribute__malloc__
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_SV_RESET \
assert(s)
+PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash);
PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_RVWEAKEN \
#define PERL_ARGS_ASSERT_SV_VCATPVFN \
assert(sv); assert(pat)
+PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \
+ assert(sv); assert(pat)
+
PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#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__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \
#define PERL_ARGS_ASSERT_VCMP \
assert(lhv); assert(rhv)
-PERL_CALLCONV void Perl_vcroak(pTHX_ const char* pat, va_list* args)
+PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args)
__attribute__noreturn__;
PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args)
#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);
#endif
#if !(defined(PERL_MAD))
PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block);
-PERL_CALLCONV void Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
- __attribute__noreturn__;
-
PERL_CALLCONV void Perl_package(pTHX_ OP* o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PACKAGE \
assert(idop)
#endif
-#if !(defined(USE_ITHREADS))
-# if defined(PERL_IN_OP_C)
-STATIC void S_forget_pmop(pTHX_ PMOP *const o)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP \
- assert(o)
-
-# endif
-#endif
#if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len)
__attribute__nonnull__(1);
#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)
#endif
#if defined(MYSWAP)
PERL_CALLCONV long Perl_my_htonl(pTHX_ long l)
- __attribute__malloc__
__attribute__warn_unused_result__
__attribute__pure__;
PERL_CALLCONV long Perl_my_ntohl(pTHX_ long l)
- __attribute__malloc__
__attribute__warn_unused_result__
__attribute__pure__;
PERL_CALLCONV short Perl_my_swap(pTHX_ short s)
- __attribute__malloc__
__attribute__warn_unused_result__
__attribute__pure__;
#if defined(NO_MATHOMS)
/* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */
#endif
+#if defined(PERL_ANY_COW)
+PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_SV_SETSV_COW \
+ assert(sstr)
+
+#endif
+#if defined(PERL_CORE)
+PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \
+ assert(slab)
+
+PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FREE \
+ assert(slab)
+
+PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \
+ assert(slab)
+
+PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \
+ assert(parser); assert(slab)
+
+# if defined(PERL_DEBUG_READONLY_OPS)
+PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_TO_RO \
+ assert(slab)
+
+PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SLAB_TO_RW \
+ assert(slab)
+
+# endif
+#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_OPS)
-# if defined(PERL_IN_OP_C)
-# if defined(PL_OP_SLAB_ALLOC)
-STATIC void S_Slab_to_rw(pTHX_ void *op)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SLAB_TO_RW \
- assert(op)
-
-# endif
-# endif
-# if defined(PL_OP_SLAB_ALLOC)
PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_OP_REFCNT_DEC \
assert(o)
PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o);
-PERL_CALLCONV void Perl_pending_Slabs_to_ro(pTHX);
-# endif
#endif
#if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)
/* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd)
# endif
#endif
#if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...)
+PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...)
__attribute__noreturn__
__attribute__format__null_ok__(__printf__,1,2);
assert(sv)
#endif
-#if defined(PERL_IN_DQUOTE_STATIC_C)
-STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
- __attribute__warn_unused_result__;
-
-STATIC bool S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_3)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
- assert(s); assert(uv); assert(len); assert(error_msg)
-
-PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s)
- __attribute__warn_unused_result__
- __attribute__pure__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_REGCURLY \
- assert(s)
-
-#endif
#if defined(PERL_IN_DUMP_C)
STATIC CV* S_deb_curcv(pTHX_ const I32 ix);
STATIC void S_debprof(pTHX_ const OP *o)
#endif
#if defined(PERL_IN_GV_C)
-STATIC HV* S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen, U32 flags)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GV_GET_SUPER_PKG \
- assert(name)
-
STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \
#define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \
assert(hv); assert(needs_copy); assert(needs_store)
-STATIC void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
+PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg)
__attribute__noreturn__
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_4);
#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, bool for_my)
+STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_APPLY_ATTRS \
assert(o)
STATIC OP* S_force_list(pTHX_ OP* arg);
+STATIC void S_forget_pmop(pTHX_ PMOP *const o)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_FORGET_PMOP \
+ assert(o)
+
STATIC OP* S_gen_constant_list(pTHX_ OP* o);
STATIC SV* S_gv_ename(pTHX_ GV *gv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_OP_STD_INIT \
assert(o)
-STATIC OP* S_opt_scalarhv(pTHX_ OP* rep_op)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_OPT_SCALARHV \
- assert(rep_op)
-
STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#define PERL_ARGS_ASSERT_PMTRANS \
assert(o); assert(expr); assert(repl)
-STATIC void S_process_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv)
- __attribute__nonnull__(pTHX_1)
+STATIC void 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_3)
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \
assert(fullname); assert(gv); assert(cv)
#define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \
assert(o); assert(namesv)
-# if defined(USE_ITHREADS)
-STATIC void S_forget_pmop(pTHX_ PMOP *const o, U32 flags)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_FORGET_PMOP \
- assert(o)
-
-# endif
#endif
#if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C)
PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp)
#define PERL_ARGS_ASSERT_MAYBERELOCATE \
assert(dir)
-STATIC void S_minus_v(pTHX)
+PERL_STATIC_NO_RET void S_minus_v(pTHX)
__attribute__noreturn__;
-STATIC void S_my_exit_jump(pTHX)
+PERL_STATIC_NO_RET void S_my_exit_jump(pTHX)
__attribute__noreturn__;
STATIC void S_nuke_stacks(pTHX);
assert(scriptname); assert(suidscript)
STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit);
-STATIC void S_run_body(pTHX_ I32 oldscope)
+PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope)
__attribute__noreturn__;
-STATIC void S_usage(pTHX)
+PERL_STATIC_NO_RET void S_usage(pTHX)
__attribute__noreturn__;
#endif
STATIC OP* S_docatch(pTHX_ OP *o)
__attribute__warn_unused_result__;
-STATIC bool S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq, HV* hh);
+STATIC bool S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh);
STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \
assert(list)
-STATIC void S_add_alternate(pTHX_ AV** alternate_ptr, U8* string, STRLEN len)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_ADD_ALTERNATE \
- assert(alternate_ptr); assert(string)
-
PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_ADD_DATA \
assert(pRExC_state); assert(s)
-STATIC void S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_CHECKPOSIXCC \
- assert(pRExC_state)
+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)
+ __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)
#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)
+
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 UV* S_get_invlist_len_addr(pTHX_ SV* 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_LEN_ADDR \
+#define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \
assert(invlist)
PERL_STATIC_INLINE UV* S_get_invlist_version_id_addr(pTHX_ SV* invlist)
#define PERL_ARGS_ASSERT_GET_INVLIST_ZERO_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)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
+ assert(pRExC_state); assert(flagp)
+
PERL_STATIC_INLINE UV* S_invlist_array(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)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \
+ assert(invlist)
+
PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_ITERINIT \
#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \
assert(invlist); assert(start); assert(end)
-PERL_STATIC_INLINE UV S_invlist_len(pTHX_ SV* const invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_INVLIST_LEN \
- assert(invlist)
-
PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INVLIST_MAX \
assert(invlist)
-STATIC IV S_invlist_search(pTHX_ SV* const invlist, const UV cp)
+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_SEARCH \
+#define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \
assert(invlist)
PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len)
#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 \
#define PERL_ARGS_ASSERT_NEXTCHAR \
assert(pRExC_state)
-STATIC void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
+PERL_STATIC_NO_RET void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)
__attribute__noreturn__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REG \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp, U32 depth)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_REG_NAMEDSEQ \
- assert(pRExC_state)
-
STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REG_NODE \
#define PERL_ARGS_ASSERT_REGBRANCH \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, U32 depth)
- __attribute__nonnull__(pTHX_1);
+STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGCLASS \
- assert(pRExC_state)
+ assert(pRExC_state); assert(flagp)
STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth)
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_REGPIECE \
assert(pRExC_state); assert(flagp)
-STATIC I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, SV *free_me)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGPPOSIXCC \
assert(pRExC_state)
#define PERL_ARGS_ASSERT_SCAN_COMMIT \
assert(pRExC_state); assert(data); assert(minlenp)
-PERL_STATIC_INLINE U8 S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT \
- assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
-
-STATIC U8 S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, SV** invlist_ptr, AV** alternate_ptr)
- __attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4)
- __attribute__nonnull__(pTHX_5);
-#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \
- assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
-
STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C)
-PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, bool return_if_undef, SV* invlist, bool passed_in_invlist_has_user_defined_property)
+PERL_STATIC_INLINE UV* S__get_invlist_len_addr(pTHX_ SV* invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__GET_INVLIST_LEN_ADDR \
+ assert(invlist)
+
+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)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \
+ assert(invlist)
+
+PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \
+ assert(invlist)
+
+PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_LEN \
+ assert(invlist)
+
+PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__INVLIST_SEARCH \
+ assert(invlist)
+
+PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
+ assert(swash)
+
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C)
+PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT__CORE_SWASH_INIT \
assert(pkg); assert(name); assert(listsv)
-PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist)
+#endif
+#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C)
+STATIC char S_grok_bslash_c(pTHX_ const char source, const bool utf8, const bool output_warning)
+ __attribute__warn_unused_result__;
+
+STATIC bool S_grok_bslash_o(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
__attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_O \
+ assert(s); assert(uv); assert(len); assert(error_msg)
+
+PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ const char* s, UV* uv, STRLEN* len, const char** error_msg, const bool output_warning)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_GROK_BSLASH_X \
+ assert(s); assert(uv); assert(len); assert(error_msg)
+
+PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s)
+ __attribute__warn_unused_result__
+ __attribute__pure__
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__INVLIST_CONTENTS \
- assert(invlist)
+#define PERL_ARGS_ASSERT_REGCURLY \
+ assert(s)
#endif
#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C)
PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size)
__attribute__warn_unused_result__;
-PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \
- assert(swash)
-
PERL_CALLCONV 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, SV **altsvp)
+STATIC SV* S_core_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \
#define PERL_ARGS_ASSERT_FIND_BYCLASS \
assert(prog); assert(c); assert(s); assert(strend)
+PERL_STATIC_INLINE bool S_is_utf8_X_LVT(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \
+ assert(p)
+
STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
#define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \
assert(rex); assert(scan)
-STATIC char* S_regcppop(pTHX_ const regexp *rex)
+STATIC void S_regcppop(pTHX_ regexp *rex)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGCPPOP \
assert(rex)
-STATIC CHECKPOINT S_regcppush(pTHX_ I32 parenfloor);
+STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_REGCPPUSH \
+ assert(rex)
+
STATIC U8* S_reghop3(U8 *s, I32 off, const U8 *lim)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
#define PERL_ARGS_ASSERT_REGHOPMAYBE3 \
assert(s); assert(lim)
-STATIC bool S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, STRLEN *lenp, bool const do_utf8sv_is_utf8)
+STATIC bool S_reginclass(pTHX_ const regexp * const prog, const regnode * const n, const U8 * const p, bool const utf8_target)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGINCLASS \
assert(n); assert(p)
-STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog)
+STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGMATCH \
- assert(reginfo); assert(prog)
+ assert(reginfo); assert(startpos); assert(prog)
-STATIC I32 S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth)
+STATIC I32 S_regrepeat(pTHX_ const regexp *prog, char **startposp, const regnode *p, I32 max, int depth)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2);
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_REGREPEAT \
- assert(prog); assert(p)
+ assert(prog); assert(startposp); assert(p)
-STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startpos)
+STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_REGTRY \
- assert(reginfo); assert(startpos)
+ assert(reginfo); assert(startposp)
-STATIC void S_to_byte_substr(pTHX_ regexp * prog)
+STATIC bool S_to_byte_substr(pTHX_ regexp * prog)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \
assert(prog)
#define PERL_ARGS_ASSERT_FORCE_IDENT \
assert(s)
+STATIC void S_force_ident_maybe_lex(pTHX_ char pit);
STATIC void S_force_next(pTHX_ I32 type);
STATIC char* S_force_strict_version(pTHX_ char *s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_FORCE_WORD \
assert(start)
+PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \
+ assert(s); assert(e)
+
STATIC void S_incline(pTHX_ const char *s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_INCLINE \
#define PERL_ARGS_ASSERT_LOP \
assert(s)
-STATIC void S_missingterm(pTHX_ char *s)
+PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s)
__attribute__noreturn__;
STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen)
#define PERL_ARGS_ASSERT_NO_OP \
assert(what)
+STATIC int S_pending_ident(pTHX);
STATIC void S_readpipe_override(pTHX);
STATIC char* S_scan_const(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)
+STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SCAN_STR \
#define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \
assert(p); assert(ustrp); assert(lenp)
-STATIC STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len)
+PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len)
__attribute__warn_unused_result__
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \
assert(s)
-STATIC bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
+PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
#endif
#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C)
-PERL_CALLCONV bool Perl__is_utf8_quotemeta(pTHX_ const U8 *p)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__IS_UTF8_QUOTEMETA \
- assert(p)
-
PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \
assert(p); assert(lenp)
+PERL_CALLCONV bool Perl_is_utf8_X_extend(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND \
+ assert(p)
+
+PERL_CALLCONV bool Perl_is_utf8_X_regular_begin(pTHX_ const U8 *p)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_IS_UTF8_X_REGULAR_BEGIN \
+ assert(p)
+
#endif
#if defined(PERL_IN_UTIL_C)
STATIC bool S_ckwarn_common(pTHX_ U32 w);
#define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \
assert(ex)
-STATIC char * S_write_no_mem(pTHX)
- __attribute__noreturn__;
-
# if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL)
STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname)
__attribute__nonnull__(4)
#define PERL_ARGS_ASSERT_NEWMADSV \
assert(sv)
-PERL_CALLCONV OP * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block)
- __attribute__noreturn__;
-
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);
#if defined(PERL_NEED_MY_LETOHS)
PERL_CALLCONV short Perl_my_letohs(short n);
#endif
-#if defined(PERL_OLD_COPY_ON_WRITE)
-PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr)
- __attribute__nonnull__(pTHX_2);
-#define PERL_ARGS_ASSERT_SV_SETSV_COW \
- assert(sstr)
-
-#endif
#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
#endif
-#if defined(PL_OP_SLAB_ALLOC)
-PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz)
- __attribute__malloc__
- __attribute__warn_unused_result__;
-
-PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op)
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_SLAB_FREE \
- assert(op)
-
-#endif
#if defined(UNLINK_ALL_VERSIONS)
PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEWPADOP \
assert(sv)
-PERL_CALLCONV AV* Perl_padlist_dup(pTHX_ AV *srcpad, CLONE_PARAMS *param)
+PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PADLIST_DUP \
assert(vbuf)
#endif
+#if defined(WIN32)
+PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname)
+ __attribute__noreturn__
+ __attribute__nonnull__(1);
+#define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \
+ assert(fname)
+
+#endif
#if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS)
PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp)
__attribute__nonnull__(pTHX_2)
https://perl5.git.perl.org / perl5.git / blobdiff