#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 SSize_t Perl_av_tindex(pTHX_ AV *av)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1); */
+
+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 \
+ assert(av)
+
PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av)
__attribute__nonnull__(pTHX_1);
#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)
PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
__attribute__warn_unused_result__;
+PERL_CALLCONV SV* Perl_cv_const_sv_or_av(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 \
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)
#define PERL_ARGS_ASSERT_FINALIZE_OPTREE \
assert(o)
+PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off);
PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_GET_DB_SUB \
assert(cv)
-PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char *seed_buffer)
+PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GET_HASH_SEED \
assert(seed_buffer)
#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_HV_FETCH_ENT \
assert(keysv)
-PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV const *const hv)
+PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HV_FILL \
assert(hv)
-PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entryK)
+PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HV_FREE_ENT \
assert(hv)
#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 \
#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \
assert(hv)
+PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_HV_RAND_SET \
+ assert(hv)
+
PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#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);
PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type)
__attribute__warn_unused_result__;
+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(pTHX_ const SV* sv, int type, const MGVTBL *vtbl)
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_MY_STRFTIME \
assert(fmt)
-PERL_CALLCONV void Perl_my_swabn(void* ptr, int n)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_MY_SWABN \
- assert(ptr)
-
PERL_CALLCONV void Perl_my_unexec(pTHX);
PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap)
__attribute__nonnull__(1)
#define PERL_ARGS_ASSERT_OP_CLEAR \
assert(o)
-PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
+PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o)
__attribute__warn_unused_result__;
PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context)
#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)
#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_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, bool *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 *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 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)
#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 \
#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_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 \
#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_NV \
assert(sv)
+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)
+
PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv);
PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_POS_B2U \
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_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 void Perl_tmps_grow(pTHX_ SSize_t n);
/* 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_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_PUT_BYTE \
assert(sv)
+STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \
+ assert(sv); assert(bitmap)
+
STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
+STATIC void S_regdump_intflags(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)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
assert(p)
#endif
-#if defined(MYSWAP)
-PERL_CALLCONV long Perl_my_htonl(pTHX_ long l)
- __attribute__warn_unused_result__
- __attribute__pure__;
-
-PERL_CALLCONV long Perl_my_ntohl(pTHX_ long l)
- __attribute__warn_unused_result__
- __attribute__pure__;
-
-PERL_CALLCONV short Perl_my_swap(pTHX_ short s)
- __attribute__warn_unused_result__
- __attribute__pure__;
-
-#endif
#if defined(NO_MATHOMS)
/* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */
#endif
#define PERL_ARGS_ASSERT_HFREEENTRIES \
assert(hv)
-STATIC void S_hsplit(pTHX_ HV *hv)
+STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HSPLIT \
assert(hv)
-STATIC struct xpvhv_aux* S_hv_auxinit(HV *hv)
- __attribute__nonnull__(1);
+STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv)
+ __attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HV_AUXINIT \
assert(hv)
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 *entryK)
- __attribute__nonnull__(pTHX_1);
+STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \
- assert(hv)
+ assert(hv); assert(entry)
STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store)
__attribute__nonnull__(1)
__attribute__malloc__
__attribute__warn_unused_result__;
+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)
+#if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE)
+STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category);
STATIC char* S_stdize_locale(pTHX_ char* locs)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_STDIZE_LOCALE \
assert(locs)
-# endif
+#endif
+#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
#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 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);
#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 void S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid)
__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)
+#define PERL_ARGS_ASSERT_BAD_TYPE_GV \
+ assert(t); assert(gv); assert(kid)
-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 char *name, U32 flags, 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)
+#define PERL_ARGS_ASSERT_BAD_TYPE_PV \
+ assert(t); assert(name); assert(kid)
STATIC void S_cop_free(pTHX_ COP *cop)
__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)
#endif
#if defined(PERL_IN_PP_PACK_C)
-STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest)
+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__INVLIST_ARRAY_INIT \
assert(invlist)
-STATIC SV* S__new_invlist_C_array(pTHX_ UV* list)
+STATIC SV* S__new_invlist_C_array(pTHX_ const UV* const list)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \
#define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \
assert(pRExC_state)
-STATIC bool S_could_it_be_POSIX(pTHX_ struct RExC_state_t *pRExC_state)
+STATIC bool S_could_it_be_a_POSIX_class(pTHX_ struct RExC_state_t *pRExC_state)
__attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_COULD_IT_BE_POSIX \
+#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)
+PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(pTHX_ SV* invlist)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_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)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT_GET_INVLIST_VERSION_ID_ADDR \
- assert(invlist)
-
-PERL_STATIC_INLINE UV* S_get_invlist_zero_addr(pTHX_ SV* invlist)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#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, const bool strict)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_GROK_BSLASH_N \
assert(pRExC_state); assert(flagp)
-STATIC regnode* S_handle_sets(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth, char * const oregcomp_parse)
+STATIC regnode* S_handle_regex_sets(pTHX_ struct RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4);
-#define PERL_ARGS_ASSERT_HANDLE_SETS \
+ __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)
#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)
#define PERL_ARGS_ASSERT_NEXTCHAR \
assert(pRExC_state)
+STATIC void S_parse_lparen_question_flags(pTHX_ struct 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__
__attribute__nonnull__(pTHX_1)
#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, SV *free_me, const bool strict)
+PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value, const bool strict)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_REGPPOSIXCC \
assert(pRExC_state)
#define PERL_ARGS_ASSERT_REGWHITE \
assert(pRExC_state); assert(p)
-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_scan_commit(pTHX_ const struct 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_SCAN_COMMIT \
assert(pRExC_state); assert(data); assert(minlenp)
-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_ struct RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *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)
__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)
- __attribute__warn_unused_result__
- __attribute__nonnull__(pTHX_1);
-#define PERL_ARGS_ASSERT__GET_INVLIST_LEN_ADDR \
- assert(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_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__SWASH_INVERSION_HASH \
assert(swash)
+PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(pTHX_ SV* invlist)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \
+ 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)
__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 \
__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 \
#define PERL_ARGS_ASSERT_CORE_REGCLASS_SWASH \
assert(node)
-STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo, bool is_utf_pat)
+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_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_reghopmaybe3(U8 *s, SSize_t off, const U8 *lim)
__attribute__warn_unused_result__
__attribute__nonnull__(1)
__attribute__nonnull__(3);
#define PERL_ARGS_ASSERT_REGINCLASS \
assert(n); assert(p)
-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, 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)
- __attribute__nonnull__(pTHX_3);
+ __attribute__nonnull__(pTHX_3)
+ __attribute__nonnull__(pTHX_4);
#define PERL_ARGS_ASSERT_REGREPEAT \
- assert(prog); assert(startposp); assert(p)
+ assert(prog); assert(startposp); assert(p); assert(reginfo)
STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp)
__attribute__warn_unused_result__
assert(prog)
# if defined(XXX_dmq)
-STATIC U8* S_reghop4(U8 *s, I32 off, const U8 *llim, const U8 *rlim)
+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)
#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_NO_OP \
assert(what)
+STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_3);
+#define PERL_ARGS_ASSERT_PARSE_IDENT \
+ 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)
#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)
#endif
#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const bool flags)
+PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \
assert(file); assert(pat)
#endif
-#if defined(PERL_NEED_MY_BETOH16)
-PERL_CALLCONV U16 Perl_my_betoh16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_BETOH32)
-PERL_CALLCONV U32 Perl_my_betoh32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_BETOH64)
-PERL_CALLCONV U64 Perl_my_betoh64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_BETOHI)
-PERL_CALLCONV int Perl_my_betohi(int n);
-#endif
-#if defined(PERL_NEED_MY_BETOHL)
-PERL_CALLCONV long Perl_my_betohl(long n);
-#endif
-#if defined(PERL_NEED_MY_BETOHS)
-PERL_CALLCONV short Perl_my_betohs(short n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE16)
-PERL_CALLCONV U16 Perl_my_htobe16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE32)
-PERL_CALLCONV U32 Perl_my_htobe32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBE64)
-PERL_CALLCONV U64 Perl_my_htobe64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_HTOBEI)
-PERL_CALLCONV int Perl_my_htobei(int n);
-#endif
-#if defined(PERL_NEED_MY_HTOBEL)
-PERL_CALLCONV long Perl_my_htobel(long n);
-#endif
-#if defined(PERL_NEED_MY_HTOBES)
-PERL_CALLCONV short Perl_my_htobes(short n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE16)
-PERL_CALLCONV U16 Perl_my_htole16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE32)
-PERL_CALLCONV U32 Perl_my_htole32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLE64)
-PERL_CALLCONV U64 Perl_my_htole64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_HTOLEI)
-PERL_CALLCONV int Perl_my_htolei(int n);
-#endif
-#if defined(PERL_NEED_MY_HTOLEL)
-PERL_CALLCONV long Perl_my_htolel(long n);
-#endif
-#if defined(PERL_NEED_MY_HTOLES)
-PERL_CALLCONV short Perl_my_htoles(short n);
-#endif
-#if defined(PERL_NEED_MY_LETOH16)
-PERL_CALLCONV U16 Perl_my_letoh16(U16 n);
-#endif
-#if defined(PERL_NEED_MY_LETOH32)
-PERL_CALLCONV U32 Perl_my_letoh32(U32 n);
-#endif
-#if defined(PERL_NEED_MY_LETOH64)
-PERL_CALLCONV U64 Perl_my_letoh64(U64 n);
-#endif
-#if defined(PERL_NEED_MY_LETOHI)
-PERL_CALLCONV int Perl_my_letohi(int n);
-#endif
-#if defined(PERL_NEED_MY_LETOHL)
-PERL_CALLCONV long Perl_my_letohl(long n);
-#endif
-#if defined(PERL_NEED_MY_LETOHS)
-PERL_CALLCONV short Perl_my_letohs(short n);
-#endif
#if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C)
STATIC void S_pidgone(pTHX_ Pid_t pid, int status);
#endif
https://perl5.git.perl.org / perl5.git / blobdiff