* proto.h
*
* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, by Larry Wall and others
+ * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, by Larry Wall and others
*
* You may distribute under the terms of either the GNU General Public
* License or the Artistic License, as specified in the README file.
#define PERL_ARGS_ASSERT_AV_FILL \
assert(av)
-PERL_CALLCONV I32 Perl_av_len(pTHX_ const AV *av)
+PERL_CALLCONV I32 Perl_av_len(pTHX_ AV *av)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_AV_LEN \
PERL_CALLCONV void Perl_vcroak(pTHX_ const char* pat, va_list* args)
__attribute__noreturn__;
+PERL_CALLCONV void Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params)
+ __attribute__noreturn__
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_CROAK_XS_USAGE \
+ assert(cv); assert(params)
+
+
#if defined(PERL_IMPLICIT_CONTEXT)
PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...)
__attribute__noreturn__
- __attribute__format__(__printf__,1,2)
- __attribute__nonnull__(1);
-#define PERL_ARGS_ASSERT_CROAK_NOCONTEXT \
- assert(pat)
+ __attribute__format__null_ok__(__printf__,1,2);
PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...)
__attribute__format__(__printf__,1,2)
#define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \
assert(pat)
-PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char* pat, ...)
+PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...)
__attribute__format__(__printf__,1,2)
__attribute__nonnull__(1);
#define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \
assert(pat)
-PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,2,3)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,2,3)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,2,3)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,2,3)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_GV_CONST_SV \
assert(gv)
-PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ CV* cv)
+PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv)
__attribute__warn_unused_result__;
PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv)
assert(name)
/* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name)
+ __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2); */
#define PERL_ARGS_ASSERT_GV_FETCHMETHOD \
- assert(name)
+ assert(stash); assert(name)
PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload)
+ __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \
- assert(name)
+ assert(stash); assert(name)
+
+PERL_CALLCONV GV* Perl_gv_fetchmethod_flags(pTHX_ HV* stash, const char* name, U32 flags)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_GV_FETCHMETHOD_FLAGS \
+ assert(stash); assert(name)
PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type)
__attribute__nonnull__(pTHX_1);
PERL_CALLCONV SV * Perl_refcounted_he_fetch(pTHX_ const struct refcounted_he *chain, SV *keysv, const char *key, STRLEN klen, int flags, U32 hash);
PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he);
PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new(pTHX_ struct refcounted_he *const parent, SV *const key, SV *const value);
+#if defined(PERL_IN_HV_C) || defined(PERL_DECL_PROT)
+STATIC struct refcounted_he * S_refcounted_he_new_common(pTHX_ struct refcounted_he *const parent, const char *const key_p, const STRLEN key_len, const char flags, char value_type, const void *value, const STRLEN value_len)
+ __attribute__nonnull__(pTHX_2)
+ __attribute__nonnull__(pTHX_6);
+#define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_COMMON \
+ assert(key_p); assert(value)
+
+#endif
/* PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */
/* PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */
/* PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */
assert(ptm)
PERL_CALLCONV OP* Perl_mod(pTHX_ OP* o, I32 type);
-PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ SV* discp);
+PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len);
PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_MORESWITCHES \
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newRV(pTHX_ SV* sv)
+PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEWRV \
assert(sv)
-PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV* sv)
+PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEWRV_NOINC \
assert(sv)
-PERL_CALLCONV SV* Perl_newSV(pTHX_ STRLEN len)
+PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len)
__attribute__malloc__
__attribute__warn_unused_result__;
#define PERL_ARGS_ASSERT_NEWSVOP \
assert(sv)
-PERL_CALLCONV SV* Perl_newSViv(pTHX_ IV i)
+PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVuv(pTHX_ UV u)
+PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVnv(pTHX_ NV n)
+PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char* s, STRLEN len)
+PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char* s, STRLEN len)
+PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char* s, STRLEN len, U32 flags)
+PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *hek)
+PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek)
__attribute__malloc__
__attribute__warn_unused_result__;
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char* pat, ...)
+PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__format__(__printf__,pTHX_1,pTHX_2)
#define PERL_ARGS_ASSERT_NEWSVPVF \
assert(pat)
-PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char* pat, va_list* args)
+PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args)
__attribute__malloc__
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_VNEWSVPVF \
assert(pat)
-PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV* rv, const char* classname)
+PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_NEWSVRV \
assert(rv)
-PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV* old)
+PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old)
__attribute__malloc__
__attribute__warn_unused_result__;
assert(r); assert(param)
#endif
-PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ const SV * const pattern, const U32 flags)
+PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PREGCOMP \
assert(pattern)
-PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ const SV * const pattern, U32 flags)
+PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_RE_COMPILE \
assert(pattern)
#define PERL_ARGS_ASSERT_SV_2BOOL \
assert(sv)
-PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV** st, GV** gvp, I32 lref)
+PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const I32 lref)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_SV_2CV \
assert(st); assert(gvp)
-PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV* sv)
+PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_2IO \
assert(sv)
#endif
/* 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* sv);
+PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv);
PERL_CALLCONV NV Perl_sv_2nv(pTHX_ SV *const sv);
PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_PVBYTEN \
assert(sv); assert(lp)
-PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *sv);
+PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv);
PERL_CALLCONV void Perl_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_ADD_ARENA \
#define PERL_ARGS_ASSERT_SV_BACKOFF \
assert(sv)
-PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV* sv, HV* stash)
+PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV *const sv, HV *const stash)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_BLESS \
assert(sv); assert(stash)
-PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,pTHX_2,pTHX_3)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_CATPVF \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV* sv, const char* pat, va_list* args)
+PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_VCATPVF \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV* sv, const char* ptr)
+PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_CATPV \
assert(sv)
PERL_CALLCONV I32 Perl_sv_clean_all(pTHX);
PERL_CALLCONV void Perl_sv_clean_objs(pTHX);
-PERL_CALLCONV void Perl_sv_clear(pTHX_ SV* sv)
+PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_CLEAR \
assert(sv)
-PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV* sv1, SV* sv2);
-PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV* sv1, SV* sv2);
+PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2);
+PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
#if defined(USE_LOCALE_COLLATE)
-PERL_CALLCONV char* Perl_sv_collxfrm(pTHX_ SV* sv, STRLEN* nxp)
+PERL_CALLCONV char* Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_COLLXFRM \
#define PERL_ARGS_ASSERT_GETCWD_SV \
assert(sv)
-PERL_CALLCONV void Perl_sv_dec(pTHX_ SV* sv);
+PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv);
PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_DUMP \
assert(sv); assert(name)
PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV* sv1, SV* sv2);
-PERL_CALLCONV void Perl_sv_free(pTHX_ SV* sv);
-PERL_CALLCONV void Perl_sv_free2(pTHX_ SV* sv)
+PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv);
+PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_FREE2 \
assert(sv)
PERL_CALLCONV void Perl_sv_free_arenas(pTHX);
-PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV* sv, PerlIO* fp, I32 append)
+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_GETS \
#define PERL_ARGS_ASSERT_SV_GROW \
assert(sv)
-PERL_CALLCONV void Perl_sv_inc(pTHX_ SV* sv);
-PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *bigstr, STRLEN offset, STRLEN len, const char *little, STRLEN littlelen)
+PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv);
+/* PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen)
__attribute__nonnull__(pTHX_1)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_4); */
#define PERL_ARGS_ASSERT_SV_INSERT \
assert(bigstr); assert(little)
-PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char* name)
+PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags)
+ __attribute__nonnull__(pTHX_1)
+ __attribute__nonnull__(pTHX_4);
+#define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \
+ assert(bigstr); assert(little)
+
+PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_ISA \
assert(name)
PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv);
-PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV* sv);
-PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV* sv);
-PERL_CALLCONV void Perl_sv_magic(pTHX_ SV* sv, SV* obj, int how, const char* name, I32 namlen)
+PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv);
+PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const 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 \
assert(sv)
-PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV* sv, SV* obj, int how, const MGVTBL *vtbl, const char* name, I32 namlen)
+PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_MAGICEXT \
assert(sv)
-PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV* oldsv)
+PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
__attribute__malloc__
__attribute__warn_unused_result__;
PERL_CALLCONV SV* Perl_sv_newmortal(pTHX)
__attribute__warn_unused_result__;
-PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV* sv);
+PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv);
PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv);
-PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV* sv, I32* offsetp, I32* lenp)
+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 \
assert(offsetp)
-PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV* sv, I32* offsetp)
+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)
#define PERL_ARGS_ASSERT_SV_PVN_FORCE \
assert(sv)
-PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV* sv, STRLEN* lp)
+PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \
assert(sv)
-PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV* sv, STRLEN* lp)
+PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \
assert(sv)
#define PERL_ARGS_ASSERT_SV_CAT_DECODE \
assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr)
-PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV* sv, int ob)
+PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_REFTYPE \
assert(sv)
-PERL_CALLCONV void Perl_sv_replace(pTHX_ SV* sv, SV* nsv)
+PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_REPLACE \
assert(sv); assert(nsv)
PERL_CALLCONV void Perl_sv_report_used(pTHX);
-PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV* stash)
+PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_RESET \
assert(s)
-PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV* sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,pTHX_2,pTHX_3)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_SETPVF \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV* sv, const char* pat, va_list* args)
+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_SV_VSETPVF \
#define PERL_ARGS_ASSERT_SV_SETIV \
assert(sv)
-PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV* sv, IV num)
+PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETPVIV \
assert(sv)
#define PERL_ARGS_ASSERT_SV_SETNV \
assert(sv)
-PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV* rv, const char* classname, IV iv)
+PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETREF_IV \
assert(rv)
-PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV* rv, const char* classname, UV uv)
+PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETREF_UV \
assert(rv)
-PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV* rv, const char* classname, NV nv)
+PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETREF_NV \
assert(rv)
-PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV* rv, const char* classname, void* pv)
+PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETREF_PV \
assert(rv)
-PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV* rv, const char* classname, const char* pv, STRLEN n)
+PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_SV_SETREF_PVN \
#define PERL_ARGS_ASSERT_SV_TAINT \
assert(sv)
-PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV* sv)
+PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_TAINTED \
assert(sv)
-PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV* sv, int type)
+PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_UNMAGIC \
assert(sv)
#define PERL_ARGS_ASSERT_SV_UNREF \
assert(sv)
-PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *ref, U32 flags)
+PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \
assert(ref)
-PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV* sv)
+PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_UNTAINT \
assert(sv)
#define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \
assert(sv)
-PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+PERL_CALLCONV void Perl_sv_vcatpvfn(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)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_VCATPVFN \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV* sv, const char* pat, STRLEN patlen, va_list* args, SV** svargs, I32 svmax, bool *maybe_tainted)
+PERL_CALLCONV void Perl_sv_vsetpvfn(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)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_VSETPVFN \
assert(s)
#if defined(MYMALLOC)
-PERL_CALLCONV void Perl_dump_mstats(pTHX_ char* s)
+PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_DUMP_MSTATS \
assert(s)
#endif
PERL_CALLCONV int Perl_runops_standard(pTHX);
PERL_CALLCONV int Perl_runops_debug(pTHX);
-PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,pTHX_2,pTHX_3)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_CATPVF_MG \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV* sv, const char* pat, va_list* args)
+PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_VCATPVF_MG \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *sv, const char *ptr)
+PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_CATPV_MG \
assert(sv)
#define PERL_ARGS_ASSERT_SV_CATSV_MG \
assert(dsv)
-PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *sv, const char* pat, ...)
+PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...)
__attribute__format__(__printf__,pTHX_2,pTHX_3)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_SETPVF_MG \
assert(sv); assert(pat)
-PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV* sv, const char* pat, va_list* args)
+PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_VSETPVF_MG \
#define PERL_ARGS_ASSERT_SV_SETIV_MG \
assert(sv)
-PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *sv, IV iv)
+PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_SETPVIV_MG \
assert(sv)
assert(sv)
PERL_CALLCONV void Perl_tmps_grow(pTHX_ I32 n);
-PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *sv)
+PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_RVWEAKEN \
assert(sv)
#define PERL_ARGS_ASSERT_RE_DUP_GUTS \
assert(sstr); assert(dstr); assert(param)
-PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO* fp, char type, CLONE_PARAMS* param)
+PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_FP_DUP \
assert(param)
-PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR* dp)
+PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp)
__attribute__warn_unused_result__;
-PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP* gp, CLONE_PARAMS* param)
+PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_GP_DUP \
assert(param)
-PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC* mg, CLONE_PARAMS* param)
+PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_MG_DUP \
assert(param)
-PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV* sstr, CLONE_PARAMS* param)
+PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_DUP \
assert(param)
-PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV* dstr, const SV *sstr, CLONE_PARAMS* param)
+PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_RVPV_DUP \
assert(dstr); assert(sstr); assert(param)
-PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *proto, CLONE_PARAMS* param)
+PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_PARSER_DUP \
assert(param)
__attribute__malloc__
__attribute__warn_unused_result__;
-PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *tbl, const void *sv)
+PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \
assert(tbl)
-PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *tbl, const void *oldsv, void *newsv)
+PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_PTR_TABLE_STORE \
assert(tbl); assert(newsv)
-PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *tbl)
+PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \
assert(tbl)
-PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *tbl);
-PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *tbl);
+PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl);
+PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl);
#if defined(USE_ITHREADS)
# if defined(HAVE_INTERP_INTERN)
PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst)
STATIC OP* S_newDEFSVOP(pTHX)
__attribute__warn_unused_result__;
+STATIC OP* S_search_const(pTHX_ OP *o)
+ __attribute__warn_unused_result__
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_SEARCH_CONST \
+ assert(o)
+
STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_3)
#endif
#if defined(PERL_IN_PP_SORT_C) || defined(PERL_DECL_PROT)
-STATIC I32 S_sv_ncmp(pTHX_ SV *a, SV *b)
+STATIC I32 S_sv_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)
-STATIC I32 S_sv_i_ncmp(pTHX_ SV *a, SV *b)
+STATIC I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_I_NCMP \
assert(a); assert(b)
-STATIC I32 S_amagic_ncmp(pTHX_ SV *a, SV *b)
+STATIC I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_AMAGIC_NCMP \
assert(a); assert(b)
-STATIC I32 S_amagic_i_ncmp(pTHX_ SV *a, SV *b)
+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_AMAGIC_I_NCMP \
assert(a); assert(b)
-STATIC I32 S_amagic_cmp(pTHX_ SV *str1, SV *str2)
+STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_AMAGIC_CMP \
assert(str1); assert(str2)
-STATIC I32 S_amagic_cmp_locale(pTHX_ SV *str1, SV *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_sortcv(pTHX_ SV *a, SV *b)
+STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SORTCV \
assert(a); assert(b)
-STATIC I32 S_sortcv_xsub(pTHX_ SV *a, SV *b)
+STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SORTCV_XSUB \
assert(a); assert(b)
-STATIC I32 S_sortcv_stacked(pTHX_ SV *a, SV *b)
+STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SORTCV_STACKED \
#endif
#if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT)
-PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *tsv, SV *sv)
+PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_ADD_BACKREF \
#endif
#if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT)
-PERL_CALLCONV int Perl_sv_kill_backrefs(pTHX_ SV *sv, AV *av)
+PERL_CALLCONV int Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \
#define PERL_ARGS_ASSERT_UIV_2BUF \
assert(buf); assert(peob)
-STATIC void S_sv_unglob(pTHX_ SV* sv)
+STATIC void S_sv_unglob(pTHX_ SV *const sv)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_UNGLOB \
assert(sv)
#define PERL_ARGS_ASSERT_VISIT \
assert(f)
-STATIC void S_sv_del_backref(pTHX_ SV *tsv, SV *sv)
+STATIC void S_sv_del_backref(pTHX_ SV *const tsv, SV *const sv)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_SV_DEL_BACKREF \
assert(tsv); assert(sv)
-STATIC SV * S_varname(pTHX_ GV *gv, const char gvtype, PADOFFSET targ, SV *keyname, I32 aindex, int subscript_type)
+STATIC SV * S_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, I32 aindex, int subscript_type)
__attribute__warn_unused_result__;
# ifdef DEBUGGING
# endif
# endif
-STATIC I32 S_expect_number(pTHX_ char** pattern)
+STATIC I32 S_expect_number(pTHX_ char **const pattern)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_EXPECT_NUMBER \
#define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \
assert(start); assert(send)
-STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, STRLEN uend)
+STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, const STRLEN uoffset, const STRLEN uend)
__attribute__nonnull__(1)
__attribute__nonnull__(2);
#define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \
assert(start); assert(send)
-STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV *sv, MAGIC **mgp, const U8 *const start, const U8 *const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0)
+STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV *const sv, MAGIC **const mgp, const U8 *const start, const U8 *const send, const STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
__attribute__nonnull__(pTHX_3)
#define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \
assert(sv); assert(mgp); assert(start); assert(send)
-STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *sv, MAGIC **mgp, STRLEN byte, STRLEN utf8, STRLEN blen)
+STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \
assert(sv); assert(mgp)
-STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *s, const U8 *const target, const U8 *end, STRLEN endu)
+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)
__attribute__nonnull__(pTHX_3);
#define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \
assert(s); assert(target); assert(end)
-STATIC char * S_F0convert(NV nv, char *endbuf, STRLEN *len)
+STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len)
__attribute__nonnull__(2)
__attribute__nonnull__(3);
#define PERL_ARGS_ASSERT_F0CONVERT \
#define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \
assert(dstr); assert(sstr)
-STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *tbl, const void *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_PTR_TABLE_FIND \
#endif
#if defined(PERL_IN_UNIVERSAL_C) || defined(PERL_DECL_PROT)
-STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, const HV * const name_stash)
+STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name)
+ __attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_ISA_LOOKUP \
- assert(name)
+ assert(stash); assert(name)
#endif
STATIC char * S_write_no_mem(pTHX)
__attribute__noreturn__;
+#if defined(PERL_MEM_LOG) && defined(PERL_MEM_LOG_STDERR)
+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)
+ __attribute__nonnull__(8)
+ __attribute__nonnull__(10);
+#define PERL_ARGS_ASSERT_MEM_LOG_COMMON \
+ assert(type_name); assert(filename); assert(funcname)
+
+#endif
#endif
#if defined(PERL_IN_NUMERIC_C) || defined(PERL_DECL_PROT)
#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS \
assert(sv)
-PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV* sv, STRLEN* lp, I32 flags)
+PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags)
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \
assert(sv)
#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \
assert(hv)
-PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ HV *hv)
+PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv)
__attribute__warn_unused_result__
__attribute__nonnull__(pTHX_1);
#define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \
#if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT)
-STATIC SV * S_find_hash_subscript(pTHX_ HV *hv, SV *val)
+STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \
assert(val)
-STATIC I32 S_find_array_subscript(pTHX_ AV *av, SV *val)
+STATIC I32 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val)
__attribute__nonnull__(pTHX_2);
#define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \
assert(val)
-STATIC SV* S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool top);
+STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top);
#endif
#ifdef PERL_NEED_MY_HTOLE16
assert(argc); assert(argv); assert(env)
PERL_CALLCONV void Perl_sys_term(void);
+PERL_CALLCONV const char * Perl_fetch_cop_label(pTHX_ struct refcounted_he *const chain, STRLEN *len, U32 *flags);
+PERL_CALLCONV struct refcounted_he * Perl_store_cop_label(pTHX_ struct refcounted_he *const chain, const char *label)
+ __attribute__nonnull__(pTHX_2);
+#define PERL_ARGS_ASSERT_STORE_COP_LABEL \
+ assert(label)
+
+PERL_CALLCONV HV * Perl_get_isa_hash(pTHX_ HV *const stash)
+ __attribute__nonnull__(pTHX_1);
+#define PERL_ARGS_ASSERT_GET_ISA_HASH \
+ assert(stash)
END_EXTERN_C
https://perl5.git.perl.org / perl5.git / blobdiff