In perl.git, the branch blead has been updated <http://perl5.git.perl.org/perl.git/commitdiff/6ba07ce12b615587e55caf4477539992d4b3e79b?hp=a85b939856f86060c9ce00162f3a05fa26df06b9>
- Log ----------------------------------------------------------------- commit 6ba07ce12b615587e55caf4477539992d4b3e79b Author: Jarkko Hietaniemi <[email protected]> Date: Fri Aug 7 22:14:55 2015 -0400 No __attribute__((nonnull(...))) from NN. ----------------------------------------------------------------------- Summary of changes: proto.h | 5198 ++++++++++++++------------------------------------------ regen/embed.pl | 4 - 2 files changed, 1230 insertions(+), 3972 deletions(-) diff --git a/proto.h b/proto.h index 5c0a61b..12bbb2e 100644 --- a/proto.h +++ b/proto.h @@ -22,11 +22,9 @@ PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch) __attribute__warn_unused_result__ __attribute__pure__; -PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing); #define PERL_ARGS_ASSERT_GV_AMUPDATE \ assert(stash) - PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch) __attribute__deprecated__ __attribute__warn_unused_result__ @@ -37,11 +35,9 @@ 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); +PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) - PERL_CALLCONV SV* Perl__get_encoding(pTHX) __attribute__pure__; @@ -56,252 +52,167 @@ PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ assert(p) PERL_STATIC_INLINE STRLEN S__is_utf8_char_slow(const U8 *s, const U8 *e) - __attribute__warn_unused_result__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_CHAR_SLOW \ assert(s); assert(e) PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_IDCONT \ assert(p) PERL_CALLCONV bool Perl__is_utf8_idstart(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_IDSTART \ assert(p) PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_MARK \ assert(p) PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ assert(p) PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p) PERL_CALLCONV bool Perl__is_utf8_xidcont(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_XIDCONT \ assert(p) PERL_CALLCONV bool Perl__is_utf8_xidstart(pTHX_ const U8 *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_XIDSTART \ assert(p) -PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ assert(p); assert(lenp) - -PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ assert(p); assert(ustrp) - -PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ assert(p); assert(ustrp) - -PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ assert(p); assert(ustrp) - -PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ assert(p); assert(ustrp) - PERL_CALLCONV void Perl__warn_problematic_locale(void); -PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_ALLOCMY \ assert(name) - -PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir); #define PERL_ARGS_ASSERT_AMAGIC_CALL \ assert(left); assert(right) - -PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) - PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); -PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest) - __attribute__nonnull__(2); +PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest); #define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ assert(dest) - -PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp); #define PERL_ARGS_ASSERT_APPLY \ assert(mark); assert(sp) - -PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len); #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ assert(stashpv); assert(cv); assert(attrstr) - PERL_CALLCONV void Perl_atfork_lock(void); PERL_CALLCONV void Perl_atfork_unlock(void); -PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ assert(av) - -PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_CLEAR \ assert(av) - -PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val); #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ assert(avp); assert(val) - -PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val); #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ assert(avp); assert(val) - -PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags); #define PERL_ARGS_ASSERT_AV_DELETE \ assert(av) - PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_EXISTS \ assert(av) -PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key); #define PERL_ARGS_ASSERT_AV_EXTEND \ assert(av) - -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); +PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp); #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ assert(maxp); assert(allocp); assert(arrayp) - PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_FETCH \ assert(av) -PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill); #define PERL_ARGS_ASSERT_AV_FILL \ assert(av) - -PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_ITER_P \ assert(av) - PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_LEN \ assert(av) PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_MAKE \ assert(strp) -PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_POP \ assert(av) - -PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val); #define PERL_ARGS_ASSERT_AV_PUSH \ assert(av); assert(val) - -PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_REIFY \ assert(av) - PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_SHIFT \ assert(av) -PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); #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); */ + __attribute__warn_unused_result__; */ PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_AV_TOP_INDEX \ assert(av) -PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_UNDEF \ assert(av) - -PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num); #define PERL_ARGS_ASSERT_AV_UNSHIFT \ assert(av) - PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_BIND_MATCH \ assert(left); assert(right) @@ -314,67 +225,44 @@ PERL_CALLCONV I32 Perl_block_gimme(pTHX) PERL_CALLCONV int Perl_block_start(pTHX_ int full) __attribute__warn_unused_result__; -PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk); #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ assert(hk) - PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); PERL_CALLCONV void Perl_boot_core_mro(pTHX); -PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ assert(b); assert(u) - -PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8); #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ assert(s); assert(len) - -PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ assert(s); assert(len) - -PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv); #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) - PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); -PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList); #define PERL_ARGS_ASSERT_CALL_LIST \ assert(paramList) - -PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags); #define PERL_ARGS_ASSERT_CALL_METHOD \ assert(methname) - -PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags); #define PERL_ARGS_ASSERT_CALL_PV \ assert(sub_name) - -PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags); #define PERL_ARGS_ASSERT_CALL_SV \ assert(sv) - PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) __attribute__malloc__ __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_3); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CANDO \ assert(statbufp) @@ -390,353 +278,278 @@ PERL_CALLCONV U32 Perl_cast_ulong(NV f) PERL_CALLCONV UV Perl_cast_uv(NV f) __attribute__warn_unused_result__; -PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len); #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ assert(s) - PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_ANONCODE \ assert(o) PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_BACKTICK \ assert(o) PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_BITOP \ assert(o) PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_CMP \ assert(o) PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_CONCAT \ assert(o) PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_DEFINED \ assert(o) PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_DELETE \ assert(o) PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_EACH \ assert(o) -PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ assert(entersubop); assert(namegv); assert(protosv) - -PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ assert(entersubop) - -PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ assert(entersubop); assert(namegv); assert(protosv) - -PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv); #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ assert(entersubop); assert(namegv); assert(protosv) - PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_EOF \ assert(o) PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_EVAL \ assert(o) PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_EXEC \ assert(o) PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_EXISTS \ assert(o) PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_FTST \ assert(o) PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_FUN \ assert(o) PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_GLOB \ assert(o) PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_GREP \ assert(o) PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_INDEX \ assert(o) PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_JOIN \ assert(o) PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_LENGTH \ assert(o) PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_LFUN \ assert(o) PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_LISTIOB \ assert(o) PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_MATCH \ assert(o) PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_METHOD \ assert(o) PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_NULL \ assert(o) PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_OPEN \ assert(o) PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_PROTOTYPE \ assert(o) PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_READLINE \ assert(o) PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_REFASSIGN \ assert(o) PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_REPEAT \ assert(o) PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_REQUIRE \ assert(o) PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_RETURN \ assert(o) PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_RFUN \ assert(o) PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_RVCONST \ assert(o) PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SASSIGN \ assert(o) PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SELECT \ assert(o) PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SHIFT \ assert(o) PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SMARTMATCH \ assert(o) PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SORT \ assert(o) PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SPAIR \ assert(o) PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SPLIT \ assert(o) PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_STRINGIFY \ assert(o) PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SUBR \ assert(o) PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SUBSTR \ assert(o) PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_SVCONST \ assert(o) PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_TELL \ assert(o) PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CK_TRUNC \ assert(o) PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...) - __attribute__format__(__printf__,pTHX_2,pTHX_3) - __attribute__nonnull__(pTHX_2); + __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER \ assert(pat) PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) - __attribute__format__(__printf__,pTHX_2,pTHX_3) - __attribute__nonnull__(pTHX_2); + __attribute__format__(__printf__,pTHX_2,pTHX_3); #define PERL_ARGS_ASSERT_CK_WARNER_D \ assert(pat) PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w); PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w); -PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext); #define PERL_ARGS_ASSERT_CLOSEST_COP \ assert(cop) - -PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags); #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ assert(cop) - -PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ assert(cop); assert(label) - -PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum); #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ assert(name) - -PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum); #define PERL_ARGS_ASSERT_CORESUB_OP \ assert(coreargssv) - PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags); PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...) __attribute__noreturn__ @@ -755,63 +568,46 @@ PERL_CALLCONV_NO_RET void Perl_croak_popstack(void) __attribute__noreturn__; PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) - __attribute__noreturn__ - __attribute__nonnull__(pTHX_1); + __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_SV \ assert(baseex) PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *const params) - __attribute__noreturn__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__noreturn__; #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ assert(cv); assert(params) PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ assert(o) PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ assert(o) PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ assert(o) -PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ assert(ppaddr); assert(xop) - /* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o) - __attribute__pure__ - __attribute__nonnull__(pTHX_1); */ + __attribute__pure__; */ -PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ assert(cv) - -PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto); #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); +PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target); #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ assert(proto); assert(target) - PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv) __attribute__warn_unused_result__; @@ -819,393 +615,243 @@ PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv); -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) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ assert(cv); assert(ckfun_p); assert(ckobj_p) - -PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags); #define PERL_ARGS_ASSERT_CV_NAME \ assert(cv) - -PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ assert(cv); assert(ckfun); assert(ckobj) - -PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 flags); #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \ assert(cv); assert(ckfun); assert(ckobj) - -PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv); #define PERL_ARGS_ASSERT_CV_UNDEF \ assert(cv) - -PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV* cv, U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV* cv, U32 flags); #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ assert(cv) - -PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv); #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ assert(cv) - -PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv); #define PERL_ARGS_ASSERT_CVGV_SET \ assert(cv) - -PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash); #define PERL_ARGS_ASSERT_CVSTASH_SET \ assert(cv) - -PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx); #define PERL_ARGS_ASSERT_CX_DUMP \ assert(cx) - PERL_CALLCONV I32 Perl_cxinc(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) - __attribute__format__(__printf__,pTHX_1,pTHX_2) - __attribute__nonnull__(pTHX_1); + __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_DEB \ assert(pat) PERL_CALLCONV void Perl_deb_stack_all(pTHX); -PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o); #define PERL_ARGS_ASSERT_DEBOP \ assert(o) - 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); + __attribute__warn_unused_result__; #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) - __attribute__nonnull__(2) - __attribute__nonnull__(3) - __attribute__nonnull__(4) - __attribute__nonnull__(6); +PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen); #define PERL_ARGS_ASSERT_DELIMCPY \ assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) - PERL_CALLCONV void Perl_despatch_signals(pTHX); PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex) - __attribute__noreturn__ - __attribute__nonnull__(pTHX_1); + __attribute__noreturn__; #define PERL_ARGS_ASSERT_DIE_SV \ assert(baseex) PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv) - __attribute__noreturn__ - __attribute__nonnull__(pTHX_1); + __attribute__noreturn__; #define PERL_ARGS_ASSERT_DIE_UNWIND \ assert(msv) -/* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); */ +/* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp); */ #define PERL_ARGS_ASSERT_DO_AEXEC \ assert(mark); assert(sp) - -PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report); #define PERL_ARGS_ASSERT_DO_AEXEC5 \ assert(mark); assert(sp) - -PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode); #define PERL_ARGS_ASSERT_DO_BINMODE \ assert(fp) - PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); -PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ assert(file) - -PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_DO_EOF \ assert(gv) - PERL_CALLCONV void Perl_do_execfree(pTHX); -PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); #define PERL_ARGS_ASSERT_DO_GV_DUMP \ assert(file); assert(name) - -PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ assert(file); assert(name) - -PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv); #define PERL_ARGS_ASSERT_DO_HV_DUMP \ assert(file); assert(name) - -PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3) - __attribute__nonnull__(pTHX_4); +PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp); #define PERL_ARGS_ASSERT_DO_JOIN \ assert(sv); assert(delim); assert(mark); assert(sp) - -PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ assert(file) - PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV *const left, SV *const right) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DO_NCMP \ assert(left); assert(right) -PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) - -/* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp); */ #define PERL_ARGS_ASSERT_DO_OPEN \ assert(gv); assert(name) - -PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num); #define PERL_ARGS_ASSERT_DO_OPEN6 \ assert(gv); assert(oname) - -PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_8); +PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num); #define PERL_ARGS_ASSERT_DO_OPEN9 \ assert(gv); assert(name); assert(svs) - -PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm); #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ assert(gv); assert(oname) - -PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num); #define PERL_ARGS_ASSERT_DO_OPENN \ assert(gv); assert(oname) - -PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm); #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ assert(file) - -PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp); #define PERL_ARGS_ASSERT_DO_PRINT \ assert(fp) - PERL_CALLCONV OP* Perl_do_readline(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); -PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg); #define PERL_ARGS_ASSERT_DO_SPRINTF \ assert(sv); assert(sarg) - -PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); #define PERL_ARGS_ASSERT_DO_SV_DUMP \ assert(file) - -PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence); #define PERL_ARGS_ASSERT_DO_SYSSEEK \ assert(gv) - PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DO_TELL \ assert(gv) -PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) - -PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) - -PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_DO_VECSET \ assert(sv) - -PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3) - __attribute__nonnull__(pTHX_4); +PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right); #define PERL_ARGS_ASSERT_DO_VOP \ assert(sv); assert(left); assert(right) - -PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin); #define PERL_ARGS_ASSERT_DOFILE \ assert(term) - PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) __attribute__warn_unused_result__; -PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); #define PERL_ARGS_ASSERT_DOREF \ assert(o) - PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); PERL_CALLCONV I32 Perl_dowantarray(pTHX) __attribute__warn_unused_result__; -PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed) - __attribute__nonnull__(1); +PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ assert(random_state) - -PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state) - __attribute__nonnull__(1); +PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state); #define PERL_ARGS_ASSERT_DRAND48_R \ assert(random_state) - PERL_CALLCONV void Perl_dump_all(pTHX); PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); PERL_CALLCONV void Perl_dump_eval(pTHX); -PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv); #define PERL_ARGS_ASSERT_DUMP_FORM \ assert(gv) - PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) - __attribute__format__(__printf__,pTHX_3,pTHX_4) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__format__(__printf__,pTHX_3,pTHX_4); #define PERL_ARGS_ASSERT_DUMP_INDENT \ assert(file); assert(pat) -PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ assert(stash) - -PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl); #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ assert(stash) - -PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv); #define PERL_ARGS_ASSERT_DUMP_SUB \ assert(gv) - -PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl); #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ assert(gv) - -PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ assert(file); assert(pat) - -PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv); #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ assert(c); assert(sv) - -PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error); #define PERL_ARGS_ASSERT_EVAL_PV \ assert(p) - -PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags); #define PERL_ARGS_ASSERT_EVAL_SV \ assert(sv) - -PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags); #define PERL_ARGS_ASSERT_FBM_COMPILE \ assert(sv) - PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FBM_INSTR \ assert(big); assert(bigend); assert(littlestr) -PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen); #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \ assert(name) - PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); -PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp); #define PERL_ARGS_ASSERT_FILTER_DEL \ assert(funcp) - PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FILTER_READ \ assert(buf_sv) -PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o); #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__; @@ -1214,98 +860,68 @@ 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); +PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq); #define PERL_ARGS_ASSERT_FIND_RUNDEFSV2 \ assert(cv) - PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) __attribute__deprecated__; -PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) - PERL_CALLCONV I32 Perl_foldEQ(const char* a, const char* b, I32 len) - __attribute__pure__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__pure__; #define PERL_ARGS_ASSERT_FOLDEQ \ assert(a); assert(b) PERL_CALLCONV I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len) - __attribute__pure__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__pure__; #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ assert(a); assert(b) PERL_CALLCONV I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len) - __attribute__pure__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__pure__; #define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ assert(a); assert(b) -/* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_5); */ - -PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_5); +/* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ +PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ assert(s1); assert(s2) - PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) - __attribute__format__(__printf__,pTHX_1,pTHX_2) - __attribute__nonnull__(pTHX_1); + __attribute__format__(__printf__,pTHX_1,pTHX_2); #define PERL_ARGS_ASSERT_FORM \ assert(pat) PERL_CALLCONV char* Perl_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len) __attribute__warn_unused_result__ - __attribute__pure__ - __attribute__nonnull__(pTHX_1); + __attribute__pure__; #define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \ assert(s) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); PERL_CALLCONV void Perl_free_tmps(pTHX); -PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_AV \ assert(name) - PERL_CALLCONV void* Perl_get_context(void) __attribute__warn_unused_result__; -PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags); #define PERL_ARGS_ASSERT_GET_CV \ assert(name) - -PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags); #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ assert(name) - -PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv); #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv) - -PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer); #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); +PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_HV \ assert(name) - PERL_CALLCONV const char* Perl_get_no_modify(pTHX) __attribute__warn_unused_result__ __attribute__pure__; @@ -1327,495 +943,311 @@ PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) __attribute__pure__; PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); -PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_SV \ assert(name) - PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) __attribute__warn_unused_result__; -PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_GETCWD_SV \ assert(sv) - PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); -PERL_CALLCONV bool Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr) - __attribute__nonnull__(1) - __attribute__nonnull__(2); +PERL_CALLCONV bool Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr); #define PERL_ARGS_ASSERT_GROK_ATOUV \ assert(pv); assert(valptr) - -PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); #define PERL_ARGS_ASSERT_GROK_BIN \ assert(start); assert(len_p); assert(flags) - PERL_CALLCONV char Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_grok_bslash_o(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GROK_BSLASH_O \ assert(s); assert(uv); assert(error_msg) -PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); #define PERL_ARGS_ASSERT_GROK_HEX \ assert(start); assert(len_p); assert(flags) - -PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char** sp, const char *send) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char** sp, const char *send); #define PERL_ARGS_ASSERT_GROK_INFNAN \ assert(sp); assert(send) - -PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep); #define PERL_ARGS_ASSERT_GROK_NUMBER \ assert(pv) - -PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags); #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ assert(pv) - PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ assert(sp); assert(send) -PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); #define PERL_ARGS_ASSERT_GROK_OCT \ assert(start); assert(len_p); assert(flags) - /* PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); */ /* PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); */ /* PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); */ PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); /* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); */ + __attribute__warn_unused_result__; */ PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ assert(namepv) PERL_CALLCONV GV* Perl_gv_autoload_pvn(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ assert(name) PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ assert(namesv) -PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash); #define PERL_ARGS_ASSERT_GV_CHECK \ assert(stash) - PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GV_CONST_SV \ assert(gv) PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv); -PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv); #define PERL_ARGS_ASSERT_GV_EFULLNAME \ assert(sv); assert(gv) - -/* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); */ #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ assert(sv); assert(gv) - -PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ assert(sv); assert(gv) - -PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name); #define PERL_ARGS_ASSERT_GV_FETCHFILE \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) - -/* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) - __attribute__nonnull__(pTHX_2); */ - -/* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) - __attribute__nonnull__(pTHX_2); */ - -PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +/* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ +/* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ +PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ assert(namesv) - -PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) - -/* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name); */ #define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ 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); +PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ assert(stash); assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ assert(stash); assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ assert(stash); assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ assert(stash); assert(namesv) - -PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHPV \ assert(nambeg) - -PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ assert(name) - -PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) - -PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv); #define PERL_ARGS_ASSERT_GV_FULLNAME \ assert(sv); assert(gv) - -/* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); */ #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ assert(sv); assert(gv) - -PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ assert(sv); assert(gv) - PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) __attribute__warn_unused_result__; -/* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); */ - -PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +/* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi); */ +PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PV \ assert(gv); assert(name) - -PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PVN \ assert(gv); assert(name) - -PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_3); +PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_SV \ assert(gv); assert(namesv) - -PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_GV_NAME_SET \ assert(gv); assert(name) - -PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len); #define PERL_ARGS_ASSERT_GV_OVERRIDE \ assert(name) - -PERL_CALLCONV void Perl_gv_setref(pTHX_ SV *const dstr, SV *const sstr) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_gv_setref(pTHX_ SV *const dstr, SV *const sstr); #define PERL_ARGS_ASSERT_GV_SETREF \ assert(dstr); assert(sstr) - -PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHPV \ assert(name) - -PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHPVN \ assert(name) - -PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHSV \ assert(sv) - -PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ assert(gv) - -PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ assert(hv) - PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); -PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ assert(hv) - PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); -PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash); #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ assert(key) - PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv) __attribute__warn_unused_result__; -PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ assert(hv) - -/* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */ #define PERL_ARGS_ASSERT_HV_DELETE \ assert(key) - -/* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */ #define PERL_ARGS_ASSERT_HV_DELETE_ENT \ assert(keysv) - PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_EITER_P \ assert(hv) -PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter); #define PERL_ARGS_ASSERT_HV_EITER_SET \ assert(hv) - -PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ assert(hv); assert(name) - -PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); +PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ assert(hv); assert(name) - /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); */ + __attribute__warn_unused_result__; */ #define PERL_ARGS_ASSERT_HV_EXISTS \ assert(key) /* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_2); */ + __attribute__warn_unused_result__; */ #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ assert(keysv) -/* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */ #define PERL_ARGS_ASSERT_HV_FETCH \ assert(key) - -/* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) - __attribute__nonnull__(pTHX_2); */ +/* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ #define PERL_ARGS_ASSERT_HV_FETCH_ENT \ assert(keysv) - -PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv); #define PERL_ARGS_ASSERT_HV_FILL \ assert(hv) - -PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry); #define PERL_ARGS_ASSERT_HV_FREE_ENT \ assert(hv) - -PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_ITERINIT \ assert(hv) - PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEY \ assert(entry); assert(retlen) PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) /* PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); */ + __attribute__warn_unused_result__; */ #define PERL_ARGS_ASSERT_HV_ITERNEXT \ assert(hv) PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ assert(hv) PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ assert(hv); assert(key); assert(retlen) PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV *hv, HE *entry) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_HV_ITERVAL \ assert(hv); assert(entry) -PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv) - -/* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) - __attribute__nonnull__(pTHX_1); */ +/* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ #define PERL_ARGS_ASSERT_HV_MAGIC \ assert(hv) - -PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_NAME_SET \ assert(hv) - PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) - __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__warn_unused_result__; **** PATCH TRUNCATED AT 2000 LINES -- 7184 NOT SHOWN **** -- Perl5 Master Repository
