1 /* -*- buffer-read-only: t -*- 2 * 3 * proto.h 4 * 5 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 6 * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall and others 7 * 8 * You may distribute under the terms of either the GNU General Public 9 * License or the Artistic License, as specified in the README file. 10 * 11 * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! 12 * This file is built by regen/embed.pl from data in embed.fnc, 13 * regen/embed.pl, regen/opcodes, intrpvar.h and perlvars.h. 14 * Any changes made here will be lost! 15 * 16 * Edit those files and run 'make regen_headers' to effect changes. 17 */ 18 19 START_EXTERN_C 20 #ifndef NO_MATHOMS 21 PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch) 22 __attribute__deprecated__ 23 __attribute__warn_unused_result__ 24 __attribute__pure__; 25 #define PERL_ARGS_ASSERT_ASCII_TO_NEED 26 #endif 27 28 #ifndef PERL_NO_INLINE_FUNCTIONS 29 PERL_STATIC_INLINE I32 * Perl_CvDEPTH(const CV * const sv); 30 #define PERL_ARGS_ASSERT_CVDEPTH \ 31 assert(sv) 32 #endif 33 #ifndef PERL_NO_INLINE_FUNCTIONS 34 PERL_STATIC_INLINE GV * Perl_CvGV(pTHX_ CV *sv); 35 #define PERL_ARGS_ASSERT_CVGV \ 36 assert(sv) 37 #endif 38 PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing); 39 #define PERL_ARGS_ASSERT_GV_AMUPDATE \ 40 assert(stash) 41 #ifndef NO_MATHOMS 42 PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch) 43 __attribute__deprecated__ 44 __attribute__warn_unused_result__ 45 __attribute__pure__; 46 #define PERL_ARGS_ASSERT_NATIVE_TO_NEED 47 #endif 48 49 #ifndef PERL_NO_INLINE_FUNCTIONS 50 PERL_STATIC_INLINE I32 Perl_POPMARK(pTHX); 51 #define PERL_ARGS_ASSERT_POPMARK 52 #endif 53 PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); 54 #define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS 55 PERL_CALLCONV int Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd); 56 #define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC 57 PERL_CALLCONV int Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd) 58 __attribute__warn_unused_result__; 59 #define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC 60 61 PERL_CALLCONV int Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) 62 __attribute__warn_unused_result__; 63 #define PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC \ 64 assert(file) 65 66 PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) 67 __attribute__warn_unused_result__; 68 #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ 69 assert(file) 70 71 /* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o); */ 72 #define PERL_ARGS_ASSERT_PERL_CUSTOM_OP_XOP 73 PERL_CALLCONV const char* Perl_setlocale(const int category, const char* locale); 74 #define PERL_ARGS_ASSERT_PERL_SETLOCALE 75 #ifndef PERL_NO_INLINE_FUNCTIONS 76 PERL_STATIC_INLINE struct regexp * Perl_ReANY(const REGEXP * const re); 77 #define PERL_ARGS_ASSERT_REANY \ 78 assert(re) 79 #endif 80 PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) 81 __attribute__warn_unused_result__; 82 #define PERL_ARGS_ASSERT_SLAB_ALLOC 83 84 PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op); 85 #define PERL_ARGS_ASSERT_SLAB_FREE \ 86 assert(op) 87 #ifndef PERL_NO_INLINE_FUNCTIONS 88 PERL_STATIC_INLINE void Perl_SvAMAGIC_off(SV *sv); 89 #define PERL_ARGS_ASSERT_SVAMAGIC_OFF \ 90 assert(sv) 91 #endif 92 #ifndef PERL_NO_INLINE_FUNCTIONS 93 PERL_STATIC_INLINE void Perl_SvAMAGIC_on(SV *sv); 94 #define PERL_ARGS_ASSERT_SVAMAGIC_ON \ 95 assert(sv) 96 #endif 97 #ifndef PERL_NO_INLINE_FUNCTIONS 98 PERL_STATIC_INLINE void Perl_SvREFCNT_dec(pTHX_ SV *sv); 99 #define PERL_ARGS_ASSERT_SVREFCNT_DEC 100 #endif 101 #ifndef PERL_NO_INLINE_FUNCTIONS 102 PERL_STATIC_INLINE void Perl_SvREFCNT_dec_NN(pTHX_ SV *sv); 103 #define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ 104 assert(sv) 105 #endif 106 #ifndef PERL_NO_INLINE_FUNCTIONS 107 PERL_STATIC_INLINE SV * Perl_SvREFCNT_inc(SV *sv); 108 #define PERL_ARGS_ASSERT_SVREFCNT_INC 109 #endif 110 #ifndef PERL_NO_INLINE_FUNCTIONS 111 PERL_STATIC_INLINE SV * Perl_SvREFCNT_inc_NN(SV *sv); 112 #define PERL_ARGS_ASSERT_SVREFCNT_INC_NN \ 113 assert(sv) 114 #endif 115 #ifndef PERL_NO_INLINE_FUNCTIONS 116 PERL_STATIC_INLINE void Perl_SvREFCNT_inc_void(SV *sv); 117 #define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID 118 #endif 119 #ifndef PERL_NO_INLINE_FUNCTIONS 120 PERL_STATIC_INLINE bool Perl_SvTRUE(pTHX_ SV *sv); 121 #define PERL_ARGS_ASSERT_SVTRUE 122 #endif 123 #ifndef PERL_NO_INLINE_FUNCTIONS 124 PERL_STATIC_INLINE bool Perl_SvTRUE_NN(pTHX_ SV *sv); 125 #define PERL_ARGS_ASSERT_SVTRUE_NN \ 126 assert(sv) 127 #endif 128 #ifndef PERL_NO_INLINE_FUNCTIONS 129 PERL_STATIC_INLINE bool Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback); 130 #define PERL_ARGS_ASSERT_SVTRUE_COMMON \ 131 assert(sv) 132 #endif 133 #ifndef PERL_NO_INLINE_FUNCTIONS 134 PERL_STATIC_INLINE bool Perl_SvTRUE_nomg(pTHX_ SV *sv); 135 #define PERL_ARGS_ASSERT_SVTRUE_NOMG 136 #endif 137 #ifndef PERL_NO_INLINE_FUNCTIONS 138 PERL_STATIC_INLINE I32 Perl_TOPMARK(pTHX); 139 #define PERL_ARGS_ASSERT_TOPMARK 140 #endif 141 PERL_CALLCONV char * Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format); 142 #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING \ 143 assert(start) 144 PERL_CALLCONV void Perl__force_out_malformed_utf8_message(pTHX_ const U8 *const p, const U8 * const e, const U32 flags, const bool die_here); 145 #define PERL_ARGS_ASSERT__FORCE_OUT_MALFORMED_UTF8_MESSAGE \ 146 assert(p); assert(e) 147 PERL_CALLCONV Size_t Perl__inverse_folds(pTHX_ const UV cp, U32 * first_folds_to, const U32 ** remaining_folds_to) 148 __attribute__warn_unused_result__; 149 #define PERL_ARGS_ASSERT__INVERSE_FOLDS \ 150 assert(first_folds_to); assert(remaining_folds_to) 151 152 PERL_CALLCONV bool Perl__is_in_locale_category(pTHX_ const bool compiling, const int category); 153 #define PERL_ARGS_ASSERT__IS_IN_LOCALE_CATEGORY 154 PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) 155 __attribute__warn_unused_result__; 156 #define PERL_ARGS_ASSERT__IS_UNI_FOO 157 158 PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c) 159 __attribute__warn_unused_result__; 160 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT 161 162 PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) 163 __attribute__warn_unused_result__; 164 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART 165 166 PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) 167 __attribute__warn_unused_result__; 168 #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ 169 assert(p); assert(e) 170 171 PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) 172 __attribute__warn_unused_result__; 173 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ 174 assert(p); assert(e) 175 176 PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) 177 __attribute__warn_unused_result__; 178 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ 179 assert(p); assert(e) 180 181 PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); 182 #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ 183 assert(p); assert(lenp) 184 PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, U8 flags); 185 #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ 186 assert(p); assert(ustrp) 187 PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags); 188 #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ 189 assert(p); assert(ustrp) 190 PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags); 191 #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ 192 assert(p); assert(ustrp) 193 PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags); 194 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ 195 assert(p); assert(ustrp) 196 PERL_CALLCONV UV Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); 197 #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER \ 198 assert(s) 199 PERL_CALLCONV void Perl__warn_problematic_locale(void); 200 #define PERL_ARGS_ASSERT__WARN_PROBLEMATIC_LOCALE 201 PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ const char * const msg, const char * const name) 202 __attribute__noreturn__; 203 #define PERL_ARGS_ASSERT_ABORT_EXECUTION \ 204 assert(msg); assert(name) 205 206 PERL_CALLCONV LOGOP* Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other); 207 #define PERL_ARGS_ASSERT_ALLOC_LOGOP 208 PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags); 209 #define PERL_ARGS_ASSERT_ALLOCMY \ 210 assert(name) 211 PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir); 212 #define PERL_ARGS_ASSERT_AMAGIC_CALL \ 213 assert(left); assert(right) 214 PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method); 215 #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ 216 assert(ref) 217 PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); 218 #define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED 219 #ifndef PERL_NO_INLINE_FUNCTIONS 220 PERL_STATIC_INLINE void Perl_append_utf8_from_native_byte(const U8 byte, U8** dest); 221 #define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ 222 assert(dest) 223 #endif 224 PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp); 225 #define PERL_ARGS_ASSERT_APPLY \ 226 assert(mark); assert(sp) 227 PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len); 228 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ 229 assert(stashpv); assert(cv); assert(attrstr) 230 PERL_CALLCONV void Perl_atfork_lock(void); 231 #define PERL_ARGS_ASSERT_ATFORK_LOCK 232 PERL_CALLCONV void Perl_atfork_unlock(void); 233 #define PERL_ARGS_ASSERT_ATFORK_UNLOCK 234 PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av); 235 #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ 236 assert(av) 237 PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av); 238 #define PERL_ARGS_ASSERT_AV_CLEAR \ 239 assert(av) 240 #ifndef PERL_NO_INLINE_FUNCTIONS 241 PERL_STATIC_INLINE Size_t Perl_av_count(pTHX_ AV *av) 242 __attribute__warn_unused_result__; 243 #define PERL_ARGS_ASSERT_AV_COUNT \ 244 assert(av) 245 #endif 246 247 PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val); 248 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ 249 assert(avp); assert(val) 250 PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val); 251 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ 252 assert(avp); assert(val) 253 PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags); 254 #define PERL_ARGS_ASSERT_AV_DELETE \ 255 assert(av) 256 PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) 257 __attribute__warn_unused_result__; 258 #define PERL_ARGS_ASSERT_AV_EXISTS \ 259 assert(av) 260 261 PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key); 262 #define PERL_ARGS_ASSERT_AV_EXTEND \ 263 assert(av) 264 PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp); 265 #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ 266 assert(maxp); assert(allocp); assert(arrayp) 267 PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) 268 __attribute__warn_unused_result__; 269 #define PERL_ARGS_ASSERT_AV_FETCH \ 270 assert(av) 271 272 #ifndef PERL_NO_INLINE_FUNCTIONS 273 PERL_STATIC_INLINE SV** Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) 274 __attribute__warn_unused_result__; 275 #define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE \ 276 assert(av) 277 #endif 278 279 PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill); 280 #define PERL_ARGS_ASSERT_AV_FILL \ 281 assert(av) 282 PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av); 283 #define PERL_ARGS_ASSERT_AV_ITER_P \ 284 assert(av) 285 PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) 286 __attribute__warn_unused_result__; 287 #define PERL_ARGS_ASSERT_AV_LEN \ 288 assert(av) 289 290 PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp) 291 __attribute__warn_unused_result__; 292 #define PERL_ARGS_ASSERT_AV_MAKE \ 293 assert(strp) 294 295 PERL_CALLCONV AV* Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) 296 __attribute__warn_unused_result__; 297 #define PERL_ARGS_ASSERT_AV_NEW_ALLOC 298 299 PERL_CALLCONV SV* Perl_av_nonelem(pTHX_ AV *av, SSize_t ix); 300 #define PERL_ARGS_ASSERT_AV_NONELEM \ 301 assert(av) 302 PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av); 303 #define PERL_ARGS_ASSERT_AV_POP \ 304 assert(av) 305 PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val); 306 #define PERL_ARGS_ASSERT_AV_PUSH \ 307 assert(av); assert(val) 308 PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av); 309 #define PERL_ARGS_ASSERT_AV_REIFY \ 310 assert(av) 311 PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) 312 __attribute__warn_unused_result__; 313 #define PERL_ARGS_ASSERT_AV_SHIFT \ 314 assert(av) 315 316 PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); 317 #define PERL_ARGS_ASSERT_AV_STORE \ 318 assert(av) 319 #ifndef PERL_NO_INLINE_FUNCTIONS 320 PERL_STATIC_INLINE SV** Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val); 321 #define PERL_ARGS_ASSERT_AV_STORE_SIMPLE \ 322 assert(av) 323 #endif 324 /* PERL_CALLCONV SSize_t av_tindex(pTHX_ AV *av) 325 __attribute__warn_unused_result__; */ 326 #define PERL_ARGS_ASSERT_AV_TINDEX 327 328 /* PERL_CALLCONV SSize_t av_top_index(pTHX_ AV *av) 329 __attribute__warn_unused_result__; */ 330 #define PERL_ARGS_ASSERT_AV_TOP_INDEX 331 332 PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av); 333 #define PERL_ARGS_ASSERT_AV_UNDEF \ 334 assert(av) 335 PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num); 336 #define PERL_ARGS_ASSERT_AV_UNSHIFT \ 337 assert(av) 338 PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) 339 __attribute__warn_unused_result__; 340 #define PERL_ARGS_ASSERT_BIND_MATCH \ 341 assert(left); assert(right) 342 343 PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq) 344 __attribute__warn_unused_result__; 345 #define PERL_ARGS_ASSERT_BLOCK_END 346 347 PERL_CALLCONV U8 Perl_block_gimme(pTHX) 348 __attribute__warn_unused_result__; 349 #define PERL_ARGS_ASSERT_BLOCK_GIMME 350 351 PERL_CALLCONV int Perl_block_start(pTHX_ int full) 352 __attribute__warn_unused_result__; 353 #define PERL_ARGS_ASSERT_BLOCK_START 354 355 PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk); 356 #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ 357 assert(hk) 358 PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); 359 #define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO 360 PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); 361 #define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL 362 PERL_CALLCONV void Perl_boot_core_mro(pTHX); 363 #define PERL_ARGS_ASSERT_BOOT_CORE_MRO 364 PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); 365 #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ 366 assert(b); assert(u) 367 PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p); 368 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ 369 assert(s); assert(lenp); assert(is_utf8p) 370 PERL_CALLCONV U8* Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8 ** first_unconverted); 371 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8_LOC \ 372 assert(s); assert(lenp); assert(is_utf8p) 373 PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp); 374 #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ 375 assert(s); assert(lenp) 376 PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv); 377 #define PERL_ARGS_ASSERT_CALL_ARGV \ 378 assert(sub_name); assert(argv) 379 PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); 380 #define PERL_ARGS_ASSERT_CALL_ATEXIT 381 PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList); 382 #define PERL_ARGS_ASSERT_CALL_LIST \ 383 assert(paramList) 384 PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags); 385 #define PERL_ARGS_ASSERT_CALL_METHOD \ 386 assert(methname) 387 PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags); 388 #define PERL_ARGS_ASSERT_CALL_PV \ 389 assert(sub_name) 390 PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, volatile I32 flags); 391 #define PERL_ARGS_ASSERT_CALL_SV \ 392 assert(sv) 393 PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); 394 #define PERL_ARGS_ASSERT_CALLER_CX 395 PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) 396 __attribute__malloc__ 397 __attribute__warn_unused_result__; 398 #define PERL_ARGS_ASSERT_CALLOC 399 400 PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) 401 __attribute__warn_unused_result__; 402 #define PERL_ARGS_ASSERT_CANDO \ 403 assert(statbufp) 404 405 PERL_CALLCONV I32 Perl_cast_i32(NV f) 406 __attribute__warn_unused_result__; 407 #define PERL_ARGS_ASSERT_CAST_I32 408 409 PERL_CALLCONV IV Perl_cast_iv(NV f) 410 __attribute__warn_unused_result__; 411 #define PERL_ARGS_ASSERT_CAST_IV 412 413 PERL_CALLCONV U32 Perl_cast_ulong(NV f) 414 __attribute__warn_unused_result__; 415 #define PERL_ARGS_ASSERT_CAST_ULONG 416 417 PERL_CALLCONV UV Perl_cast_uv(NV f) 418 __attribute__warn_unused_result__; 419 #define PERL_ARGS_ASSERT_CAST_UV 420 421 PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len); 422 #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ 423 assert(s) 424 PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) 425 __attribute__warn_unused_result__; 426 #define PERL_ARGS_ASSERT_CK_ANONCODE \ 427 assert(o) 428 429 PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) 430 __attribute__warn_unused_result__; 431 #define PERL_ARGS_ASSERT_CK_BACKTICK \ 432 assert(o) 433 434 PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) 435 __attribute__warn_unused_result__; 436 #define PERL_ARGS_ASSERT_CK_BITOP \ 437 assert(o) 438 439 PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) 440 __attribute__warn_unused_result__; 441 #define PERL_ARGS_ASSERT_CK_CMP \ 442 assert(o) 443 444 PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) 445 __attribute__warn_unused_result__; 446 #define PERL_ARGS_ASSERT_CK_CONCAT \ 447 assert(o) 448 449 PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) 450 __attribute__warn_unused_result__; 451 #define PERL_ARGS_ASSERT_CK_DEFINED \ 452 assert(o) 453 454 PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) 455 __attribute__warn_unused_result__; 456 #define PERL_ARGS_ASSERT_CK_DELETE \ 457 assert(o) 458 459 PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) 460 __attribute__warn_unused_result__; 461 #define PERL_ARGS_ASSERT_CK_EACH \ 462 assert(o) 463 464 PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv); 465 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ 466 assert(entersubop); assert(namegv); assert(protosv) 467 PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop); 468 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ 469 assert(entersubop) 470 PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv); 471 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ 472 assert(entersubop); assert(namegv); assert(protosv) 473 PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv); 474 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ 475 assert(entersubop); assert(namegv); assert(protosv) 476 PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) 477 __attribute__warn_unused_result__; 478 #define PERL_ARGS_ASSERT_CK_EOF \ 479 assert(o) 480 481 PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) 482 __attribute__warn_unused_result__; 483 #define PERL_ARGS_ASSERT_CK_EVAL \ 484 assert(o) 485 486 PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) 487 __attribute__warn_unused_result__; 488 #define PERL_ARGS_ASSERT_CK_EXEC \ 489 assert(o) 490 491 PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) 492 __attribute__warn_unused_result__; 493 #define PERL_ARGS_ASSERT_CK_EXISTS \ 494 assert(o) 495 496 PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) 497 __attribute__warn_unused_result__; 498 #define PERL_ARGS_ASSERT_CK_FTST \ 499 assert(o) 500 501 PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) 502 __attribute__warn_unused_result__; 503 #define PERL_ARGS_ASSERT_CK_FUN \ 504 assert(o) 505 506 PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) 507 __attribute__warn_unused_result__; 508 #define PERL_ARGS_ASSERT_CK_GLOB \ 509 assert(o) 510 511 PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) 512 __attribute__warn_unused_result__; 513 #define PERL_ARGS_ASSERT_CK_GREP \ 514 assert(o) 515 516 PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) 517 __attribute__warn_unused_result__; 518 #define PERL_ARGS_ASSERT_CK_INDEX \ 519 assert(o) 520 521 PERL_CALLCONV OP * Perl_ck_isa(pTHX_ OP *o) 522 __attribute__warn_unused_result__; 523 #define PERL_ARGS_ASSERT_CK_ISA \ 524 assert(o) 525 526 PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) 527 __attribute__warn_unused_result__; 528 #define PERL_ARGS_ASSERT_CK_JOIN \ 529 assert(o) 530 531 PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) 532 __attribute__warn_unused_result__; 533 #define PERL_ARGS_ASSERT_CK_LENGTH \ 534 assert(o) 535 536 PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) 537 __attribute__warn_unused_result__; 538 #define PERL_ARGS_ASSERT_CK_LFUN \ 539 assert(o) 540 541 PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) 542 __attribute__warn_unused_result__; 543 #define PERL_ARGS_ASSERT_CK_LISTIOB \ 544 assert(o) 545 546 PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) 547 __attribute__warn_unused_result__; 548 #define PERL_ARGS_ASSERT_CK_MATCH \ 549 assert(o) 550 551 PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) 552 __attribute__warn_unused_result__; 553 #define PERL_ARGS_ASSERT_CK_METHOD \ 554 assert(o) 555 556 PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) 557 __attribute__warn_unused_result__; 558 #define PERL_ARGS_ASSERT_CK_NULL \ 559 assert(o) 560 561 PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) 562 __attribute__warn_unused_result__; 563 #define PERL_ARGS_ASSERT_CK_OPEN \ 564 assert(o) 565 566 PERL_CALLCONV OP * Perl_ck_prototype(pTHX_ OP *o) 567 __attribute__warn_unused_result__; 568 #define PERL_ARGS_ASSERT_CK_PROTOTYPE \ 569 assert(o) 570 571 PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) 572 __attribute__warn_unused_result__; 573 #define PERL_ARGS_ASSERT_CK_READLINE \ 574 assert(o) 575 576 PERL_CALLCONV OP * Perl_ck_refassign(pTHX_ OP *o) 577 __attribute__warn_unused_result__; 578 #define PERL_ARGS_ASSERT_CK_REFASSIGN \ 579 assert(o) 580 581 PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) 582 __attribute__warn_unused_result__; 583 #define PERL_ARGS_ASSERT_CK_REPEAT \ 584 assert(o) 585 586 PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) 587 __attribute__warn_unused_result__; 588 #define PERL_ARGS_ASSERT_CK_REQUIRE \ 589 assert(o) 590 591 PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) 592 __attribute__warn_unused_result__; 593 #define PERL_ARGS_ASSERT_CK_RETURN \ 594 assert(o) 595 596 PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) 597 __attribute__warn_unused_result__; 598 #define PERL_ARGS_ASSERT_CK_RFUN \ 599 assert(o) 600 601 PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) 602 __attribute__warn_unused_result__; 603 #define PERL_ARGS_ASSERT_CK_RVCONST \ 604 assert(o) 605 606 PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) 607 __attribute__warn_unused_result__; 608 #define PERL_ARGS_ASSERT_CK_SASSIGN \ 609 assert(o) 610 611 PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) 612 __attribute__warn_unused_result__; 613 #define PERL_ARGS_ASSERT_CK_SELECT \ 614 assert(o) 615 616 PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) 617 __attribute__warn_unused_result__; 618 #define PERL_ARGS_ASSERT_CK_SHIFT \ 619 assert(o) 620 621 PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) 622 __attribute__warn_unused_result__; 623 #define PERL_ARGS_ASSERT_CK_SMARTMATCH \ 624 assert(o) 625 626 PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) 627 __attribute__warn_unused_result__; 628 #define PERL_ARGS_ASSERT_CK_SORT \ 629 assert(o) 630 631 PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) 632 __attribute__warn_unused_result__; 633 #define PERL_ARGS_ASSERT_CK_SPAIR \ 634 assert(o) 635 636 PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) 637 __attribute__warn_unused_result__; 638 #define PERL_ARGS_ASSERT_CK_SPLIT \ 639 assert(o) 640 641 PERL_CALLCONV OP * Perl_ck_stringify(pTHX_ OP *o) 642 __attribute__warn_unused_result__; 643 #define PERL_ARGS_ASSERT_CK_STRINGIFY \ 644 assert(o) 645 646 PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) 647 __attribute__warn_unused_result__; 648 #define PERL_ARGS_ASSERT_CK_SUBR \ 649 assert(o) 650 651 PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) 652 __attribute__warn_unused_result__; 653 #define PERL_ARGS_ASSERT_CK_SUBSTR \ 654 assert(o) 655 656 PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) 657 __attribute__warn_unused_result__; 658 #define PERL_ARGS_ASSERT_CK_SVCONST \ 659 assert(o) 660 661 PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) 662 __attribute__warn_unused_result__; 663 #define PERL_ARGS_ASSERT_CK_TELL \ 664 assert(o) 665 666 PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) 667 __attribute__warn_unused_result__; 668 #define PERL_ARGS_ASSERT_CK_TRUNC \ 669 assert(o) 670 671 PERL_CALLCONV OP * Perl_ck_trycatch(pTHX_ OP *o) 672 __attribute__warn_unused_result__; 673 #define PERL_ARGS_ASSERT_CK_TRYCATCH \ 674 assert(o) 675 676 PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...) 677 __attribute__format__(__printf__,pTHX_2,pTHX_3); 678 #define PERL_ARGS_ASSERT_CK_WARNER \ 679 assert(pat) 680 681 PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) 682 __attribute__format__(__printf__,pTHX_2,pTHX_3); 683 #define PERL_ARGS_ASSERT_CK_WARNER_D \ 684 assert(pat) 685 686 PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w) 687 __attribute__warn_unused_result__ 688 __attribute__pure__; 689 #define PERL_ARGS_ASSERT_CKWARN 690 691 PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w) 692 __attribute__warn_unused_result__ 693 __attribute__pure__; 694 #define PERL_ARGS_ASSERT_CKWARN_D 695 696 PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV* av, bool abandon); 697 #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ 698 assert(av) 699 PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext); 700 #define PERL_ARGS_ASSERT_CLOSEST_COP \ 701 assert(cop) 702 PERL_CALLCONV OP* Perl_cmpchain_extend(pTHX_ I32 type, OP* ch, OP* right) 703 __attribute__warn_unused_result__; 704 #define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND \ 705 assert(ch) 706 707 PERL_CALLCONV OP* Perl_cmpchain_finish(pTHX_ OP* ch) 708 __attribute__warn_unused_result__; 709 #define PERL_ARGS_ASSERT_CMPCHAIN_FINISH \ 710 assert(ch) 711 712 PERL_CALLCONV OP* Perl_cmpchain_start(pTHX_ I32 type, OP* left, OP* right) 713 __attribute__warn_unused_result__; 714 #define PERL_ARGS_ASSERT_CMPCHAIN_START 715 716 PERL_CALLCONV const char * Perl_cntrl_to_mnemonic(const U8 c) 717 __attribute__warn_unused_result__; 718 #define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC 719 720 PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags); 721 #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ 722 assert(cop) 723 PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags); 724 #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ 725 assert(cop); assert(label) 726 PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum); 727 #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ 728 assert(name) 729 PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum); 730 #define PERL_ARGS_ASSERT_CORESUB_OP \ 731 assert(coreargssv) 732 PERL_CALLCONV void Perl_create_eval_scope(pTHX_ OP *retop, U32 flags); 733 #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE 734 PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...) 735 __attribute__noreturn__ 736 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 737 #define PERL_ARGS_ASSERT_CROAK 738 739 PERL_CALLCONV_NO_RET void Perl_croak_caller(const char* pat, ...) 740 __attribute__noreturn__ 741 __attribute__format__null_ok__(__printf__,1,2); 742 #define PERL_ARGS_ASSERT_CROAK_CALLER 743 744 PERL_CALLCONV_NO_RET void Perl_croak_memory_wrap(void) 745 __attribute__noreturn__; 746 #define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP 747 748 PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void) 749 __attribute__noreturn__; 750 #define PERL_ARGS_ASSERT_CROAK_NO_MEM 751 752 PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void) 753 __attribute__noreturn__; 754 #define PERL_ARGS_ASSERT_CROAK_NO_MODIFY 755 756 PERL_CALLCONV_NO_RET void Perl_croak_popstack(void) 757 __attribute__noreturn__; 758 #define PERL_ARGS_ASSERT_CROAK_POPSTACK 759 760 PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) 761 __attribute__noreturn__; 762 #define PERL_ARGS_ASSERT_CROAK_SV \ 763 assert(baseex) 764 765 PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *const params) 766 __attribute__noreturn__; 767 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ 768 assert(cv); assert(params) 769 770 PERL_CALLCONV Signal_t Perl_csighandler1(int sig); 771 #define PERL_ARGS_ASSERT_CSIGHANDLER1 772 PERL_CALLCONV Signal_t Perl_csighandler3(int sig, Siginfo_t *info, void *uap); 773 #define PERL_ARGS_ASSERT_CSIGHANDLER3 774 PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); 775 #define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE 776 #ifndef NO_MATHOMS 777 PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) 778 __attribute__deprecated__ 779 __attribute__warn_unused_result__; 780 #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ 781 assert(o) 782 #endif 783 784 PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) 785 __attribute__warn_unused_result__; 786 #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ 787 assert(o) 788 789 #ifndef NO_MATHOMS 790 PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) 791 __attribute__deprecated__ 792 __attribute__warn_unused_result__; 793 #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ 794 assert(o) 795 #endif 796 797 PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); 798 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ 799 assert(ppaddr); assert(xop) 800 PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags); 801 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ 802 assert(cv) 803 PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto); 804 #define PERL_ARGS_ASSERT_CV_CLONE \ 805 assert(proto) 806 PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target); 807 #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ 808 assert(proto); assert(target) 809 PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv) 810 __attribute__warn_unused_result__; 811 #define PERL_ARGS_ASSERT_CV_CONST_SV 812 813 PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv) 814 __attribute__warn_unused_result__; 815 #define PERL_ARGS_ASSERT_CV_CONST_SV_OR_AV 816 817 PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv); 818 #define PERL_ARGS_ASSERT_CV_FORGET_SLAB 819 PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); 820 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ 821 assert(cv); assert(ckfun_p); assert(ckobj_p) 822 PERL_CALLCONV void Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p); 823 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER_FLAGS \ 824 assert(cv); assert(ckfun_p); assert(ckobj_p); assert(ckflags_p) 825 PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags); 826 #define PERL_ARGS_ASSERT_CV_NAME \ 827 assert(cv) 828 PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj); 829 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ 830 assert(cv); assert(ckfun); assert(ckobj) 831 PERL_CALLCONV void Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags); 832 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \ 833 assert(cv); assert(ckfun); assert(ckobj) 834 PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv); 835 #define PERL_ARGS_ASSERT_CV_UNDEF \ 836 assert(cv) 837 PERL_CALLCONV void Perl_cv_undef_flags(pTHX_ CV* cv, U32 flags); 838 #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ 839 assert(cv) 840 PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv); 841 #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ 842 assert(cv) 843 PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv); 844 #define PERL_ARGS_ASSERT_CVGV_SET \ 845 assert(cv) 846 PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash); 847 #define PERL_ARGS_ASSERT_CVSTASH_SET \ 848 assert(cv) 849 PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx); 850 #define PERL_ARGS_ASSERT_CX_DUMP \ 851 assert(cx) 852 PERL_CALLCONV I32 Perl_cxinc(pTHX) 853 __attribute__warn_unused_result__; 854 #define PERL_ARGS_ASSERT_CXINC 855 856 PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) 857 __attribute__format__(__printf__,pTHX_1,pTHX_2); 858 #define PERL_ARGS_ASSERT_DEB \ 859 assert(pat) 860 861 PERL_CALLCONV void Perl_deb_stack_all(pTHX); 862 #define PERL_ARGS_ASSERT_DEB_STACK_ALL 863 PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o); 864 #define PERL_ARGS_ASSERT_DEBOP \ 865 assert(o) 866 PERL_CALLCONV void Perl_debprofdump(pTHX); 867 #define PERL_ARGS_ASSERT_DEBPROFDUMP 868 PERL_CALLCONV I32 Perl_debstack(pTHX); 869 #define PERL_ARGS_ASSERT_DEBSTACK 870 PERL_CALLCONV I32 Perl_debstackptrs(pTHX); 871 #define PERL_ARGS_ASSERT_DEBSTACKPTRS 872 PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) 873 __attribute__warn_unused_result__; 874 #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ 875 assert(sv) 876 877 PERL_CALLCONV void Perl_delete_eval_scope(pTHX); 878 #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE 879 PERL_CALLCONV char* Perl_delimcpy(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen); 880 #define PERL_ARGS_ASSERT_DELIMCPY \ 881 assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen) 882 PERL_CALLCONV char* Perl_delimcpy_no_escape(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen); 883 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE \ 884 assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen) 885 PERL_CALLCONV void Perl_despatch_signals(pTHX); 886 #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS 887 PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...) 888 __attribute__noreturn__ 889 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 890 #define PERL_ARGS_ASSERT_DIE 891 892 PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex) 893 __attribute__noreturn__; 894 #define PERL_ARGS_ASSERT_DIE_SV \ 895 assert(baseex) 896 897 PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv) 898 __attribute__noreturn__; 899 #define PERL_ARGS_ASSERT_DIE_UNWIND \ 900 assert(msv) 901 902 #ifndef NO_MATHOMS 903 PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp); 904 #define PERL_ARGS_ASSERT_DO_AEXEC \ 905 assert(mark); assert(sp) 906 #endif 907 PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report); 908 #define PERL_ARGS_ASSERT_DO_AEXEC5 \ 909 assert(mark); assert(sp) 910 #ifndef NO_MATHOMS 911 PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) 912 __attribute__deprecated__; 913 #define PERL_ARGS_ASSERT_DO_BINMODE \ 914 assert(fp) 915 #endif 916 917 PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); 918 #define PERL_ARGS_ASSERT_DO_CLOSE 919 PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full); 920 #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ 921 assert(file) 922 PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv); 923 #define PERL_ARGS_ASSERT_DO_EOF \ 924 assert(gv) 925 PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); 926 #define PERL_ARGS_ASSERT_DO_GV_DUMP \ 927 assert(file); assert(name) 928 PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); 929 #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ 930 assert(file); assert(name) 931 PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv); 932 #define PERL_ARGS_ASSERT_DO_HV_DUMP \ 933 assert(file); assert(name) 934 PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp); 935 #define PERL_ARGS_ASSERT_DO_JOIN \ 936 assert(sv); assert(delim); assert(mark); assert(sp) 937 PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); 938 #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ 939 assert(file) 940 PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV *const left, SV *const right) 941 __attribute__warn_unused_result__; 942 #define PERL_ARGS_ASSERT_DO_NCMP \ 943 assert(left); assert(right) 944 945 PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); 946 #define PERL_ARGS_ASSERT_DO_OP_DUMP \ 947 assert(file) 948 #ifndef NO_MATHOMS 949 PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp); 950 #define PERL_ARGS_ASSERT_DO_OPEN \ 951 assert(gv); assert(name) 952 #endif 953 PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num); 954 #define PERL_ARGS_ASSERT_DO_OPEN6 \ 955 assert(gv); assert(oname) 956 #ifndef NO_MATHOMS 957 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) 958 __attribute__deprecated__; 959 #define PERL_ARGS_ASSERT_DO_OPEN9 \ 960 assert(gv); assert(name); assert(svs) 961 #endif 962 963 PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp); 964 #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ 965 assert(gv); assert(oname) 966 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); 967 #define PERL_ARGS_ASSERT_DO_OPENN \ 968 assert(gv); assert(oname) 969 PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm); 970 #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ 971 assert(file) 972 PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp); 973 #define PERL_ARGS_ASSERT_DO_PRINT \ 974 assert(fp) 975 PERL_CALLCONV OP* Perl_do_readline(pTHX) 976 __attribute__warn_unused_result__; 977 #define PERL_ARGS_ASSERT_DO_READLINE 978 979 PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); 980 #define PERL_ARGS_ASSERT_DO_SEEK 981 PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, SSize_t len, SV** sarg); 982 #define PERL_ARGS_ASSERT_DO_SPRINTF \ 983 assert(sv); assert(sarg) 984 PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); 985 #define PERL_ARGS_ASSERT_DO_SV_DUMP \ 986 assert(file) 987 PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence); 988 #define PERL_ARGS_ASSERT_DO_SYSSEEK \ 989 assert(gv) 990 PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) 991 __attribute__warn_unused_result__; 992 #define PERL_ARGS_ASSERT_DO_TELL \ 993 assert(gv) 994 995 PERL_CALLCONV Size_t Perl_do_trans(pTHX_ SV* sv); 996 #define PERL_ARGS_ASSERT_DO_TRANS \ 997 assert(sv) 998 PERL_CALLCONV I16 Perl_do_uniprop_match(const char * const key, const U16 key_len) 999 __attribute__warn_unused_result__; 1000 #define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH \ 1001 assert(key) 1002 1003 PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, STRLEN offset, int size); 1004 #define PERL_ARGS_ASSERT_DO_VECGET \ 1005 assert(sv) 1006 PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv); 1007 #define PERL_ARGS_ASSERT_DO_VECSET \ 1008 assert(sv) 1009 PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right); 1010 #define PERL_ARGS_ASSERT_DO_VOP \ 1011 assert(sv); assert(left); assert(right) 1012 PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin); 1013 #define PERL_ARGS_ASSERT_DOFILE \ 1014 assert(term) 1015 PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) 1016 __attribute__warn_unused_result__; 1017 #define PERL_ARGS_ASSERT_DOING_TAINT 1018 1019 PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); 1020 #define PERL_ARGS_ASSERT_DOREF \ 1021 assert(o) 1022 PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); 1023 #define PERL_ARGS_ASSERT_DOUNWIND 1024 PERL_CALLCONV U8 Perl_dowantarray(pTHX) 1025 __attribute__warn_unused_result__; 1026 #define PERL_ARGS_ASSERT_DOWANTARRAY 1027 1028 PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); 1029 #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ 1030 assert(random_state) 1031 PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state); 1032 #define PERL_ARGS_ASSERT_DRAND48_R \ 1033 assert(random_state) 1034 PERL_CALLCONV void Perl_dump_all(pTHX); 1035 #define PERL_ARGS_ASSERT_DUMP_ALL 1036 PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); 1037 #define PERL_ARGS_ASSERT_DUMP_ALL_PERL 1038 PERL_CALLCONV void Perl_dump_eval(pTHX); 1039 #define PERL_ARGS_ASSERT_DUMP_EVAL 1040 PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv); 1041 #define PERL_ARGS_ASSERT_DUMP_FORM \ 1042 assert(gv) 1043 PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 1044 __attribute__format__(__printf__,pTHX_3,pTHX_4); 1045 #define PERL_ARGS_ASSERT_DUMP_INDENT \ 1046 assert(file); assert(pat) 1047 1048 PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash); 1049 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ 1050 assert(stash) 1051 PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl); 1052 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ 1053 assert(stash) 1054 PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv); 1055 #define PERL_ARGS_ASSERT_DUMP_SUB \ 1056 assert(gv) 1057 PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl); 1058 #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ 1059 assert(gv) 1060 PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args); 1061 #define PERL_ARGS_ASSERT_DUMP_VINDENT \ 1062 assert(file); assert(pat) 1063 PERL_CALLCONV STRLEN* Perl_dup_warnings(pTHX_ STRLEN* warnings); 1064 #define PERL_ARGS_ASSERT_DUP_WARNINGS 1065 PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv); 1066 #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ 1067 assert(c); assert(sv) 1068 PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error); 1069 #define PERL_ARGS_ASSERT_EVAL_PV \ 1070 assert(p) 1071 PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags); 1072 #define PERL_ARGS_ASSERT_EVAL_SV \ 1073 assert(sv) 1074 PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags); 1075 #define PERL_ARGS_ASSERT_FBM_COMPILE \ 1076 assert(sv) 1077 PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags) 1078 __attribute__warn_unused_result__; 1079 #define PERL_ARGS_ASSERT_FBM_INSTR \ 1080 assert(big); assert(bigend); assert(littlestr) 1081 1082 PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); 1083 #define PERL_ARGS_ASSERT_FILTER_ADD 1084 PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp); 1085 #define PERL_ARGS_ASSERT_FILTER_DEL \ 1086 assert(funcp) 1087 PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) 1088 __attribute__warn_unused_result__; 1089 #define PERL_ARGS_ASSERT_FILTER_READ \ 1090 assert(buf_sv) 1091 1092 PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o); 1093 #define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ 1094 assert(o) 1095 PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off); 1096 #define PERL_ARGS_ASSERT_FIND_LEXICAL_CV 1097 PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) 1098 __attribute__warn_unused_result__; 1099 #define PERL_ARGS_ASSERT_FIND_RUNCV 1100 1101 PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp) 1102 __attribute__warn_unused_result__; 1103 #define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE 1104 1105 PERL_CALLCONV SV* Perl_find_rundefsv(pTHX); 1106 #define PERL_ARGS_ASSERT_FIND_RUNDEFSV 1107 PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) 1108 __attribute__deprecated__; 1109 #define PERL_ARGS_ASSERT_FIND_RUNDEFSVOFFSET 1110 1111 PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags); 1112 #define PERL_ARGS_ASSERT_FIND_SCRIPT \ 1113 assert(scriptname) 1114 #ifndef PERL_NO_INLINE_FUNCTIONS 1115 PERL_STATIC_INLINE I32 Perl_foldEQ(const char* a, const char* b, I32 len); 1116 #define PERL_ARGS_ASSERT_FOLDEQ \ 1117 assert(a); assert(b) 1118 #endif 1119 #ifndef PERL_NO_INLINE_FUNCTIONS 1120 PERL_STATIC_INLINE I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len); 1121 #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ 1122 assert(a); assert(b) 1123 #endif 1124 #ifndef PERL_NO_INLINE_FUNCTIONS 1125 PERL_STATIC_INLINE I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len); 1126 #define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ 1127 assert(a); assert(b) 1128 #endif 1129 /* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ 1130 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8 1131 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); 1132 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ 1133 assert(s1); assert(s2) 1134 PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) 1135 __attribute__format__(__printf__,pTHX_1,pTHX_2); 1136 #define PERL_ARGS_ASSERT_FORM \ 1137 assert(pat) 1138 1139 PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); 1140 #define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL 1141 PERL_CALLCONV void Perl_free_tmps(pTHX); 1142 #define PERL_ARGS_ASSERT_FREE_TMPS 1143 PERL_CALLCONV SV* Perl_get_and_check_backslash_N_name(pTHX_ const char* s, const char* e, const bool is_utf8, const char** error_msg) 1144 __attribute__warn_unused_result__; 1145 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ 1146 assert(s); assert(e); assert(error_msg) 1147 1148 PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags); 1149 #define PERL_ARGS_ASSERT_GET_AV \ 1150 assert(name) 1151 PERL_CALLCONV void* Perl_get_context(void) 1152 __attribute__warn_unused_result__; 1153 #define PERL_ARGS_ASSERT_GET_CONTEXT 1154 1155 PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags); 1156 #define PERL_ARGS_ASSERT_GET_CV \ 1157 assert(name) 1158 PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags); 1159 #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ 1160 assert(name) 1161 PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv); 1162 #define PERL_ARGS_ASSERT_GET_DB_SUB \ 1163 assert(cv) 1164 PERL_CALLCONV const char * Perl_get_deprecated_property_msg(const Size_t warning_offset) 1165 __attribute__warn_unused_result__; 1166 #define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG 1167 1168 PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer); 1169 #define PERL_ARGS_ASSERT_GET_HASH_SEED \ 1170 assert(seed_buffer) 1171 PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags); 1172 #define PERL_ARGS_ASSERT_GET_HV \ 1173 assert(name) 1174 PERL_CALLCONV const char* Perl_get_no_modify(pTHX) 1175 __attribute__warn_unused_result__ 1176 __attribute__pure__; 1177 #define PERL_ARGS_ASSERT_GET_NO_MODIFY 1178 1179 PERL_CALLCONV char** Perl_get_op_descs(pTHX) 1180 __attribute__warn_unused_result__ 1181 __attribute__pure__; 1182 #define PERL_ARGS_ASSERT_GET_OP_DESCS 1183 1184 PERL_CALLCONV char** Perl_get_op_names(pTHX) 1185 __attribute__warn_unused_result__ 1186 __attribute__pure__; 1187 #define PERL_ARGS_ASSERT_GET_OP_NAMES 1188 1189 PERL_CALLCONV U32* Perl_get_opargs(pTHX) 1190 __attribute__warn_unused_result__ 1191 __attribute__pure__; 1192 #define PERL_ARGS_ASSERT_GET_OPARGS 1193 1194 PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) 1195 __attribute__warn_unused_result__ 1196 __attribute__pure__; 1197 #define PERL_ARGS_ASSERT_GET_PPADDR 1198 1199 PERL_CALLCONV SV * Perl_get_prop_definition(pTHX_ const int table_index) 1200 __attribute__warn_unused_result__; 1201 #define PERL_ARGS_ASSERT_GET_PROP_DEFINITION 1202 1203 PERL_CALLCONV const char * const * Perl_get_prop_values(const int table_index) 1204 __attribute__warn_unused_result__; 1205 #define PERL_ARGS_ASSERT_GET_PROP_VALUES 1206 1207 PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); 1208 #define PERL_ARGS_ASSERT_GET_RE_ARG 1209 PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags); 1210 #define PERL_ARGS_ASSERT_GET_SV \ 1211 assert(name) 1212 PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) 1213 __attribute__warn_unused_result__; 1214 #define PERL_ARGS_ASSERT_GET_VTBL 1215 1216 PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv); 1217 #define PERL_ARGS_ASSERT_GETCWD_SV \ 1218 assert(sv) 1219 PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); 1220 #define PERL_ARGS_ASSERT_GP_FREE 1221 PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); 1222 #define PERL_ARGS_ASSERT_GP_REF 1223 PERL_CALLCONV bool Perl_grok_atoUV(const char* pv, UV* valptr, const char** endptr); 1224 #define PERL_ARGS_ASSERT_GROK_ATOUV \ 1225 assert(pv); assert(valptr) 1226 PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); 1227 #define PERL_ARGS_ASSERT_GROK_BIN \ 1228 assert(start); assert(len_p); assert(flags) 1229 PERL_CALLCONV UV Perl_grok_bin_oct_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix); 1230 #define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX \ 1231 assert(start); assert(len_p); assert(flags) 1232 PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); 1233 #define PERL_ARGS_ASSERT_GROK_HEX \ 1234 assert(start); assert(len_p); assert(flags) 1235 PERL_CALLCONV int Perl_grok_infnan(pTHX_ const char** sp, const char *send); 1236 #define PERL_ARGS_ASSERT_GROK_INFNAN \ 1237 assert(sp); assert(send) 1238 PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep); 1239 #define PERL_ARGS_ASSERT_GROK_NUMBER \ 1240 assert(pv) 1241 PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags); 1242 #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ 1243 assert(pv) 1244 PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) 1245 __attribute__warn_unused_result__; 1246 #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ 1247 assert(sp); assert(send) 1248 1249 PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result); 1250 #define PERL_ARGS_ASSERT_GROK_OCT \ 1251 assert(start); assert(len_p); assert(flags) 1252 #ifndef NO_MATHOMS 1253 PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); 1254 #define PERL_ARGS_ASSERT_GV_AVADD 1255 #endif 1256 #ifndef NO_MATHOMS 1257 PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); 1258 #define PERL_ARGS_ASSERT_GV_HVADD 1259 #endif 1260 #ifndef NO_MATHOMS 1261 PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); 1262 #define PERL_ARGS_ASSERT_GV_IOADD 1263 #endif 1264 PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); 1265 #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE 1266 /* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) 1267 __attribute__warn_unused_result__; */ 1268 #define PERL_ARGS_ASSERT_GV_AUTOLOAD4 1269 1270 PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags) 1271 __attribute__warn_unused_result__; 1272 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ 1273 assert(namepv) 1274 1275 PERL_CALLCONV GV* Perl_gv_autoload_pvn(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags) 1276 __attribute__warn_unused_result__; 1277 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ 1278 assert(name) 1279 1280 PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags) 1281 __attribute__warn_unused_result__; 1282 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ 1283 assert(namesv) 1284 1285 PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash); 1286 #define PERL_ARGS_ASSERT_GV_CHECK \ 1287 assert(stash) 1288 PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) 1289 __attribute__warn_unused_result__; 1290 #define PERL_ARGS_ASSERT_GV_CONST_SV \ 1291 assert(gv) 1292 1293 PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv); 1294 #define PERL_ARGS_ASSERT_GV_DUMP 1295 #ifndef NO_MATHOMS 1296 PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) 1297 __attribute__deprecated__; 1298 #define PERL_ARGS_ASSERT_GV_EFULLNAME \ 1299 assert(sv); assert(gv) 1300 #endif 1301 1302 #ifndef NO_MATHOMS 1303 PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); 1304 #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ 1305 assert(sv); assert(gv) 1306 #endif 1307 PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain); 1308 #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ 1309 assert(sv); assert(gv) 1310 PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name); 1311 #define PERL_ARGS_ASSERT_GV_FETCHFILE \ 1312 assert(name) 1313 PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags); 1314 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ 1315 assert(name) 1316 /* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ 1317 #define PERL_ARGS_ASSERT_GV_FETCHMETH 1318 /* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level); */ 1319 #define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD 1320 PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags); 1321 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ 1322 assert(name) 1323 PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags); 1324 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ 1325 assert(name) 1326 PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags); 1327 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ 1328 assert(name) 1329 PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags); 1330 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ 1331 assert(name) 1332 PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags); 1333 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ 1334 assert(namesv) 1335 PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags); 1336 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ 1337 assert(namesv) 1338 #ifndef NO_MATHOMS 1339 PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name); 1340 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ 1341 assert(stash); assert(name) 1342 #endif 1343 PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload); 1344 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ 1345 assert(stash); assert(name) 1346 PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags); 1347 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ 1348 assert(stash); assert(name) 1349 PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags); 1350 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ 1351 assert(stash); assert(name) 1352 PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags); 1353 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ 1354 assert(stash); assert(namesv) 1355 PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type); 1356 #define PERL_ARGS_ASSERT_GV_FETCHPV \ 1357 assert(nambeg) 1358 PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type); 1359 #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ 1360 assert(name) 1361 PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); 1362 #define PERL_ARGS_ASSERT_GV_FETCHSV \ 1363 assert(name) 1364 #ifndef NO_MATHOMS 1365 PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv) 1366 __attribute__deprecated__; 1367 #define PERL_ARGS_ASSERT_GV_FULLNAME \ 1368 assert(sv); assert(gv) 1369 #endif 1370 1371 #ifndef NO_MATHOMS 1372 PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); 1373 #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ 1374 assert(sv); assert(gv) 1375 #endif 1376 PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain); 1377 #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ 1378 assert(sv); assert(gv) 1379 PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) 1380 __attribute__warn_unused_result__; 1381 #define PERL_ARGS_ASSERT_GV_HANDLER 1382 1383 /* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi); */ 1384 #define PERL_ARGS_ASSERT_GV_INIT 1385 PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags); 1386 #define PERL_ARGS_ASSERT_GV_INIT_PV \ 1387 assert(gv); assert(name) 1388 PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags); 1389 #define PERL_ARGS_ASSERT_GV_INIT_PVN \ 1390 assert(gv); assert(name) 1391 PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags); 1392 #define PERL_ARGS_ASSERT_GV_INIT_SV \ 1393 assert(gv); assert(namesv) 1394 PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags); 1395 #define PERL_ARGS_ASSERT_GV_NAME_SET \ 1396 assert(gv); assert(name) 1397 PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len); 1398 #define PERL_ARGS_ASSERT_GV_OVERRIDE \ 1399 assert(name) 1400 PERL_CALLCONV void Perl_gv_setref(pTHX_ SV *const dsv, SV *const ssv); 1401 #define PERL_ARGS_ASSERT_GV_SETREF \ 1402 assert(dsv); assert(ssv) 1403 PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags); 1404 #define PERL_ARGS_ASSERT_GV_STASHPV \ 1405 assert(name) 1406 PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags); 1407 #define PERL_ARGS_ASSERT_GV_STASHPVN \ 1408 assert(name) 1409 PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags); 1410 #define PERL_ARGS_ASSERT_GV_STASHSV \ 1411 assert(sv) 1412 PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv); 1413 #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ 1414 assert(gv) 1415 PERL_CALLCONV struct xpvhv_aux* Perl_hv_auxalloc(pTHX_ HV *hv); 1416 #define PERL_ARGS_ASSERT_HV_AUXALLOC \ 1417 assert(hv) 1418 PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv); 1419 #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ 1420 assert(hv) 1421 PERL_CALLCONV SV* Perl_hv_bucket_ratio(pTHX_ HV *hv) 1422 __attribute__warn_unused_result__; 1423 #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO \ 1424 assert(hv) 1425 1426 PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); 1427 #define PERL_ARGS_ASSERT_HV_CLEAR 1428 PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv); 1429 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ 1430 assert(hv) 1431 PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); 1432 #define PERL_ARGS_ASSERT_HV_COMMON 1433 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); 1434 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ 1435 assert(key) 1436 PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv) 1437 __attribute__warn_unused_result__; 1438 #define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV 1439 1440 PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry); 1441 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ 1442 assert(hv) 1443 #ifndef NO_MATHOMS 1444 PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); 1445 #define PERL_ARGS_ASSERT_HV_DELETE \ 1446 assert(key) 1447 #endif 1448 #ifndef NO_MATHOMS 1449 PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); 1450 #define PERL_ARGS_ASSERT_HV_DELETE_ENT \ 1451 assert(keysv) 1452 #endif 1453 PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv) 1454 __attribute__warn_unused_result__; 1455 #define PERL_ARGS_ASSERT_HV_EITER_P \ 1456 assert(hv) 1457 1458 PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter); 1459 #define PERL_ARGS_ASSERT_HV_EITER_SET \ 1460 assert(hv) 1461 PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags); 1462 #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ 1463 assert(hv); assert(name) 1464 PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags); 1465 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ 1466 assert(hv); assert(name) 1467 #ifndef NO_MATHOMS 1468 PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) 1469 __attribute__warn_unused_result__; 1470 #define PERL_ARGS_ASSERT_HV_EXISTS \ 1471 assert(key) 1472 #endif 1473 1474 #ifndef NO_MATHOMS 1475 PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) 1476 __attribute__warn_unused_result__; 1477 #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ 1478 assert(keysv) 1479 #endif 1480 1481 #ifndef NO_MATHOMS 1482 PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); 1483 #define PERL_ARGS_ASSERT_HV_FETCH \ 1484 assert(key) 1485 #endif 1486 #ifndef NO_MATHOMS 1487 PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); 1488 #define PERL_ARGS_ASSERT_HV_FETCH_ENT \ 1489 assert(keysv) 1490 #endif 1491 PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv); 1492 #define PERL_ARGS_ASSERT_HV_FILL \ 1493 assert(hv) 1494 PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry); 1495 #define PERL_ARGS_ASSERT_HV_FREE_ENT \ 1496 assert(hv) 1497 PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv); 1498 #define PERL_ARGS_ASSERT_HV_ITERINIT \ 1499 assert(hv) 1500 PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen) 1501 __attribute__warn_unused_result__; 1502 #define PERL_ARGS_ASSERT_HV_ITERKEY \ 1503 assert(entry); assert(retlen) 1504 1505 PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry) 1506 __attribute__warn_unused_result__; 1507 #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ 1508 assert(entry) 1509 1510 #ifndef NO_MATHOMS 1511 PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv) 1512 __attribute__warn_unused_result__; 1513 #define PERL_ARGS_ASSERT_HV_ITERNEXT \ 1514 assert(hv) 1515 #endif 1516 1517 PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) 1518 __attribute__warn_unused_result__; 1519 #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ 1520 assert(hv) 1521 1522 PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) 1523 __attribute__warn_unused_result__; 1524 #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ 1525 assert(hv); assert(key); assert(retlen) 1526 1527 PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV *hv, HE *entry) 1528 __attribute__warn_unused_result__; 1529 #define PERL_ARGS_ASSERT_HV_ITERVAL \ 1530 assert(hv); assert(entry) 1531 1532 PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); 1533 #define PERL_ARGS_ASSERT_HV_KSPLIT \ 1534 assert(hv) 1535 #ifndef NO_MATHOMS 1536 PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); 1537 #define PERL_ARGS_ASSERT_HV_MAGIC \ 1538 assert(hv) 1539 #endif 1540 PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); 1541 #define PERL_ARGS_ASSERT_HV_NAME_SET \ 1542 assert(hv) 1543 PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) 1544 __attribute__warn_unused_result__; 1545 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ 1546 assert(hv) 1547 1548 PERL_CALLCONV SSize_t* Perl_hv_placeholders_p(pTHX_ HV *hv) 1549 __attribute__warn_unused_result__; 1550 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ 1551 assert(hv) 1552 1553 PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph); 1554 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ 1555 assert(hv) 1556 PERL_CALLCONV void Perl_hv_pushkv(pTHX_ HV *hv, U32 flags); 1557 #define PERL_ARGS_ASSERT_HV_PUSHKV \ 1558 assert(hv) 1559 PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand); 1560 #define PERL_ARGS_ASSERT_HV_RAND_SET \ 1561 assert(hv) 1562 PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv) 1563 __attribute__warn_unused_result__; 1564 #define PERL_ARGS_ASSERT_HV_RITER_P \ 1565 assert(hv) 1566 1567 PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter); 1568 #define PERL_ARGS_ASSERT_HV_RITER_SET \ 1569 assert(hv) 1570 PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv) 1571 __attribute__warn_unused_result__; 1572 #define PERL_ARGS_ASSERT_HV_SCALAR \ 1573 assert(hv) 1574 1575 #ifndef NO_MATHOMS 1576 PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); 1577 #define PERL_ARGS_ASSERT_HV_STORE 1578 #endif 1579 #ifndef NO_MATHOMS 1580 PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); 1581 #define PERL_ARGS_ASSERT_HV_STORE_ENT 1582 #endif 1583 #ifndef NO_MATHOMS 1584 PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); 1585 #define PERL_ARGS_ASSERT_HV_STORE_FLAGS 1586 #endif 1587 /* PERL_CALLCONV void hv_undef(pTHX_ HV *hv); */ 1588 #define PERL_ARGS_ASSERT_HV_UNDEF 1589 PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); 1590 #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS 1591 /* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len) 1592 __attribute__warn_unused_result__ 1593 __attribute__pure__; */ 1594 #define PERL_ARGS_ASSERT_IBCMP 1595 1596 /* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len) 1597 __attribute__warn_unused_result__ 1598 __attribute__pure__; */ 1599 #define PERL_ARGS_ASSERT_IBCMP_LOCALE 1600 1601 /* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ 1602 #define PERL_ARGS_ASSERT_IBCMP_UTF8 1603 PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv); 1604 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ 1605 assert(argv) 1606 PERL_CALLCONV void Perl_init_constants(pTHX); 1607 #define PERL_ARGS_ASSERT_INIT_CONSTANTS 1608 PERL_CALLCONV void Perl_init_dbargs(pTHX); 1609 #define PERL_ARGS_ASSERT_INIT_DBARGS 1610 PERL_CALLCONV void Perl_init_debugger(pTHX); 1611 #define PERL_ARGS_ASSERT_INIT_DEBUGGER 1612 PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); 1613 #define PERL_ARGS_ASSERT_INIT_I18NL10N 1614 #ifndef NO_MATHOMS 1615 PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn) 1616 __attribute__deprecated__; 1617 #define PERL_ARGS_ASSERT_INIT_I18NL14N 1618 #endif 1619 1620 PERL_CALLCONV void Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); 1621 #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ 1622 assert(cv); assert(nameop) 1623 PERL_CALLCONV void Perl_init_stacks(pTHX); 1624 #define PERL_ARGS_ASSERT_INIT_STACKS 1625 PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm); 1626 #define PERL_ARGS_ASSERT_INIT_TM \ 1627 assert(ptm) 1628 PERL_CALLCONV void Perl_init_uniprops(pTHX); 1629 #define PERL_ARGS_ASSERT_INIT_UNIPROPS 1630 #ifndef NO_MATHOMS 1631 PERL_CALLCONV char* Perl_instr(const char* big, const char* little) 1632 __attribute__warn_unused_result__ 1633 __attribute__pure__; 1634 #define PERL_ARGS_ASSERT_INSTR \ 1635 assert(big); assert(little) 1636 #endif 1637 1638 PERL_CALLCONV U32 Perl_intro_my(pTHX); 1639 #define PERL_ARGS_ASSERT_INTRO_MY 1640 PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) 1641 __attribute__warn_unused_result__; 1642 #define PERL_ARGS_ASSERT_INVERT 1643 1644 PERL_CALLCONV void Perl_invmap_dump(pTHX_ SV* invlist, UV * map); 1645 #define PERL_ARGS_ASSERT_INVMAP_DUMP \ 1646 assert(invlist); assert(map) 1647 PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail); 1648 #define PERL_ARGS_ASSERT_IO_CLOSE \ 1649 assert(io) 1650 #ifndef PERL_NO_INLINE_FUNCTIONS 1651 PERL_STATIC_INLINE Size_t Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) 1652 __attribute__warn_unused_result__; 1653 #define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ 1654 assert(s0); assert(e) 1655 #endif 1656 1657 #ifndef PERL_NO_INLINE_FUNCTIONS 1658 PERL_STATIC_INLINE Size_t Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) 1659 __attribute__warn_unused_result__; 1660 #define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ 1661 assert(s0); assert(e) 1662 #endif 1663 1664 #ifndef PERL_NO_INLINE_FUNCTIONS 1665 PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) 1666 __attribute__warn_unused_result__; 1667 #define PERL_ARGS_ASSERT_ISUTF8_CHAR \ 1668 assert(s0); assert(e) 1669 #endif 1670 1671 #ifndef PERL_NO_INLINE_FUNCTIONS 1672 PERL_STATIC_INLINE Size_t Perl_isUTF8_CHAR_flags(const U8 * const s0, const U8 * const e, const U32 flags) 1673 __attribute__warn_unused_result__; 1674 #define PERL_ARGS_ASSERT_ISUTF8_CHAR_FLAGS \ 1675 assert(s0); assert(e) 1676 #endif 1677 1678 /* PERL_CALLCONV bool is_ascii_string(const U8* const s, STRLEN len) 1679 __attribute__warn_unused_result__ 1680 __attribute__pure__; */ 1681 #define PERL_ARGS_ASSERT_IS_ASCII_STRING 1682 1683 /* PERL_CALLCONV bool is_c9strict_utf8_string(const U8 *s, STRLEN len) 1684 __attribute__warn_unused_result__; */ 1685 #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING 1686 1687 /* PERL_CALLCONV bool is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ 1688 #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOC 1689 #ifndef PERL_NO_INLINE_FUNCTIONS 1690 PERL_STATIC_INLINE bool Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 1691 #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ 1692 assert(s) 1693 #endif 1694 /* PERL_CALLCONV bool is_invariant_string(const U8* const s, STRLEN len) 1695 __attribute__warn_unused_result__ 1696 __attribute__pure__; */ 1697 #define PERL_ARGS_ASSERT_IS_INVARIANT_STRING 1698 1699 PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) 1700 __attribute__warn_unused_result__; 1701 #define PERL_ARGS_ASSERT_IS_LVALUE_SUB 1702 1703 #ifndef PERL_NO_INLINE_FUNCTIONS 1704 PERL_STATIC_INLINE bool Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) 1705 __attribute__warn_unused_result__; 1706 #define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ 1707 assert(pv); assert(what); assert(op_name) 1708 #endif 1709 1710 /* PERL_CALLCONV bool is_strict_utf8_string(const U8 *s, STRLEN len) 1711 __attribute__warn_unused_result__; */ 1712 #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING 1713 1714 /* PERL_CALLCONV bool is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ 1715 #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOC 1716 #ifndef PERL_NO_INLINE_FUNCTIONS 1717 PERL_STATIC_INLINE bool Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 1718 #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ 1719 assert(s) 1720 #endif 1721 PERL_CALLCONV Size_t Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial) 1722 __attribute__warn_unused_result__ 1723 __attribute__pure__; 1724 #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ 1725 assert(s0); assert(e) 1726 1727 #ifndef NO_MATHOMS 1728 PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) 1729 __attribute__deprecated__; 1730 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR \ 1731 assert(s) 1732 #endif 1733 1734 #ifndef NO_MATHOMS 1735 PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); 1736 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ 1737 assert(buf); assert(buf_end) 1738 #endif 1739 PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 * e, const U32 flags) 1740 __attribute__warn_unused_result__ 1741 __attribute__pure__; 1742 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_ \ 1743 assert(s); assert(e) 1744 1745 /* PERL_CALLCONV bool is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ 1746 #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_FLAGS 1747 /* PERL_CALLCONV bool is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ 1748 #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS 1749 #ifndef PERL_NO_INLINE_FUNCTIONS 1750 PERL_STATIC_INLINE bool Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); 1751 #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ 1752 assert(s) 1753 #endif 1754 /* PERL_CALLCONV bool is_utf8_invariant_string(const U8* const s, STRLEN len) 1755 __attribute__warn_unused_result__; */ 1756 #define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING 1757 1758 #ifndef PERL_NO_INLINE_FUNCTIONS 1759 PERL_STATIC_INLINE bool Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) 1760 __attribute__warn_unused_result__; 1761 #define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ 1762 assert(s) 1763 #endif 1764 1765 /* PERL_CALLCONV bool is_utf8_string(const U8 *s, STRLEN len) 1766 __attribute__warn_unused_result__; */ 1767 #define PERL_ARGS_ASSERT_IS_UTF8_STRING 1768 1769 #ifndef PERL_NO_INLINE_FUNCTIONS 1770 PERL_STATIC_INLINE bool Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) 1771 __attribute__warn_unused_result__; 1772 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ 1773 assert(s) 1774 #endif 1775 1776 #ifndef NO_MATHOMS 1777 PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); 1778 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ 1779 assert(s); assert(ep) 1780 #endif 1781 /* PERL_CALLCONV bool is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */ 1782 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC_FLAGS 1783 #ifndef PERL_NO_INLINE_FUNCTIONS 1784 PERL_STATIC_INLINE bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 1785 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ 1786 assert(s) 1787 #endif 1788 #ifndef PERL_NO_INLINE_FUNCTIONS 1789 PERL_STATIC_INLINE bool Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); 1790 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ 1791 assert(s) 1792 #endif 1793 /* PERL_CALLCONV bool is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) 1794 __attribute__warn_unused_result__ 1795 __attribute__pure__; */ 1796 #define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR 1797 1798 #ifndef PERL_NO_INLINE_FUNCTIONS 1799 PERL_STATIC_INLINE bool Perl_is_utf8_valid_partial_char_flags(const U8 * const s0, const U8 * const e, const U32 flags) 1800 __attribute__warn_unused_result__; 1801 #define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ 1802 assert(s0); assert(e) 1803 #endif 1804 1805 PERL_CALLCONV bool Perl_isinfnan(NV nv) 1806 __attribute__warn_unused_result__ 1807 __attribute__pure__; 1808 #define PERL_ARGS_ASSERT_ISINFNAN 1809 1810 PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv); 1811 #define PERL_ARGS_ASSERT_ISINFNANSV \ 1812 assert(sv) 1813 PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o); 1814 #define PERL_ARGS_ASSERT_JMAYBE \ 1815 assert(o) 1816 PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) 1817 __attribute__warn_unused_result__ 1818 __attribute__pure__; 1819 #define PERL_ARGS_ASSERT_KEYWORD \ 1820 assert(name) 1821 1822 PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr); 1823 #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ 1824 assert(keyword_ptr); assert(op_ptr) 1825 PERL_CALLCONV void Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter); 1826 #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ 1827 assert(from_sp); assert(to_sp) 1828 PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); 1829 #define PERL_ARGS_ASSERT_LEAVE_SCOPE 1830 PERL_CALLCONV bool Perl_lex_bufutf8(pTHX); 1831 #define PERL_ARGS_ASSERT_LEX_BUFUTF8 1832 PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr); 1833 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ 1834 assert(ptr) 1835 PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len); 1836 #define PERL_ARGS_ASSERT_LEX_GROW_LINESTR 1837 PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags); 1838 #define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK 1839 PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags); 1840 #define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR 1841 PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags); 1842 #define PERL_ARGS_ASSERT_LEX_READ_SPACE 1843 PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr); 1844 #define PERL_ARGS_ASSERT_LEX_READ_TO \ 1845 assert(ptr) 1846 PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); 1847 #define PERL_ARGS_ASSERT_LEX_READ_UNICHAR 1848 PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags); 1849 #define PERL_ARGS_ASSERT_LEX_START 1850 PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags); 1851 #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ 1852 assert(pv) 1853 PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char* pv, STRLEN len, U32 flags); 1854 #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ 1855 assert(pv) 1856 PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags); 1857 #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ 1858 assert(sv) 1859 PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr); 1860 #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ 1861 assert(ptr) 1862 PERL_CALLCONV OP* Perl_list(pTHX_ OP* o); 1863 #define PERL_ARGS_ASSERT_LIST 1864 PERL_CALLCONV HV* Perl_load_charnames(pTHX_ SV * char_name, const char * context, const STRLEN context_len, const char ** error_msg) 1865 __attribute__warn_unused_result__; 1866 #define PERL_ARGS_ASSERT_LOAD_CHARNAMES \ 1867 assert(char_name); assert(context); assert(error_msg) 1868 1869 PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...); 1870 #define PERL_ARGS_ASSERT_LOAD_MODULE \ 1871 assert(name) 1872 PERL_CALLCONV OP* Perl_localize(pTHX_ OP *o, I32 lex); 1873 #define PERL_ARGS_ASSERT_LOCALIZE \ 1874 assert(o) 1875 PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV *const sv) 1876 __attribute__warn_unused_result__; 1877 #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ 1878 assert(sv) 1879 1880 #ifndef PERL_NO_INLINE_FUNCTIONS 1881 PERL_STATIC_INLINE unsigned Perl_lsbit_pos32(U32 word) 1882 __attribute__warn_unused_result__; 1883 #define PERL_ARGS_ASSERT_LSBIT_POS32 1884 #endif 1885 1886 PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg); 1887 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ 1888 assert(sv); assert(mg) 1889 PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg); 1890 #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ 1891 assert(sv); assert(mg) 1892 PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg); 1893 #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ 1894 assert(sv); assert(mg) 1895 PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg); 1896 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ 1897 assert(sv); assert(mg) 1898 PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg); 1899 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ 1900 assert(sv); assert(mg) 1901 PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg); 1902 #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ 1903 assert(mg) 1904 PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg); 1905 #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ 1906 assert(sv); assert(mg) 1907 PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg); 1908 #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ 1909 assert(sv); assert(mg) 1910 PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen); 1911 #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ 1912 assert(sv); assert(mg); assert(nsv) 1913 PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); 1914 #define PERL_ARGS_ASSERT_MAGIC_DUMP 1915 PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg); 1916 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ 1917 assert(sv); assert(mg) 1918 PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg); 1919 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ 1920 assert(sv); assert(mg) 1921 PERL_CALLCONV int Perl_magic_freemglob(pTHX_ SV* sv, MAGIC* mg); 1922 #define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB \ 1923 assert(sv); assert(mg) 1924 PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg); 1925 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ 1926 assert(sv); assert(mg) 1927 PERL_CALLCONV int Perl_magic_freeutf8(pTHX_ SV* sv, MAGIC* mg); 1928 #define PERL_ARGS_ASSERT_MAGIC_FREEUTF8 \ 1929 assert(sv); assert(mg) 1930 PERL_CALLCONV int Perl_magic_get(pTHX_ SV* sv, MAGIC* mg); 1931 #define PERL_ARGS_ASSERT_MAGIC_GET \ 1932 assert(sv); assert(mg) 1933 PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV* sv, const MAGIC* mg); 1934 #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ 1935 assert(sv); assert(mg) 1936 PERL_CALLCONV int Perl_magic_getdebugvar(pTHX_ SV* sv, MAGIC* mg); 1937 #define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR \ 1938 assert(sv); assert(mg) 1939 PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg); 1940 #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ 1941 assert(sv); assert(mg) 1942 PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV* sv, MAGIC* mg); 1943 #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ 1944 assert(sv); assert(mg) 1945 PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV* sv, MAGIC* mg); 1946 #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ 1947 assert(sv); assert(mg) 1948 PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV* sv, MAGIC* mg); 1949 #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ 1950 assert(sv); assert(mg) 1951 PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV* sv, MAGIC* mg); 1952 #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ 1953 assert(sv); assert(mg) 1954 PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV* sv, MAGIC* mg); 1955 #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ 1956 assert(sv); assert(mg) 1957 PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV* sv, MAGIC* mg); 1958 #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ 1959 assert(sv); assert(mg) 1960 PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV* sv, MAGIC* mg); 1961 #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ 1962 assert(sv); assert(mg) 1963 PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV* sv, MAGIC* mg); 1964 #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ 1965 assert(sv); assert(mg) 1966 PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg); 1967 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ 1968 assert(sv); assert(mg) 1969 PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...); 1970 #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ 1971 assert(sv); assert(mg); assert(meth) 1972 PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key); 1973 #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ 1974 assert(sv); assert(mg); assert(key) 1975 PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV* sv, MAGIC* mg); 1976 #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ 1977 assert(sv); assert(mg) 1978 PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg); 1979 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ 1980 assert(sv); assert(mg) 1981 PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg); 1982 #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ 1983 assert(hv); assert(mg) 1984 PERL_CALLCONV int Perl_magic_set(pTHX_ SV* sv, MAGIC* mg); 1985 #define PERL_ARGS_ASSERT_MAGIC_SET \ 1986 assert(sv); assert(mg) 1987 PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg); 1988 #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ 1989 assert(sv); assert(mg) 1990 PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg); 1991 #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ 1992 assert(sv); assert(mg) 1993 PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV* sv, MAGIC* mg); 1994 #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ 1995 assert(sv); assert(mg) 1996 PERL_CALLCONV int Perl_magic_setdebugvar(pTHX_ SV* sv, MAGIC* mg); 1997 #define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR \ 1998 assert(sv); assert(mg) 1999 PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg); 2000 #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ 2001 assert(sv); assert(mg) 2002 PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV* sv, MAGIC* mg); 2003 #define PERL_ARGS_ASSERT_MAGIC_SETENV \ 2004 assert(sv); assert(mg) 2005 PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV* sv, MAGIC* mg); 2006 #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ 2007 assert(sv); assert(mg) 2008 PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV* sv, MAGIC* mg); 2009 #define PERL_ARGS_ASSERT_MAGIC_SETISA \ 2010 assert(sv); assert(mg) 2011 PERL_CALLCONV int Perl_magic_setlvref(pTHX_ SV* sv, MAGIC* mg); 2012 #define PERL_ARGS_ASSERT_MAGIC_SETLVREF \ 2013 assert(sv); assert(mg) 2014 PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg); 2015 #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ 2016 assert(sv); assert(mg) 2017 PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg); 2018 #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ 2019 assert(sv); assert(mg) 2020 PERL_CALLCONV int Perl_magic_setnonelem(pTHX_ SV* sv, MAGIC* mg); 2021 #define PERL_ARGS_ASSERT_MAGIC_SETNONELEM \ 2022 assert(sv); assert(mg) 2023 PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg); 2024 #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ 2025 assert(sv); assert(mg) 2026 PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV* sv, MAGIC* mg); 2027 #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ 2028 assert(sv); assert(mg) 2029 PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg); 2030 #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ 2031 assert(sv); assert(mg) 2032 PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg); 2033 #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ 2034 assert(mg) 2035 PERL_CALLCONV int Perl_magic_setsigall(pTHX_ SV* sv, MAGIC* mg); 2036 #define PERL_ARGS_ASSERT_MAGIC_SETSIGALL \ 2037 assert(sv); assert(mg) 2038 PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg); 2039 #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ 2040 assert(sv); assert(mg) 2041 PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV* sv, MAGIC* mg); 2042 #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ 2043 assert(sv); assert(mg) 2044 PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV* sv, MAGIC* mg); 2045 #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ 2046 assert(sv); assert(mg) 2047 PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV* sv, MAGIC* mg); 2048 #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ 2049 assert(sv); assert(mg) 2050 PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg); 2051 #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ 2052 assert(sv); assert(mg) 2053 PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg); 2054 #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ 2055 assert(sv); assert(mg) 2056 PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg); 2057 #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ 2058 assert(sv); assert(mg) 2059 PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) 2060 __attribute__malloc__ 2061 __attribute__warn_unused_result__; 2062 #define PERL_ARGS_ASSERT_MALLOC 2063 2064 PERL_CALLCONV I32 * Perl_markstack_grow(pTHX); 2065 #define PERL_ARGS_ASSERT_MARKSTACK_GROW 2066 PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) 2067 __attribute__format__(__printf__,pTHX_1,pTHX_2); 2068 #define PERL_ARGS_ASSERT_MESS \ 2069 assert(pat) 2070 2071 PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume); 2072 #define PERL_ARGS_ASSERT_MESS_SV \ 2073 assert(basemsg) 2074 PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); 2075 #define PERL_ARGS_ASSERT_MFREE 2076 PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv); 2077 #define PERL_ARGS_ASSERT_MG_CLEAR \ 2078 assert(sv) 2079 PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen); 2080 #define PERL_ARGS_ASSERT_MG_COPY \ 2081 assert(sv); assert(nsv) 2082 PERL_CALLCONV MAGIC* Perl_mg_find(const SV* sv, int type) 2083 __attribute__warn_unused_result__; 2084 #define PERL_ARGS_ASSERT_MG_FIND 2085 2086 PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) 2087 __attribute__warn_unused_result__; 2088 #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \ 2089 assert(sv) 2090 2091 PERL_CALLCONV MAGIC* Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl) 2092 __attribute__warn_unused_result__; 2093 #define PERL_ARGS_ASSERT_MG_FINDEXT 2094 2095 PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv); 2096 #define PERL_ARGS_ASSERT_MG_FREE \ 2097 assert(sv) 2098 PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV* sv, int how); 2099 #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ 2100 assert(sv) 2101 PERL_CALLCONV void Perl_mg_freeext(pTHX_ SV* sv, int how, const MGVTBL *vtbl); 2102 #define PERL_ARGS_ASSERT_MG_FREEEXT \ 2103 assert(sv) 2104 PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv); 2105 #define PERL_ARGS_ASSERT_MG_GET \ 2106 assert(sv) 2107 PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv) 2108 __attribute__deprecated__; 2109 #define PERL_ARGS_ASSERT_MG_LENGTH \ 2110 assert(sv) 2111 2112 PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic); 2113 #define PERL_ARGS_ASSERT_MG_LOCALIZE \ 2114 assert(sv); assert(nsv) 2115 PERL_CALLCONV void Perl_mg_magical(SV* sv); 2116 #define PERL_ARGS_ASSERT_MG_MAGICAL \ 2117 assert(sv) 2118 PERL_CALLCONV int Perl_mg_set(pTHX_ SV* sv); 2119 #define PERL_ARGS_ASSERT_MG_SET \ 2120 assert(sv) 2121 PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv); 2122 #define PERL_ARGS_ASSERT_MG_SIZE \ 2123 assert(sv) 2124 PERL_CALLCONV void Perl_mini_mktime(struct tm *ptm); 2125 #define PERL_ARGS_ASSERT_MINI_MKTIME \ 2126 assert(ptm) 2127 PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len); 2128 #define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE 2129 PERL_CALLCONV void * Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size); 2130 #define PERL_ARGS_ASSERT_MORE_BODIES 2131 PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s); 2132 #define PERL_ARGS_ASSERT_MORESWITCHES \ 2133 assert(s) 2134 #ifndef PERL_NO_INLINE_FUNCTIONS 2135 PERL_STATIC_INLINE char * Perl_mortal_getenv(const char * str) 2136 __attribute__warn_unused_result__; 2137 #define PERL_ARGS_ASSERT_MORTAL_GETENV \ 2138 assert(str) 2139 #endif 2140 2141 PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name); 2142 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ 2143 assert(name) 2144 PERL_CALLCONV AV* Perl_mro_get_linear_isa(pTHX_ HV* stash); 2145 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ 2146 assert(stash) 2147 PERL_CALLCONV SV* Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which); 2148 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ 2149 assert(smeta); assert(which) 2150 PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV* stash); 2151 #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ 2152 assert(stash) 2153 PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash); 2154 #define PERL_ARGS_ASSERT_MRO_META_INIT \ 2155 assert(stash) 2156 PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV* stash); 2157 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ 2158 assert(stash) 2159 PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags); 2160 #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ 2161 assert(gv) 2162 PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro); 2163 #define PERL_ARGS_ASSERT_MRO_REGISTER \ 2164 assert(mro) 2165 PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name); 2166 #define PERL_ARGS_ASSERT_MRO_SET_MRO \ 2167 assert(meta); assert(name) 2168 PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which, SV *const data); 2169 #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ 2170 assert(smeta); assert(which); assert(data) 2171 #ifndef PERL_NO_INLINE_FUNCTIONS 2172 PERL_STATIC_INLINE unsigned Perl_msbit_pos32(U32 word) 2173 __attribute__warn_unused_result__; 2174 #define PERL_ARGS_ASSERT_MSBIT_POS32 2175 #endif 2176 2177 PERL_CALLCONV SV* Perl_multiconcat_stringify(pTHX_ const OP* o); 2178 #define PERL_ARGS_ASSERT_MULTICONCAT_STRINGIFY \ 2179 assert(o) 2180 PERL_CALLCONV SV* Perl_multideref_stringify(pTHX_ const OP* o, CV *cv); 2181 #define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY \ 2182 assert(o) 2183 PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s); 2184 #define PERL_ARGS_ASSERT_MY_ATOF \ 2185 assert(s) 2186 PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *orig, NV* value); 2187 #define PERL_ARGS_ASSERT_MY_ATOF2 \ 2188 assert(orig); assert(value) 2189 PERL_CALLCONV char* Perl_my_atof3(pTHX_ const char *orig, NV* value, const STRLEN len); 2190 #define PERL_ARGS_ASSERT_MY_ATOF3 \ 2191 assert(orig); assert(value) 2192 PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs); 2193 #define PERL_ARGS_ASSERT_MY_ATTRS \ 2194 assert(o) 2195 PERL_CALLCONV void Perl_my_clearenv(pTHX); 2196 #define PERL_ARGS_ASSERT_MY_CLEARENV 2197 PERL_CALLCONV int Perl_my_dirfd(DIR* dir); 2198 #define PERL_ARGS_ASSERT_MY_DIRFD 2199 PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) 2200 __attribute__noreturn__; 2201 #define PERL_ARGS_ASSERT_MY_EXIT 2202 2203 PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX) 2204 __attribute__noreturn__; 2205 #define PERL_ARGS_ASSERT_MY_FAILURE_EXIT 2206 2207 PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); 2208 #define PERL_ARGS_ASSERT_MY_FFLUSH_ALL 2209 PERL_CALLCONV Pid_t Perl_my_fork(void); 2210 #define PERL_ARGS_ASSERT_MY_FORK 2211 /* PERL_CALLCONV I32 my_lstat(pTHX); */ 2212 #define PERL_ARGS_ASSERT_MY_LSTAT 2213 PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); 2214 #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS 2215 PERL_CALLCONV int Perl_my_mkostemp_cloexec(char *templte, int flags) 2216 __attribute__warn_unused_result__; 2217 #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ 2218 assert(templte) 2219 2220 PERL_CALLCONV int Perl_my_mkstemp_cloexec(char *templte) 2221 __attribute__warn_unused_result__; 2222 #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC \ 2223 assert(templte) 2224 2225 PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args); 2226 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ 2227 assert(mode); assert(args) 2228 PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val); 2229 #define PERL_ARGS_ASSERT_MY_SETENV 2230 PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) 2231 __attribute__format__(__printf__,3,4); 2232 #define PERL_ARGS_ASSERT_MY_SNPRINTF \ 2233 assert(buffer); assert(format) 2234 2235 PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); 2236 #define PERL_ARGS_ASSERT_MY_SOCKETPAIR 2237 /* PERL_CALLCONV I32 my_stat(pTHX); */ 2238 #define PERL_ARGS_ASSERT_MY_STAT 2239 PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); 2240 #define PERL_ARGS_ASSERT_MY_STAT_FLAGS 2241 PERL_CALLCONV char* Perl_my_strerror(pTHX_ const int errnum); 2242 #define PERL_ARGS_ASSERT_MY_STRERROR 2243 PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst) 2244 __attribute__format__(__strftime__,pTHX_1,0); 2245 #define PERL_ARGS_ASSERT_MY_STRFTIME \ 2246 assert(fmt) 2247 2248 PERL_CALLCONV NV Perl_my_strtod(const char * const s, char ** e) 2249 __attribute__warn_unused_result__; 2250 #define PERL_ARGS_ASSERT_MY_STRTOD \ 2251 assert(s) 2252 2253 PERL_CALLCONV void Perl_my_unexec(pTHX); 2254 #define PERL_ARGS_ASSERT_MY_UNEXEC 2255 PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap); 2256 #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ 2257 assert(buffer); assert(format) 2258 PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); 2259 #define PERL_ARGS_ASSERT_NEWANONATTRSUB 2260 PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o) 2261 __attribute__warn_unused_result__; 2262 #define PERL_ARGS_ASSERT_NEWANONHASH 2263 2264 PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o) 2265 __attribute__warn_unused_result__; 2266 #define PERL_ARGS_ASSERT_NEWANONLIST 2267 2268 PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block); 2269 #define PERL_ARGS_ASSERT_NEWANONSUB 2270 PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right) 2271 __attribute__warn_unused_result__; 2272 #define PERL_ARGS_ASSERT_NEWASSIGNOP 2273 2274 /* PERL_CALLCONV CV* newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ 2275 #define PERL_ARGS_ASSERT_NEWATTRSUB 2276 PERL_CALLCONV CV* Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); 2277 #define PERL_ARGS_ASSERT_NEWATTRSUB_X 2278 #ifndef NO_MATHOMS 2279 PERL_CALLCONV AV* Perl_newAV(pTHX) 2280 __attribute__warn_unused_result__; 2281 #define PERL_ARGS_ASSERT_NEWAV 2282 #endif 2283 2284 PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) 2285 __attribute__warn_unused_result__; 2286 #define PERL_ARGS_ASSERT_NEWAVREF \ 2287 assert(o) 2288 2289 /* PERL_CALLCONV AV* newAV_alloc_x(pTHX_ SSize_t size) 2290 __attribute__warn_unused_result__; */ 2291 #define PERL_ARGS_ASSERT_NEWAV_ALLOC_X 2292 2293 /* PERL_CALLCONV AV* newAV_alloc_xz(pTHX_ SSize_t size) 2294 __attribute__warn_unused_result__; */ 2295 #define PERL_ARGS_ASSERT_NEWAV_ALLOC_XZ 2296 2297 PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2298 __attribute__warn_unused_result__; 2299 #define PERL_ARGS_ASSERT_NEWBINOP 2300 2301 PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop) 2302 __attribute__warn_unused_result__; 2303 #define PERL_ARGS_ASSERT_NEWCONDOP \ 2304 assert(first) 2305 2306 PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv); 2307 #define PERL_ARGS_ASSERT_NEWCONSTSUB 2308 PERL_CALLCONV CV* Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv); 2309 #define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS 2310 PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) 2311 __attribute__warn_unused_result__; 2312 #define PERL_ARGS_ASSERT_NEWCVREF 2313 2314 PERL_CALLCONV OP* Perl_newDEFEROP(pTHX_ I32 flags, OP *block) 2315 __attribute__warn_unused_result__; 2316 #define PERL_ARGS_ASSERT_NEWDEFEROP \ 2317 assert(block) 2318 2319 PERL_CALLCONV OP* Perl_newDEFSVOP(pTHX) 2320 __attribute__warn_unused_result__; 2321 #define PERL_ARGS_ASSERT_NEWDEFSVOP 2322 2323 PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 2324 #define PERL_ARGS_ASSERT_NEWFORM 2325 PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont) 2326 __attribute__warn_unused_result__; 2327 #define PERL_ARGS_ASSERT_NEWFOROP \ 2328 assert(expr) 2329 2330 PERL_CALLCONV OP* Perl_newGIVENOP(pTHX_ OP* cond, OP* block, PADOFFSET defsv_off) 2331 __attribute__warn_unused_result__; 2332 #define PERL_ARGS_ASSERT_NEWGIVENOP \ 2333 assert(cond); assert(block) 2334 2335 PERL_CALLCONV GP * Perl_newGP(pTHX_ GV *const gv); 2336 #define PERL_ARGS_ASSERT_NEWGP \ 2337 assert(gv) 2338 PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv) 2339 __attribute__warn_unused_result__; 2340 #define PERL_ARGS_ASSERT_NEWGVOP \ 2341 assert(gv) 2342 2343 PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o) 2344 __attribute__warn_unused_result__; 2345 #define PERL_ARGS_ASSERT_NEWGVREF 2346 2347 /* PERL_CALLCONV GV* newGVgen(pTHX_ const char* pack); */ 2348 #define PERL_ARGS_ASSERT_NEWGVGEN 2349 PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags) 2350 __attribute__warn_unused_result__; 2351 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ 2352 assert(pack) 2353 2354 #ifndef NO_MATHOMS 2355 PERL_CALLCONV HV* Perl_newHV(pTHX) 2356 __attribute__warn_unused_result__; 2357 #define PERL_ARGS_ASSERT_NEWHV 2358 #endif 2359 2360 PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) 2361 __attribute__warn_unused_result__; 2362 #define PERL_ARGS_ASSERT_NEWHVREF \ 2363 assert(o) 2364 2365 PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv) 2366 __attribute__warn_unused_result__; 2367 #define PERL_ARGS_ASSERT_NEWHVHV 2368 2369 #ifndef NO_MATHOMS 2370 PERL_CALLCONV IO* Perl_newIO(pTHX) 2371 __attribute__warn_unused_result__; 2372 #define PERL_ARGS_ASSERT_NEWIO 2373 #endif 2374 2375 PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2376 __attribute__warn_unused_result__; 2377 #define PERL_ARGS_ASSERT_NEWLISTOP 2378 2379 PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) 2380 __attribute__warn_unused_result__; 2381 #define PERL_ARGS_ASSERT_NEWLOGOP \ 2382 assert(first); assert(other) 2383 2384 PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label) 2385 __attribute__warn_unused_result__; 2386 #define PERL_ARGS_ASSERT_NEWLOOPEX \ 2387 assert(label) 2388 2389 PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block) 2390 __attribute__warn_unused_result__; 2391 #define PERL_ARGS_ASSERT_NEWLOOPOP 2392 2393 PERL_CALLCONV OP* Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP* dynamic_meth) 2394 __attribute__warn_unused_result__; 2395 #define PERL_ARGS_ASSERT_NEWMETHOP \ 2396 assert(dynamic_meth) 2397 2398 PERL_CALLCONV OP* Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV* const_meth) 2399 __attribute__warn_unused_result__; 2400 #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \ 2401 assert(const_meth) 2402 2403 PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); 2404 #define PERL_ARGS_ASSERT_NEWMYSUB \ 2405 assert(o) 2406 PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) 2407 __attribute__warn_unused_result__; 2408 #define PERL_ARGS_ASSERT_NEWNULLLIST 2409 2410 PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags) 2411 __attribute__warn_unused_result__; 2412 #define PERL_ARGS_ASSERT_NEWOP 2413 2414 PERL_CALLCONV PADNAMELIST * Perl_newPADNAMELIST(size_t max) 2415 __attribute__warn_unused_result__; 2416 #define PERL_ARGS_ASSERT_NEWPADNAMELIST 2417 2418 PERL_CALLCONV PADNAME * Perl_newPADNAMEouter(PADNAME *outer) 2419 __attribute__warn_unused_result__; 2420 #define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \ 2421 assert(outer) 2422 2423 PERL_CALLCONV PADNAME * Perl_newPADNAMEpvn(const char *s, STRLEN len) 2424 __attribute__warn_unused_result__; 2425 #define PERL_ARGS_ASSERT_NEWPADNAMEPVN \ 2426 assert(s) 2427 2428 PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags) 2429 __attribute__warn_unused_result__; 2430 #define PERL_ARGS_ASSERT_NEWPMOP 2431 2432 PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o); 2433 #define PERL_ARGS_ASSERT_NEWPROG \ 2434 assert(o) 2435 PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv) 2436 __attribute__warn_unused_result__; 2437 #define PERL_ARGS_ASSERT_NEWPVOP 2438 2439 PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right) 2440 __attribute__warn_unused_result__; 2441 #define PERL_ARGS_ASSERT_NEWRANGE \ 2442 assert(left); assert(right) 2443 2444 PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv) 2445 __attribute__warn_unused_result__; 2446 #define PERL_ARGS_ASSERT_NEWRV \ 2447 assert(sv) 2448 2449 PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const tmpRef) 2450 __attribute__warn_unused_result__; 2451 #define PERL_ARGS_ASSERT_NEWRV_NOINC \ 2452 assert(tmpRef) 2453 2454 PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop) 2455 __attribute__warn_unused_result__; 2456 #define PERL_ARGS_ASSERT_NEWSLICEOP 2457 2458 PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) 2459 __attribute__warn_unused_result__; 2460 #define PERL_ARGS_ASSERT_NEWSTATEOP 2461 2462 PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake); 2463 #define PERL_ARGS_ASSERT_NEWSTUB \ 2464 assert(gv) 2465 #ifndef NO_MATHOMS 2466 PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); 2467 #define PERL_ARGS_ASSERT_NEWSUB 2468 #endif 2469 PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) 2470 __attribute__warn_unused_result__; 2471 #define PERL_ARGS_ASSERT_NEWSV 2472 2473 PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv) 2474 __attribute__warn_unused_result__; 2475 #define PERL_ARGS_ASSERT_NEWSVOP \ 2476 assert(sv) 2477 2478 PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o) 2479 __attribute__warn_unused_result__; 2480 #define PERL_ARGS_ASSERT_NEWSVREF \ 2481 assert(o) 2482 2483 PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type) 2484 __attribute__warn_unused_result__; 2485 #define PERL_ARGS_ASSERT_NEWSV_TYPE 2486 2487 PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) 2488 __attribute__warn_unused_result__; 2489 #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \ 2490 assert(av) 2491 2492 PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek) 2493 __attribute__warn_unused_result__; 2494 #define PERL_ARGS_ASSERT_NEWSVHEK 2495 2496 PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i) 2497 __attribute__warn_unused_result__; 2498 #define PERL_ARGS_ASSERT_NEWSVIV 2499 2500 PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n) 2501 __attribute__warn_unused_result__; 2502 #define PERL_ARGS_ASSERT_NEWSVNV 2503 2504 PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len) 2505 __attribute__warn_unused_result__; 2506 #define PERL_ARGS_ASSERT_NEWSVPV 2507 2508 PERL_CALLCONV SV* Perl_newSVpv_share(pTHX_ const char* s, U32 hash) 2509 __attribute__warn_unused_result__; 2510 #define PERL_ARGS_ASSERT_NEWSVPV_SHARE 2511 2512 PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) 2513 __attribute__warn_unused_result__ 2514 __attribute__format__(__printf__,pTHX_1,pTHX_2); 2515 #define PERL_ARGS_ASSERT_NEWSVPVF \ 2516 assert(pat) 2517 2518 PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const buffer, const STRLEN len) 2519 __attribute__warn_unused_result__; 2520 #define PERL_ARGS_ASSERT_NEWSVPVN 2521 2522 PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) 2523 __attribute__warn_unused_result__; 2524 #define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS 2525 2526 PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) 2527 __attribute__warn_unused_result__; 2528 #define PERL_ARGS_ASSERT_NEWSVPVN_SHARE 2529 2530 PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname); 2531 #define PERL_ARGS_ASSERT_NEWSVRV \ 2532 assert(rv) 2533 #ifndef NO_MATHOMS 2534 PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) 2535 __attribute__warn_unused_result__; 2536 #define PERL_ARGS_ASSERT_NEWSVSV 2537 #endif 2538 2539 PERL_CALLCONV SV* Perl_newSVsv_flags(pTHX_ SV *const old, I32 flags) 2540 __attribute__warn_unused_result__; 2541 #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS 2542 2543 /* PERL_CALLCONV SV* newSVsv_nomg(pTHX_ SV *const old) 2544 __attribute__warn_unused_result__; */ 2545 #define PERL_ARGS_ASSERT_NEWSVSV_NOMG 2546 2547 PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) 2548 __attribute__warn_unused_result__; 2549 #define PERL_ARGS_ASSERT_NEWSVUV 2550 2551 PERL_CALLCONV OP* Perl_newTRYCATCHOP(pTHX_ I32 flags, OP* tryblock, OP *catchvar, OP* catchblock) 2552 __attribute__warn_unused_result__; 2553 #define PERL_ARGS_ASSERT_NEWTRYCATCHOP \ 2554 assert(tryblock); assert(catchvar); assert(catchblock) 2555 2556 PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first) 2557 __attribute__warn_unused_result__; 2558 #define PERL_ARGS_ASSERT_NEWUNOP 2559 2560 PERL_CALLCONV OP* Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP* first, UNOP_AUX_item *aux) 2561 __attribute__warn_unused_result__; 2562 #define PERL_ARGS_ASSERT_NEWUNOP_AUX 2563 2564 PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) 2565 __attribute__warn_unused_result__; 2566 #define PERL_ARGS_ASSERT_NEWWHENOP \ 2567 assert(block) 2568 2569 PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my) 2570 __attribute__warn_unused_result__; 2571 #define PERL_ARGS_ASSERT_NEWWHILEOP 2572 2573 PERL_CALLCONV CV* Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename); 2574 #define PERL_ARGS_ASSERT_NEWXS \ 2575 assert(subaddr); assert(filename) 2576 PERL_CALLCONV CV * Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr); 2577 #define PERL_ARGS_ASSERT_NEWXS_DEFFILE \ 2578 assert(name); assert(subaddr) 2579 PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags); 2580 #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ 2581 assert(subaddr); assert(filename) 2582 PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char *const filename, const char *const proto, SV **const_svp, U32 flags); 2583 #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ 2584 assert(subaddr) 2585 PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) 2586 __attribute__warn_unused_result__; 2587 #define PERL_ARGS_ASSERT_NEW_STACKINFO 2588 2589 PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver); 2590 #define PERL_ARGS_ASSERT_NEW_VERSION \ 2591 assert(ver) 2592 PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits, STRLEN size) 2593 __attribute__warn_unused_result__; 2594 #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ 2595 assert(bits) 2596 2597 PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv, bool nomagicopen); 2598 #define PERL_ARGS_ASSERT_NEXTARGV \ 2599 assert(gv) 2600 PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) 2601 __attribute__warn_unused_result__ 2602 __attribute__pure__; 2603 #define PERL_ARGS_ASSERT_NINSTR \ 2604 assert(big); assert(bigend); assert(little); assert(lend) 2605 2606 PERL_CALLCONV void Perl_no_bareword_filehandle(pTHX_ const char *fhname); 2607 #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \ 2608 assert(fhname) 2609 PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...) 2610 __attribute__noreturn__ 2611 __attribute__format__(__printf__,1,2); 2612 #define PERL_ARGS_ASSERT_NOPERL_DIE \ 2613 assert(pat) 2614 2615 PERL_CALLCONV int Perl_nothreadhook(pTHX); 2616 #define PERL_ARGS_ASSERT_NOTHREADHOOK 2617 PERL_CALLCONV void Perl_notify_parser_that_changed_to_utf8(pTHX); 2618 #define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_CHANGED_TO_UTF8 2619 PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) 2620 __attribute__warn_unused_result__; 2621 #define PERL_ARGS_ASSERT_OOPSAV \ 2622 assert(o) 2623 2624 PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) 2625 __attribute__warn_unused_result__; 2626 #define PERL_ARGS_ASSERT_OOPSHV \ 2627 assert(o) 2628 2629 PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last); 2630 #define PERL_ARGS_ASSERT_OP_APPEND_ELEM 2631 PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last); 2632 #define PERL_ARGS_ASSERT_OP_APPEND_LIST 2633 PERL_CALLCONV OPclass Perl_op_class(pTHX_ const OP *o); 2634 #define PERL_ARGS_ASSERT_OP_CLASS 2635 PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o); 2636 #define PERL_ARGS_ASSERT_OP_CLEAR \ 2637 assert(o) 2638 PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context); 2639 #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ 2640 assert(o) 2641 PERL_CALLCONV OP* Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP* o) 2642 __attribute__warn_unused_result__; 2643 #define PERL_ARGS_ASSERT_OP_CONVERT_LIST 2644 2645 PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o); 2646 #define PERL_ARGS_ASSERT_OP_DUMP \ 2647 assert(o) 2648 PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg); 2649 #define PERL_ARGS_ASSERT_OP_FREE 2650 PERL_CALLCONV OP* Perl_op_linklist(pTHX_ OP *o); 2651 #define PERL_ARGS_ASSERT_OP_LINKLIST \ 2652 assert(o) 2653 /* PERL_CALLCONV OP* op_lvalue(pTHX_ OP* o, I32 type); */ 2654 #define PERL_ARGS_ASSERT_OP_LVALUE 2655 PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags); 2656 #define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS 2657 PERL_CALLCONV void Perl_op_null(pTHX_ OP* o); 2658 #define PERL_ARGS_ASSERT_OP_NULL \ 2659 assert(o) 2660 PERL_CALLCONV OP* Perl_op_parent(OP *o); 2661 #define PERL_ARGS_ASSERT_OP_PARENT \ 2662 assert(o) 2663 PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); 2664 #define PERL_ARGS_ASSERT_OP_PREPEND_ELEM 2665 PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); 2666 #define PERL_ARGS_ASSERT_OP_REFCNT_LOCK 2667 PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); 2668 #define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK 2669 PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); 2670 #define PERL_ARGS_ASSERT_OP_SCOPE 2671 PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert); 2672 #define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE 2673 PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); 2674 #define PERL_ARGS_ASSERT_OP_UNSCOPE 2675 PERL_CALLCONV void Perl_optimize_optree(pTHX_ OP* o); 2676 #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ 2677 assert(o) 2678 #ifndef NO_MATHOMS 2679 PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags) 2680 __attribute__deprecated__; 2681 #define PERL_ARGS_ASSERT_PACK_CAT \ 2682 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) 2683 #endif 2684 2685 PERL_CALLCONV void Perl_package(pTHX_ OP* o); 2686 #define PERL_ARGS_ASSERT_PACKAGE \ 2687 assert(o) 2688 PERL_CALLCONV void Perl_package_version(pTHX_ OP* v); 2689 #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ 2690 assert(v) 2691 PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist); 2692 #define PERL_ARGS_ASSERT_PACKLIST \ 2693 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist) 2694 PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV* func, I32 optype); 2695 #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ 2696 assert(func) 2697 PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash); 2698 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ 2699 assert(name) 2700 PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash); 2701 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ 2702 assert(namepv) 2703 PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash); 2704 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ 2705 assert(name) 2706 PERL_CALLCONV void Perl_pad_add_weakref(pTHX_ CV* func); 2707 #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ 2708 assert(func) 2709 PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); 2710 #define PERL_ARGS_ASSERT_PAD_ALLOC 2711 PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full); 2712 #define PERL_ARGS_ASSERT_PAD_BLOCK_START 2713 #ifndef NO_MATHOMS 2714 PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po) 2715 __attribute__deprecated__ 2716 __attribute__warn_unused_result__; 2717 #define PERL_ARGS_ASSERT_PAD_COMPNAME_TYPE 2718 #endif 2719 2720 PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags); 2721 #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ 2722 assert(name) 2723 PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char* namepv, STRLEN namelen, U32 flags); 2724 #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ 2725 assert(namepv) 2726 PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV* name, U32 flags); 2727 #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ 2728 assert(name) 2729 PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv); 2730 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ 2731 assert(padlist); assert(old_cv); assert(new_cv) 2732 PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); 2733 #define PERL_ARGS_ASSERT_PAD_FREE 2734 PERL_CALLCONV OP * Perl_pad_leavemy(pTHX); 2735 #define PERL_ARGS_ASSERT_PAD_LEAVEMY 2736 PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) 2737 __attribute__warn_unused_result__; 2738 #define PERL_ARGS_ASSERT_PAD_NEW 2739 2740 PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth); 2741 #define PERL_ARGS_ASSERT_PAD_PUSH \ 2742 assert(padlist) 2743 PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); 2744 #define PERL_ARGS_ASSERT_PAD_SWIPE 2745 PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); 2746 #define PERL_ARGS_ASSERT_PAD_TIDY 2747 PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val); 2748 #define PERL_ARGS_ASSERT_PADLIST_STORE \ 2749 assert(padlist) 2750 PERL_CALLCONV void Perl_padname_free(pTHX_ PADNAME *pn); 2751 #define PERL_ARGS_ASSERT_PADNAME_FREE \ 2752 assert(pn) 2753 PERL_CALLCONV PADNAME * Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key) 2754 __attribute__warn_unused_result__; 2755 #define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \ 2756 assert(pnl) 2757 2758 PERL_CALLCONV void Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl); 2759 #define PERL_ARGS_ASSERT_PADNAMELIST_FREE \ 2760 assert(pnl) 2761 PERL_CALLCONV PADNAME ** Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val); 2762 #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ 2763 assert(pnl) 2764 PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags); 2765 #define PERL_ARGS_ASSERT_PARSE_ARITHEXPR 2766 PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags); 2767 #define PERL_ARGS_ASSERT_PARSE_BARESTMT 2768 PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags); 2769 #define PERL_ARGS_ASSERT_PARSE_BLOCK 2770 PERL_CALLCONV OP* Perl_parse_fullexpr(pTHX_ U32 flags); 2771 #define PERL_ARGS_ASSERT_PARSE_FULLEXPR 2772 PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags); 2773 #define PERL_ARGS_ASSERT_PARSE_FULLSTMT 2774 PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags); 2775 #define PERL_ARGS_ASSERT_PARSE_LABEL 2776 PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags); 2777 #define PERL_ARGS_ASSERT_PARSE_LISTEXPR 2778 PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags); 2779 #define PERL_ARGS_ASSERT_PARSE_STMTSEQ 2780 PERL_CALLCONV OP* Perl_parse_subsignature(pTHX_ U32 flags); 2781 #define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE 2782 PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags); 2783 #define PERL_ARGS_ASSERT_PARSE_TERMEXPR 2784 PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt); 2785 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ 2786 assert(popt) 2787 PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser); 2788 #define PERL_ARGS_ASSERT_PARSER_FREE \ 2789 assert(parser) 2790 PERL_CALLCONV void Perl_peep(pTHX_ OP* o); 2791 #define PERL_ARGS_ASSERT_PEEP 2792 PERL_CALLCONV PerlInterpreter* perl_alloc(void); 2793 #define PERL_ARGS_ASSERT_PERL_ALLOC 2794 PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl); 2795 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ 2796 assert(my_perl) 2797 PERL_CALLCONV int perl_destruct(PerlInterpreter *my_perl); 2798 #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ 2799 assert(my_perl) 2800 PERL_CALLCONV void perl_free(PerlInterpreter *my_perl); 2801 #define PERL_ARGS_ASSERT_PERL_FREE \ 2802 assert(my_perl) 2803 PERL_CALLCONV int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env); 2804 #define PERL_ARGS_ASSERT_PERL_PARSE \ 2805 assert(my_perl) 2806 PERL_CALLCONV int perl_run(PerlInterpreter *my_perl); 2807 #define PERL_ARGS_ASSERT_PERL_RUN \ 2808 assert(my_perl) 2809 PERL_CALLCONV Signal_t Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); 2810 #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER 2811 PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); 2812 #define PERL_ARGS_ASSERT_PMOP_DUMP 2813 PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor); 2814 #define PERL_ARGS_ASSERT_PMRUNTIME \ 2815 assert(o); assert(expr) 2816 PERL_CALLCONV void Perl_pop_scope(pTHX); 2817 #define PERL_ARGS_ASSERT_POP_SCOPE 2818 PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...); 2819 #define PERL_ARGS_ASSERT_POPULATE_ISA \ 2820 assert(name) 2821 PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags); 2822 #define PERL_ARGS_ASSERT_PREGCOMP \ 2823 assert(pattern) 2824 PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave); 2825 #define PERL_ARGS_ASSERT_PREGEXEC \ 2826 assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) 2827 PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r); 2828 #define PERL_ARGS_ASSERT_PREGFREE 2829 PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx); 2830 #define PERL_ARGS_ASSERT_PREGFREE2 \ 2831 assert(rx) 2832 PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha); 2833 #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ 2834 assert(s) 2835 PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv) 2836 __attribute__warn_unused_result__; 2837 #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ 2838 assert(tbl) 2839 2840 PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl); 2841 #define PERL_ARGS_ASSERT_PTR_TABLE_FREE 2842 PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX) 2843 __attribute__warn_unused_result__; 2844 #define PERL_ARGS_ASSERT_PTR_TABLE_NEW 2845 2846 PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl); 2847 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ 2848 assert(tbl) 2849 PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv); 2850 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ 2851 assert(tbl); assert(newsv) 2852 PERL_CALLCONV void Perl_push_scope(pTHX); 2853 #define PERL_ARGS_ASSERT_PUSH_SCOPE 2854 PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim); 2855 #define PERL_ARGS_ASSERT_PV_DISPLAY \ 2856 assert(dsv); assert(pv) 2857 PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags); 2858 #define PERL_ARGS_ASSERT_PV_ESCAPE \ 2859 assert(str) 2860 PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags); 2861 #define PERL_ARGS_ASSERT_PV_PRETTY \ 2862 assert(dsv); assert(str) 2863 PERL_CALLCONV char* Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags); 2864 #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ 2865 assert(dsv); assert(spv) 2866 PERL_CALLCONV void Perl_qerror(pTHX_ SV* err); 2867 #define PERL_ARGS_ASSERT_QERROR \ 2868 assert(err) 2869 PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags); 2870 #define PERL_ARGS_ASSERT_RE_COMPILE \ 2871 assert(pattern) 2872 PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, const char* const strbeg, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data); 2873 #define PERL_ARGS_ASSERT_RE_INTUIT_START \ 2874 assert(rx); assert(strbeg); assert(strpos); assert(strend) 2875 PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r); 2876 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ 2877 assert(r) 2878 PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags); 2879 #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ 2880 assert(eng) 2881 PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) 2882 __attribute__warn_unused_result__; 2883 #define PERL_ARGS_ASSERT_REALLOC 2884 2885 PERL_CALLCONV void Perl_reentrant_free(pTHX); 2886 #define PERL_ARGS_ASSERT_REENTRANT_FREE 2887 PERL_CALLCONV void Perl_reentrant_init(pTHX); 2888 #define PERL_ARGS_ASSERT_REENTRANT_INIT 2889 PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...); 2890 #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ 2891 assert(f) 2892 PERL_CALLCONV void Perl_reentrant_size(pTHX); 2893 #define PERL_ARGS_ASSERT_REENTRANT_SIZE 2894 PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); 2895 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_CHAIN_2HV 2896 PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags); 2897 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ 2898 assert(key) 2899 PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags); 2900 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ 2901 assert(keypv) 2902 PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags); 2903 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ 2904 assert(key) 2905 PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); 2906 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE 2907 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); 2908 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_INC 2909 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags); 2910 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ 2911 assert(key) 2912 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags); 2913 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ 2914 assert(keypv) 2915 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags); 2916 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ 2917 assert(key) 2918 PERL_CALLCONV SV* Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags); 2919 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ 2920 assert(rx) 2921 PERL_CALLCONV SV* Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags); 2922 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ 2923 assert(rx) 2924 PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags); 2925 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ 2926 assert(rx); assert(key) 2927 PERL_CALLCONV SV* Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags); 2928 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ 2929 assert(rx); assert(namesv) 2930 PERL_CALLCONV SV* Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags); 2931 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ 2932 assert(rx) 2933 PERL_CALLCONV SV* Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags); 2934 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ 2935 assert(rx) 2936 PERL_CALLCONV SV* Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags); 2937 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ 2938 assert(rx) 2939 PERL_CALLCONV SV* Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags); 2940 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ 2941 assert(rx) 2942 PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren, SV * const sv); 2943 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ 2944 assert(rx) 2945 PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren); 2946 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ 2947 assert(rx); assert(sv) 2948 PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value); 2949 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ 2950 assert(rx) 2951 PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx); 2952 #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ 2953 assert(rx) 2954 PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* dsv, REGEXP* ssv); 2955 #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ 2956 assert(ssv) 2957 PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r); 2958 #define PERL_ARGS_ASSERT_REGDUMP \ 2959 assert(r) 2960 PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags); 2961 #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ 2962 assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv) 2963 PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx); 2964 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ 2965 assert(rx) 2966 PERL_CALLCONV void Perl_reginitcolors(pTHX); 2967 #define PERL_ARGS_ASSERT_REGINITCOLORS 2968 PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) 2969 __attribute__warn_unused_result__; 2970 #define PERL_ARGS_ASSERT_REGNEXT 2971 2972 PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count); 2973 #define PERL_ARGS_ASSERT_REPEATCPY \ 2974 assert(to); assert(from) 2975 PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv); 2976 #define PERL_ARGS_ASSERT_REPORT_EVIL_FH 2977 PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); 2978 #define PERL_ARGS_ASSERT_REPORT_UNINIT 2979 PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have); 2980 #define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH 2981 PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv); 2982 #define PERL_ARGS_ASSERT_REQUIRE_PV \ 2983 assert(pv) 2984 PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend) 2985 __attribute__warn_unused_result__ 2986 __attribute__pure__; 2987 #define PERL_ARGS_ASSERT_RNINSTR \ 2988 assert(big); assert(bigend); assert(little); assert(lend) 2989 2990 PERL_CALLCONV void Perl_rpeep(pTHX_ OP* o); 2991 #define PERL_ARGS_ASSERT_RPEEP 2992 PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t); 2993 #define PERL_ARGS_ASSERT_RSIGNAL 2994 PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t); 2995 #define PERL_ARGS_ASSERT_RSIGNAL_RESTORE 2996 PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save); 2997 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ 2998 assert(save) 2999 PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); 3000 #define PERL_ARGS_ASSERT_RSIGNAL_STATE 3001 PERL_CALLCONV int Perl_runops_debug(pTHX); 3002 #define PERL_ARGS_ASSERT_RUNOPS_DEBUG 3003 PERL_CALLCONV int Perl_runops_standard(pTHX); 3004 #define PERL_ARGS_ASSERT_RUNOPS_STANDARD 3005 PERL_CALLCONV CV* Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags); 3006 #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ 3007 assert(cvop) 3008 PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx); 3009 #define PERL_ARGS_ASSERT_RXRES_SAVE \ 3010 assert(rsp); assert(rx) 3011 PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) 3012 __attribute__malloc__ 3013 __attribute__warn_unused_result__; 3014 #define PERL_ARGS_ASSERT_SAFESYSCALLOC 3015 3016 PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where); 3017 #define PERL_ARGS_ASSERT_SAFESYSFREE 3018 PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes) 3019 __attribute__malloc__ 3020 __attribute__warn_unused_result__; 3021 #define PERL_ARGS_ASSERT_SAFESYSMALLOC 3022 3023 PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) 3024 __attribute__warn_unused_result__; 3025 #define PERL_ARGS_ASSERT_SAFESYSREALLOC 3026 3027 PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp); 3028 #define PERL_ARGS_ASSERT_SAVE_I16 \ 3029 assert(intp) 3030 PERL_CALLCONV void Perl_save_I32(pTHX_ I32* intp); 3031 #define PERL_ARGS_ASSERT_SAVE_I32 \ 3032 assert(intp) 3033 PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep); 3034 #define PERL_ARGS_ASSERT_SAVE_I8 \ 3035 assert(bytep) 3036 PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key); 3037 #define PERL_ARGS_ASSERT_SAVE_ADELETE \ 3038 assert(av) 3039 /* PERL_CALLCONV void save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr); */ 3040 #define PERL_ARGS_ASSERT_SAVE_AELEM 3041 PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags); 3042 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ 3043 assert(av); assert(sptr) 3044 PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad); 3045 #define PERL_ARGS_ASSERT_SAVE_ALLOC 3046 PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr); 3047 #define PERL_ARGS_ASSERT_SAVE_APTR \ 3048 assert(aptr) 3049 PERL_CALLCONV AV* Perl_save_ary(pTHX_ GV* gv); 3050 #define PERL_ARGS_ASSERT_SAVE_ARY \ 3051 assert(gv) 3052 PERL_CALLCONV void Perl_save_bool(pTHX_ bool* boolp); 3053 #define PERL_ARGS_ASSERT_SAVE_BOOL \ 3054 assert(boolp) 3055 PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV** svp); 3056 #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ 3057 assert(svp) 3058 PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen); 3059 #define PERL_ARGS_ASSERT_SAVE_DELETE \ 3060 assert(hv); assert(key) 3061 PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p); 3062 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ 3063 assert(p) 3064 PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p); 3065 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X 3066 #ifndef NO_MATHOMS 3067 PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); 3068 #define PERL_ARGS_ASSERT_SAVE_FREEOP 3069 #endif 3070 #ifndef NO_MATHOMS 3071 PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); 3072 #define PERL_ARGS_ASSERT_SAVE_FREEPV 3073 #endif 3074 #ifndef NO_MATHOMS 3075 PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); 3076 #define PERL_ARGS_ASSERT_SAVE_FREESV 3077 #endif 3078 PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str); 3079 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ 3080 assert(str) 3081 PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV** sptr); 3082 #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ 3083 assert(sptr) 3084 PERL_CALLCONV void Perl_save_gp(pTHX_ GV* gv, I32 empty); 3085 #define PERL_ARGS_ASSERT_SAVE_GP \ 3086 assert(gv) 3087 PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv); 3088 #define PERL_ARGS_ASSERT_SAVE_HASH \ 3089 assert(gv) 3090 PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); 3091 #define PERL_ARGS_ASSERT_SAVE_HDELETE \ 3092 assert(hv); assert(keysv) 3093 /* PERL_CALLCONV void save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ 3094 #define PERL_ARGS_ASSERT_SAVE_HELEM 3095 PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); 3096 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ 3097 assert(hv); assert(key); assert(sptr) 3098 PERL_CALLCONV void Perl_save_hints(pTHX); 3099 #define PERL_ARGS_ASSERT_SAVE_HINTS 3100 PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr); 3101 #define PERL_ARGS_ASSERT_SAVE_HPTR \ 3102 assert(hptr) 3103 PERL_CALLCONV void Perl_save_int(pTHX_ int* intp); 3104 #define PERL_ARGS_ASSERT_SAVE_INT \ 3105 assert(intp) 3106 PERL_CALLCONV void Perl_save_item(pTHX_ SV* item); 3107 #define PERL_ARGS_ASSERT_SAVE_ITEM \ 3108 assert(item) 3109 PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp); 3110 #define PERL_ARGS_ASSERT_SAVE_IV \ 3111 assert(ivp) 3112 #ifndef NO_MATHOMS 3113 PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg) 3114 __attribute__deprecated__; 3115 #define PERL_ARGS_ASSERT_SAVE_LIST \ 3116 assert(sarg) 3117 #endif 3118 3119 #ifndef NO_MATHOMS 3120 PERL_CALLCONV void Perl_save_long(pTHX_ long* longp) 3121 __attribute__deprecated__; 3122 #define PERL_ARGS_ASSERT_SAVE_LONG \ 3123 assert(longp) 3124 #endif 3125 3126 #ifndef NO_MATHOMS 3127 PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv); 3128 #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ 3129 assert(sv) 3130 #endif 3131 #ifndef NO_MATHOMS 3132 PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv) 3133 __attribute__deprecated__; 3134 #define PERL_ARGS_ASSERT_SAVE_NOGV \ 3135 assert(gv) 3136 #endif 3137 3138 #ifndef NO_MATHOMS 3139 PERL_CALLCONV void Perl_save_op(pTHX); 3140 #define PERL_ARGS_ASSERT_SAVE_OP 3141 #endif 3142 PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); 3143 #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE 3144 PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr); 3145 #define PERL_ARGS_ASSERT_SAVE_PPTR \ 3146 assert(pptr) 3147 PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type); 3148 #define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR 3149 PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type); 3150 #define PERL_ARGS_ASSERT_SAVE_PUSHPTR 3151 PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type); 3152 #define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR 3153 PERL_CALLCONV void Perl_save_re_context(pTHX); 3154 #define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT 3155 PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv); 3156 #define PERL_ARGS_ASSERT_SAVE_SCALAR \ 3157 assert(gv) 3158 PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val); 3159 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ 3160 assert(sv) 3161 PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char** str); 3162 #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ 3163 assert(str) 3164 PERL_CALLCONV void Perl_save_sptr(pTHX_ SV** sptr); 3165 #define PERL_ARGS_ASSERT_SAVE_SPTR \ 3166 assert(sptr) 3167 PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN* ptr); 3168 #define PERL_ARGS_ASSERT_SAVE_STRLEN \ 3169 assert(ptr) 3170 PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr); 3171 #define PERL_ARGS_ASSERT_SAVE_SVREF \ 3172 assert(sptr) 3173 PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr); 3174 #define PERL_ARGS_ASSERT_SAVE_VPTR \ 3175 assert(ptr) 3176 PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv) 3177 __attribute__malloc__ 3178 __attribute__warn_unused_result__; 3179 #define PERL_ARGS_ASSERT_SAVEPV 3180 3181 PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, Size_t len) 3182 __attribute__malloc__ 3183 __attribute__warn_unused_result__; 3184 #define PERL_ARGS_ASSERT_SAVEPVN 3185 3186 PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv) 3187 __attribute__malloc__ 3188 __attribute__warn_unused_result__; 3189 #define PERL_ARGS_ASSERT_SAVESHAREDPV 3190 3191 PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len) 3192 __attribute__malloc__ 3193 __attribute__warn_unused_result__; 3194 #define PERL_ARGS_ASSERT_SAVESHAREDPVN 3195 3196 PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv) 3197 __attribute__malloc__ 3198 __attribute__warn_unused_result__; 3199 #define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ 3200 assert(sv) 3201 3202 PERL_CALLCONV void Perl_savestack_grow(pTHX); 3203 #define PERL_ARGS_ASSERT_SAVESTACK_GROW 3204 PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need); 3205 #define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT 3206 PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) 3207 __attribute__malloc__ 3208 __attribute__warn_unused_result__; 3209 #define PERL_ARGS_ASSERT_SAVESVPV \ 3210 assert(sv) 3211 3212 PERL_CALLCONV void Perl_savetmps(pTHX); 3213 #define PERL_ARGS_ASSERT_SAVETMPS 3214 PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o); 3215 #define PERL_ARGS_ASSERT_SAWPARENS 3216 PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o); 3217 #define PERL_ARGS_ASSERT_SCALAR 3218 PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o); 3219 #define PERL_ARGS_ASSERT_SCALARVOID \ 3220 assert(o) 3221 PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char* start, STRLEN len, STRLEN* retlen); 3222 #define PERL_ARGS_ASSERT_SCAN_BIN \ 3223 assert(start); assert(retlen) 3224 PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char* start, STRLEN len, STRLEN* retlen); 3225 #define PERL_ARGS_ASSERT_SCAN_HEX \ 3226 assert(start); assert(retlen) 3227 PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp); 3228 #define PERL_ARGS_ASSERT_SCAN_NUM \ 3229 assert(s); assert(lvalp) 3230 PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen); 3231 #define PERL_ARGS_ASSERT_SCAN_OCT \ 3232 assert(start); assert(retlen) 3233 PERL_CALLCONV char* Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) 3234 __attribute__warn_unused_result__; 3235 #define PERL_ARGS_ASSERT_SCAN_STR \ 3236 assert(start) 3237 3238 PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv); 3239 #define PERL_ARGS_ASSERT_SCAN_VERSION \ 3240 assert(s); assert(rv) 3241 PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, SV *sv); 3242 #define PERL_ARGS_ASSERT_SCAN_VSTRING \ 3243 assert(s); assert(e); assert(sv) 3244 PERL_CALLCONV char* Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); 3245 #define PERL_ARGS_ASSERT_SCAN_WORD \ 3246 assert(s); assert(dest); assert(slp) 3247 PERL_CALLCONV U32 Perl_seed(pTHX); 3248 #define PERL_ARGS_ASSERT_SEED 3249 PERL_CALLCONV void Perl_set_caret_X(pTHX); 3250 #define PERL_ARGS_ASSERT_SET_CARET_X 3251 PERL_CALLCONV void Perl_set_context(void *t); 3252 #define PERL_ARGS_ASSERT_SET_CONTEXT \ 3253 assert(t) 3254 PERL_CALLCONV void Perl_set_numeric_standard(pTHX); 3255 #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD 3256 PERL_CALLCONV void Perl_set_numeric_underlying(pTHX); 3257 #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING 3258 PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); 3259 #define PERL_ARGS_ASSERT_SETDEFOUT \ 3260 assert(gv) 3261 PERL_CALLCONV void Perl_setfd_cloexec(int fd); 3262 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC 3263 PERL_CALLCONV void Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd); 3264 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD 3265 PERL_CALLCONV void Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd); 3266 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS 3267 PERL_CALLCONV void Perl_setfd_inhexec(int fd); 3268 #define PERL_ARGS_ASSERT_SETFD_INHEXEC 3269 PERL_CALLCONV void Perl_setfd_inhexec_for_sysfd(pTHX_ int fd); 3270 #define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD 3271 PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, SSize_t len, U32 hash); 3272 #define PERL_ARGS_ASSERT_SHARE_HEK \ 3273 assert(str) 3274 PERL_CALLCONV Signal_t Perl_sighandler1(int sig); 3275 #define PERL_ARGS_ASSERT_SIGHANDLER1 3276 PERL_CALLCONV Signal_t Perl_sighandler3(int sig, Siginfo_t *info, void *uap); 3277 #define PERL_ARGS_ASSERT_SIGHANDLER3 3278 #ifndef PERL_NO_INLINE_FUNCTIONS 3279 PERL_STATIC_INLINE unsigned Perl_single_1bit_pos32(U32 word) 3280 __attribute__warn_unused_result__; 3281 #define PERL_ARGS_ASSERT_SINGLE_1BIT_POS32 3282 #endif 3283 3284 PERL_CALLCONV char* Perl_skipspace_flags(pTHX_ char *s, U32 flags) 3285 __attribute__warn_unused_result__; 3286 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ 3287 assert(s) 3288 3289 PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp); 3290 #define PERL_ARGS_ASSERT_SORTSV \ 3291 assert(cmp) 3292 PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags); 3293 #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ 3294 assert(cmp) 3295 PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, SSize_t n); 3296 #define PERL_ARGS_ASSERT_STACK_GROW \ 3297 assert(sp); assert(p) 3298 PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io); 3299 #define PERL_ARGS_ASSERT_START_GLOB \ 3300 assert(tmpglob); assert(io) 3301 PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); 3302 #define PERL_ARGS_ASSERT_START_SUBPARSE 3303 PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) 3304 __attribute__warn_unused_result__; 3305 #define PERL_ARGS_ASSERT_STR_TO_VERSION \ 3306 assert(sv) 3307 3308 PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv); 3309 #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ 3310 assert(cv) 3311 #ifndef NO_MATHOMS 3312 PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv); 3313 #define PERL_ARGS_ASSERT_SV_2BOOL \ 3314 assert(sv) 3315 #endif 3316 PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); 3317 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ 3318 assert(sv) 3319 PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const I32 lref); 3320 #define PERL_ARGS_ASSERT_SV_2CV \ 3321 assert(st); assert(gvp) 3322 PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv); 3323 #define PERL_ARGS_ASSERT_SV_2IO \ 3324 assert(sv) 3325 #ifndef NO_MATHOMS 3326 PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv); 3327 #define PERL_ARGS_ASSERT_SV_2IV \ 3328 assert(sv) 3329 #endif 3330 PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags); 3331 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ 3332 assert(sv) 3333 PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv); 3334 #define PERL_ARGS_ASSERT_SV_2MORTAL 3335 PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv); 3336 #define PERL_ARGS_ASSERT_SV_2NUM \ 3337 assert(sv) 3338 PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags); 3339 #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ 3340 assert(sv) 3341 #ifndef NO_MATHOMS 3342 PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); 3343 #define PERL_ARGS_ASSERT_SV_2PV \ 3344 assert(sv) 3345 #endif 3346 PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags); 3347 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ 3348 assert(sv) 3349 #ifndef NO_MATHOMS 3350 PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv) 3351 __attribute__warn_unused_result__; 3352 #define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ 3353 assert(sv) 3354 #endif 3355 3356 #ifndef NO_MATHOMS 3357 PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp); 3358 #define PERL_ARGS_ASSERT_SV_2PVBYTE \ 3359 assert(sv) 3360 #endif 3361 PERL_CALLCONV char* Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN *const lp, const U32 flags); 3362 #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ 3363 assert(sv) 3364 #ifndef NO_MATHOMS 3365 PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) 3366 __attribute__warn_unused_result__; 3367 #define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ 3368 assert(sv) 3369 #endif 3370 3371 #ifndef NO_MATHOMS 3372 PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp); 3373 #define PERL_ARGS_ASSERT_SV_2PVUTF8 \ 3374 assert(sv) 3375 #endif 3376 PERL_CALLCONV char* Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN *const lp, const U32 flags); 3377 #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ 3378 assert(sv) 3379 #ifndef NO_MATHOMS 3380 PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv) 3381 __attribute__warn_unused_result__; 3382 #define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ 3383 assert(sv) 3384 #endif 3385 3386 #ifndef NO_MATHOMS 3387 PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv); 3388 #define PERL_ARGS_ASSERT_SV_2UV \ 3389 assert(sv) 3390 #endif 3391 PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags); 3392 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ 3393 assert(sv) 3394 PERL_CALLCONV void Perl_sv_backoff(SV *const sv); 3395 #define PERL_ARGS_ASSERT_SV_BACKOFF \ 3396 assert(sv) 3397 PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV *const sv, HV *const stash); 3398 #define PERL_ARGS_ASSERT_SV_BLESS \ 3399 assert(sv); assert(stash) 3400 PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen); 3401 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ 3402 assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) 3403 PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV *const dsv, const char* sstr); 3404 #define PERL_ARGS_ASSERT_SV_CATPV \ 3405 assert(dsv) 3406 PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV *dsv, const char *sstr, const I32 flags); 3407 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ 3408 assert(dsv); assert(sstr) 3409 PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *const dsv, const char *const sstr); 3410 #define PERL_ARGS_ASSERT_SV_CATPV_MG \ 3411 assert(dsv) 3412 PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...) 3413 __attribute__format__(__printf__,pTHX_2,pTHX_3); 3414 #define PERL_ARGS_ASSERT_SV_CATPVF \ 3415 assert(sv); assert(pat) 3416 3417 PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 3418 __attribute__format__(__printf__,pTHX_2,pTHX_3); 3419 #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ 3420 assert(sv); assert(pat) 3421 3422 #ifndef NO_MATHOMS 3423 PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len); 3424 #define PERL_ARGS_ASSERT_SV_CATPVN \ 3425 assert(dsv); assert(sstr) 3426 #endif 3427 PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV *const dsv, const char *sstr, const STRLEN len, const I32 flags); 3428 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ 3429 assert(dsv); assert(sstr) 3430 #ifndef NO_MATHOMS 3431 PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len); 3432 #define PERL_ARGS_ASSERT_SV_CATPVN_MG \ 3433 assert(dsv); assert(sstr) 3434 #endif 3435 #ifndef NO_MATHOMS 3436 PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dsv, SV *sstr); 3437 #define PERL_ARGS_ASSERT_SV_CATSV \ 3438 assert(dsv) 3439 #endif 3440 PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const sstr, const I32 flags); 3441 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ 3442 assert(dsv) 3443 #ifndef NO_MATHOMS 3444 PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *sstr); 3445 #define PERL_ARGS_ASSERT_SV_CATSV_MG \ 3446 assert(dsv) 3447 #endif 3448 PERL_CALLCONV void Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr); 3449 #define PERL_ARGS_ASSERT_SV_CHOP \ 3450 assert(sv) 3451 PERL_CALLCONV I32 Perl_sv_clean_all(pTHX); 3452 #define PERL_ARGS_ASSERT_SV_CLEAN_ALL 3453 PERL_CALLCONV void Perl_sv_clean_objs(pTHX); 3454 #define PERL_ARGS_ASSERT_SV_CLEAN_OBJS 3455 PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const orig_sv); 3456 #define PERL_ARGS_ASSERT_SV_CLEAR \ 3457 assert(orig_sv) 3458 PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); 3459 #define PERL_ARGS_ASSERT_SV_CMP 3460 PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); 3461 #define PERL_ARGS_ASSERT_SV_CMP_FLAGS 3462 PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); 3463 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE 3464 PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); 3465 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS 3466 #ifndef NO_MATHOMS 3467 PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv); 3468 #define PERL_ARGS_ASSERT_SV_COPYPV \ 3469 assert(dsv); assert(ssv) 3470 #endif 3471 PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags); 3472 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ 3473 assert(dsv); assert(ssv) 3474 /* PERL_CALLCONV void sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv); */ 3475 #define PERL_ARGS_ASSERT_SV_COPYPV_NOMG 3476 PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); 3477 #define PERL_ARGS_ASSERT_SV_DEC 3478 PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv); 3479 #define PERL_ARGS_ASSERT_SV_DEC_NOMG 3480 PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv); 3481 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ 3482 assert(tsv); assert(sv) 3483 PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV* sv, const char *const name) 3484 __attribute__warn_unused_result__; 3485 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ 3486 assert(sv); assert(name) 3487 3488 PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV* sv, const char *const name, U32 flags) 3489 __attribute__warn_unused_result__; 3490 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ 3491 assert(sv); assert(name) 3492 3493 PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) 3494 __attribute__warn_unused_result__; 3495 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ 3496 assert(sv); assert(name) 3497 3498 PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags) 3499 __attribute__warn_unused_result__; 3500 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ 3501 assert(sv); assert(namesv) 3502 3503 PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); 3504 #define PERL_ARGS_ASSERT_SV_DESTROYABLE 3505 PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name) 3506 __attribute__warn_unused_result__; 3507 #define PERL_ARGS_ASSERT_SV_DOES \ 3508 assert(sv); assert(name) 3509 3510 PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV* sv, const char *const name, U32 flags) 3511 __attribute__warn_unused_result__; 3512 #define PERL_ARGS_ASSERT_SV_DOES_PV \ 3513 assert(sv); assert(name) 3514 3515 PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) 3516 __attribute__warn_unused_result__; 3517 #define PERL_ARGS_ASSERT_SV_DOES_PVN \ 3518 assert(sv); assert(name) 3519 3520 PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags) 3521 __attribute__warn_unused_result__; 3522 #define PERL_ARGS_ASSERT_SV_DOES_SV \ 3523 assert(sv); assert(namesv) 3524 3525 PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv); 3526 #define PERL_ARGS_ASSERT_SV_DUMP 3527 #ifndef NO_MATHOMS 3528 PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV* sv1, SV* sv2); 3529 #define PERL_ARGS_ASSERT_SV_EQ 3530 #endif 3531 PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); 3532 #define PERL_ARGS_ASSERT_SV_EQ_FLAGS 3533 #ifndef NO_MATHOMS 3534 PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv); 3535 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ 3536 assert(sv) 3537 #endif 3538 PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags); 3539 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ 3540 assert(sv) 3541 PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); 3542 #define PERL_ARGS_ASSERT_SV_FREE 3543 PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt); 3544 #define PERL_ARGS_ASSERT_SV_FREE2 \ 3545 assert(sv) 3546 PERL_CALLCONV void Perl_sv_free_arenas(pTHX); 3547 #define PERL_ARGS_ASSERT_SV_FREE_ARENAS 3548 PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv); 3549 #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ 3550 assert(sv) 3551 PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append); 3552 #define PERL_ARGS_ASSERT_SV_GETS \ 3553 assert(sv); assert(fp) 3554 PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen); 3555 #define PERL_ARGS_ASSERT_SV_GROW \ 3556 assert(sv) 3557 PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv); 3558 #define PERL_ARGS_ASSERT_SV_INC 3559 PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV *const sv); 3560 #define PERL_ARGS_ASSERT_SV_INC_NOMG 3561 #ifndef NO_MATHOMS 3562 PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen); 3563 #define PERL_ARGS_ASSERT_SV_INSERT \ 3564 assert(bigstr); assert(little) 3565 #endif 3566 PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); 3567 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ 3568 assert(bigstr); assert(little) 3569 PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name); 3570 #define PERL_ARGS_ASSERT_SV_ISA \ 3571 assert(name) 3572 PERL_CALLCONV bool Perl_sv_isa_sv(pTHX_ SV* sv, SV* namesv) 3573 __attribute__warn_unused_result__; 3574 #define PERL_ARGS_ASSERT_SV_ISA_SV \ 3575 assert(sv); assert(namesv) 3576 3577 PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); 3578 #define PERL_ARGS_ASSERT_SV_ISOBJECT 3579 #ifndef NO_MATHOMS 3580 PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) 3581 __attribute__deprecated__; 3582 #define PERL_ARGS_ASSERT_SV_IV \ 3583 assert(sv) 3584 #endif 3585 3586 PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); 3587 #define PERL_ARGS_ASSERT_SV_LEN 3588 PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); 3589 #define PERL_ARGS_ASSERT_SV_LEN_UTF8 3590 PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv); 3591 #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ 3592 assert(sv) 3593 PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen); 3594 #define PERL_ARGS_ASSERT_SV_MAGIC \ 3595 assert(sv) 3596 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); 3597 #define PERL_ARGS_ASSERT_SV_MAGICEXT \ 3598 assert(sv) 3599 PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv); 3600 #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ 3601 assert(sv) 3602 #ifndef NO_MATHOMS 3603 PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) 3604 __attribute__warn_unused_result__; 3605 #define PERL_ARGS_ASSERT_SV_MORTALCOPY 3606 #endif 3607 3608 PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags) 3609 __attribute__warn_unused_result__; 3610 #define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS 3611 3612 PERL_CALLCONV SV* Perl_sv_newmortal(pTHX) 3613 __attribute__warn_unused_result__; 3614 #define PERL_ARGS_ASSERT_SV_NEWMORTAL 3615 3616 PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv); 3617 #define PERL_ARGS_ASSERT_SV_NEWREF 3618 #ifndef NO_MATHOMS 3619 PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv) 3620 __attribute__deprecated__; 3621 #define PERL_ARGS_ASSERT_SV_NOLOCKING 3622 #endif 3623 3624 PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); 3625 #define PERL_ARGS_ASSERT_SV_NOSHARING 3626 #ifndef NO_MATHOMS 3627 PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv) 3628 __attribute__deprecated__; 3629 #define PERL_ARGS_ASSERT_SV_NOUNLOCKING 3630 #endif 3631 3632 #ifndef NO_MATHOMS 3633 PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv) 3634 __attribute__deprecated__; 3635 #define PERL_ARGS_ASSERT_SV_NV \ 3636 assert(sv) 3637 #endif 3638 3639 #ifndef PERL_NO_INLINE_FUNCTIONS 3640 PERL_STATIC_INLINE bool Perl_sv_only_taint_gmagic(SV *sv); 3641 #define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ 3642 assert(sv) 3643 #endif 3644 PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); 3645 #define PERL_ARGS_ASSERT_SV_PEEK 3646 PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp); 3647 #define PERL_ARGS_ASSERT_SV_POS_B2U \ 3648 assert(offsetp) 3649 PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags); 3650 #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ 3651 assert(sv) 3652 PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp); 3653 #define PERL_ARGS_ASSERT_SV_POS_U2B \ 3654 assert(offsetp) 3655 PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags); 3656 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ 3657 assert(sv) 3658 #ifndef NO_MATHOMS 3659 PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv) 3660 __attribute__warn_unused_result__; 3661 #define PERL_ARGS_ASSERT_SV_PV \ 3662 assert(sv) 3663 #endif 3664 3665 #ifndef NO_MATHOMS 3666 PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) 3667 __attribute__warn_unused_result__; 3668 #define PERL_ARGS_ASSERT_SV_PVBYTE \ 3669 assert(sv) 3670 #endif 3671 3672 #ifndef NO_MATHOMS 3673 PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp) 3674 __attribute__deprecated__; 3675 #define PERL_ARGS_ASSERT_SV_PVBYTEN \ 3676 assert(sv); assert(lp) 3677 #endif 3678 3679 PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp); 3680 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ 3681 assert(sv) 3682 #ifndef NO_MATHOMS 3683 PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp) 3684 __attribute__deprecated__; 3685 #define PERL_ARGS_ASSERT_SV_PVN \ 3686 assert(sv); assert(lp) 3687 #endif 3688 3689 #ifndef NO_MATHOMS 3690 PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp); 3691 #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ 3692 assert(sv) 3693 #endif 3694 PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags); 3695 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ 3696 assert(sv) 3697 #ifndef NO_MATHOMS 3698 PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp) 3699 __attribute__deprecated__; 3700 #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ 3701 assert(sv) 3702 #endif 3703 3704 #ifndef NO_MATHOMS 3705 PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) 3706 __attribute__warn_unused_result__; 3707 #define PERL_ARGS_ASSERT_SV_PVUTF8 \ 3708 assert(sv) 3709 #endif 3710 3711 #ifndef NO_MATHOMS 3712 PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp) 3713 __attribute__deprecated__; 3714 #define PERL_ARGS_ASSERT_SV_PVUTF8N \ 3715 assert(sv); assert(lp) 3716 #endif 3717 3718 PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp); 3719 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ 3720 assert(sv) 3721 PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding); 3722 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ 3723 assert(sv); assert(encoding) 3724 PERL_CALLCONV SV* Perl_sv_ref(pTHX_ SV *dst, const SV *const sv, const int ob); 3725 #define PERL_ARGS_ASSERT_SV_REF \ 3726 assert(sv) 3727 PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob) 3728 __attribute__warn_unused_result__; 3729 #define PERL_ARGS_ASSERT_SV_REFTYPE \ 3730 assert(sv) 3731 3732 PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv); 3733 #define PERL_ARGS_ASSERT_SV_REPLACE \ 3734 assert(sv); assert(nsv) 3735 PERL_CALLCONV void Perl_sv_report_used(pTHX); 3736 #define PERL_ARGS_ASSERT_SV_REPORT_USED 3737 PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash); 3738 #define PERL_ARGS_ASSERT_SV_RESET \ 3739 assert(s) 3740 PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash); 3741 #define PERL_ARGS_ASSERT_SV_RESETPVN 3742 PERL_CALLCONV SV* Perl_sv_rvunweaken(pTHX_ SV *const sv); 3743 #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ 3744 assert(sv) 3745 PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv); 3746 #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ 3747 assert(sv) 3748 PERL_CALLCONV void Perl_sv_set_undef(pTHX_ SV *sv); 3749 #define PERL_ARGS_ASSERT_SV_SET_UNDEF \ 3750 assert(sv) 3751 PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek); 3752 #define PERL_ARGS_ASSERT_SV_SETHEK \ 3753 assert(sv) 3754 PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num); 3755 #define PERL_ARGS_ASSERT_SV_SETIV \ 3756 assert(sv) 3757 PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i); 3758 #define PERL_ARGS_ASSERT_SV_SETIV_MG \ 3759 assert(sv) 3760 PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num); 3761 #define PERL_ARGS_ASSERT_SV_SETNV \ 3762 assert(sv) 3763 PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num); 3764 #define PERL_ARGS_ASSERT_SV_SETNV_MG \ 3765 assert(sv) 3766 PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr); 3767 #define PERL_ARGS_ASSERT_SV_SETPV \ 3768 assert(sv) 3769 PERL_CALLCONV char * Perl_sv_setpv_bufsize(pTHX_ SV *const sv, const STRLEN cur, const STRLEN len); 3770 #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE \ 3771 assert(sv) 3772 PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr); 3773 #define PERL_ARGS_ASSERT_SV_SETPV_MG \ 3774 assert(sv) 3775 PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...) 3776 __attribute__format__(__printf__,pTHX_2,pTHX_3); 3777 #define PERL_ARGS_ASSERT_SV_SETPVF \ 3778 assert(sv); assert(pat) 3779 3780 PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 3781 __attribute__format__(__printf__,pTHX_2,pTHX_3); 3782 #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ 3783 assert(sv); assert(pat) 3784 3785 #ifndef NO_MATHOMS 3786 PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num) 3787 __attribute__deprecated__; 3788 #define PERL_ARGS_ASSERT_SV_SETPVIV \ 3789 assert(sv) 3790 #endif 3791 3792 #ifndef NO_MATHOMS 3793 PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv) 3794 __attribute__deprecated__; 3795 #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \ 3796 assert(sv) 3797 #endif 3798 3799 PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len); 3800 #define PERL_ARGS_ASSERT_SV_SETPVN \ 3801 assert(sv) 3802 PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len); 3803 #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ 3804 assert(sv); assert(ptr) 3805 PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv); 3806 #define PERL_ARGS_ASSERT_SV_SETREF_IV \ 3807 assert(rv) 3808 PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv); 3809 #define PERL_ARGS_ASSERT_SV_SETREF_NV \ 3810 assert(rv) 3811 PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv); 3812 #define PERL_ARGS_ASSERT_SV_SETREF_PV \ 3813 assert(rv) 3814 PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n); 3815 #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ 3816 assert(rv); assert(pv) 3817 PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv); 3818 #define PERL_ARGS_ASSERT_SV_SETREF_UV \ 3819 assert(rv) 3820 PERL_CALLCONV void Perl_sv_setrv_inc(pTHX_ SV *const sv, SV *const ref); 3821 #define PERL_ARGS_ASSERT_SV_SETRV_INC \ 3822 assert(sv); assert(ref) 3823 PERL_CALLCONV void Perl_sv_setrv_inc_mg(pTHX_ SV *const sv, SV *const ref); 3824 #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG \ 3825 assert(sv); assert(ref) 3826 PERL_CALLCONV void Perl_sv_setrv_noinc(pTHX_ SV *const sv, SV *const ref); 3827 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC \ 3828 assert(sv); assert(ref) 3829 PERL_CALLCONV void Perl_sv_setrv_noinc_mg(pTHX_ SV *const sv, SV *const ref); 3830 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ 3831 assert(sv); assert(ref) 3832 #ifndef NO_MATHOMS 3833 PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); 3834 #define PERL_ARGS_ASSERT_SV_SETSV \ 3835 assert(dsv) 3836 #endif 3837 PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); 3838 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ 3839 assert(dsv) 3840 PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV *const dsv, SV *const ssv); 3841 #define PERL_ARGS_ASSERT_SV_SETSV_MG \ 3842 assert(dsv) 3843 PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num); 3844 #define PERL_ARGS_ASSERT_SV_SETUV \ 3845 assert(sv) 3846 PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u); 3847 #define PERL_ARGS_ASSERT_SV_SETUV_MG \ 3848 assert(sv) 3849 PERL_CALLCONV SV* Perl_sv_string_from_errnum(pTHX_ int errnum, SV* tgtsv); 3850 #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM 3851 #ifndef NO_MATHOMS 3852 PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv); 3853 #define PERL_ARGS_ASSERT_SV_TAINT \ 3854 assert(sv) 3855 #endif 3856 PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) 3857 __attribute__warn_unused_result__; 3858 #define PERL_ARGS_ASSERT_SV_TAINTED \ 3859 assert(sv) 3860 3861 PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); 3862 #define PERL_ARGS_ASSERT_SV_TRUE 3863 PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) 3864 __attribute__warn_unused_result__; 3865 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ 3866 assert(dsv); assert(ssv) 3867 3868 PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type); 3869 #define PERL_ARGS_ASSERT_SV_UNMAGIC \ 3870 assert(sv) 3871 PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl); 3872 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ 3873 assert(sv) 3874 #ifndef NO_MATHOMS 3875 PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv); 3876 #define PERL_ARGS_ASSERT_SV_UNREF \ 3877 assert(sv) 3878 #endif 3879 PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags); 3880 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ 3881 assert(ref) 3882 PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv); 3883 #define PERL_ARGS_ASSERT_SV_UNTAINT \ 3884 assert(sv) 3885 PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type); 3886 #define PERL_ARGS_ASSERT_SV_UPGRADE \ 3887 assert(sv) 3888 #ifndef NO_MATHOMS 3889 PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len); 3890 #define PERL_ARGS_ASSERT_SV_USEPVN \ 3891 assert(sv) 3892 #endif 3893 PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags); 3894 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ 3895 assert(sv) 3896 #ifndef NO_MATHOMS 3897 PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); 3898 #define PERL_ARGS_ASSERT_SV_USEPVN_MG \ 3899 assert(sv) 3900 #endif 3901 PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv); 3902 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ 3903 assert(sv) 3904 #ifndef NO_MATHOMS 3905 PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok); 3906 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ 3907 assert(sv) 3908 #endif 3909 PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV *const sv, const bool fail_ok, const U32 flags); 3910 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ 3911 assert(sv) 3912 /* PERL_CALLCONV bool sv_utf8_downgrade_nomg(pTHX_ SV *const sv, const bool fail_ok); */ 3913 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_NOMG 3914 PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv); 3915 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ 3916 assert(sv) 3917 #ifndef NO_MATHOMS 3918 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv); 3919 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ 3920 assert(sv) 3921 #endif 3922 /* PERL_CALLCONV STRLEN sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */ 3923 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS 3924 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra); 3925 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ 3926 assert(sv) 3927 /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ 3928 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG 3929 #ifndef NO_MATHOMS 3930 PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) 3931 __attribute__deprecated__; 3932 #define PERL_ARGS_ASSERT_SV_UV \ 3933 assert(sv) 3934 #endif 3935 3936 PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args); 3937 #define PERL_ARGS_ASSERT_SV_VCATPVF \ 3938 assert(sv); assert(pat) 3939 PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args); 3940 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ 3941 assert(sv); assert(pat) 3942 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 Size_t sv_count, bool *const maybe_tainted); 3943 #define PERL_ARGS_ASSERT_SV_VCATPVFN \ 3944 assert(sv); assert(pat) 3945 PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const Size_t sv_count, bool *const maybe_tainted, const U32 flags); 3946 #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ 3947 assert(sv); assert(pat) 3948 PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args); 3949 #define PERL_ARGS_ASSERT_SV_VSETPVF \ 3950 assert(sv); assert(pat) 3951 PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args); 3952 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ 3953 assert(sv); assert(pat) 3954 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 Size_t sv_count, bool *const maybe_tainted); 3955 #define PERL_ARGS_ASSERT_SV_VSETPVFN \ 3956 assert(sv); assert(pat) 3957 PERL_CALLCONV void Perl_switch_to_global_locale(void); 3958 #define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE 3959 PERL_CALLCONV bool Perl_sync_locale(void); 3960 #define PERL_ARGS_ASSERT_SYNC_LOCALE 3961 PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv); 3962 #define PERL_ARGS_ASSERT_SYS_INIT \ 3963 assert(argc); assert(argv) 3964 PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env); 3965 #define PERL_ARGS_ASSERT_SYS_INIT3 \ 3966 assert(argc); assert(argv); assert(env) 3967 PERL_CALLCONV void Perl_sys_term(void); 3968 #define PERL_ARGS_ASSERT_SYS_TERM 3969 PERL_CALLCONV void Perl_taint_env(pTHX); 3970 #define PERL_ARGS_ASSERT_TAINT_ENV 3971 PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s); 3972 #define PERL_ARGS_ASSERT_TAINT_PROPER \ 3973 assert(s) 3974 PERL_CALLCONV void Perl_thread_locale_init(void); 3975 #define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT 3976 PERL_CALLCONV void Perl_thread_locale_term(void); 3977 #define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM 3978 PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...); 3979 #define PERL_ARGS_ASSERT_TIED_METHOD \ 3980 assert(methname); assert(sp); assert(sv); assert(mg) 3981 PERL_CALLCONV SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix); 3982 #define PERL_ARGS_ASSERT_TMPS_GROW_P 3983 /* PERL_CALLCONV UV to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ 3984 #define PERL_ARGS_ASSERT_TO_UNI_FOLD 3985 PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); 3986 #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ 3987 assert(p); assert(lenp) 3988 PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); 3989 #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ 3990 assert(p); assert(lenp) 3991 PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); 3992 #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ 3993 assert(p); assert(lenp) 3994 PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); 3995 #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN 3996 PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); 3997 #define PERL_ARGS_ASSERT_TRY_AMAGIC_UN 3998 #ifndef NO_MATHOMS 3999 PERL_CALLCONV SSize_t Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags) 4000 __attribute__deprecated__; 4001 #define PERL_ARGS_ASSERT_UNPACK_STR \ 4002 assert(pat); assert(patend); assert(s); assert(strend) 4003 #endif 4004 4005 PERL_CALLCONV SSize_t Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags); 4006 #define PERL_ARGS_ASSERT_UNPACKSTRING \ 4007 assert(pat); assert(patend); assert(s); assert(strend) 4008 PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); 4009 #define PERL_ARGS_ASSERT_UNSHARE_HEK 4010 PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); 4011 #define PERL_ARGS_ASSERT_UNSHAREPVN 4012 PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv); 4013 #define PERL_ARGS_ASSERT_UPG_VERSION \ 4014 assert(ver) 4015 PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, Size_t bytelen, Size_t *newlen); 4016 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ 4017 assert(p); assert(d); assert(newlen) 4018 PERL_CALLCONV U8* Perl_utf16_to_utf8_base(pTHX_ U8* p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); 4019 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_BASE \ 4020 assert(p); assert(d); assert(newlen) 4021 PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, Size_t bytelen, Size_t *newlen); 4022 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ 4023 assert(p); assert(d); assert(newlen) 4024 #ifndef PERL_NO_INLINE_FUNCTIONS 4025 PERL_STATIC_INLINE IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) 4026 __attribute__warn_unused_result__; 4027 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ 4028 assert(a); assert(b) 4029 #endif 4030 4031 #ifndef PERL_NO_INLINE_FUNCTIONS 4032 PERL_STATIC_INLINE U8* Perl_utf8_hop(const U8 *s, SSize_t off) 4033 __attribute__warn_unused_result__; 4034 #define PERL_ARGS_ASSERT_UTF8_HOP \ 4035 assert(s) 4036 #endif 4037 4038 #ifndef PERL_NO_INLINE_FUNCTIONS 4039 PERL_STATIC_INLINE U8* Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 *start) 4040 __attribute__warn_unused_result__; 4041 #define PERL_ARGS_ASSERT_UTF8_HOP_BACK \ 4042 assert(s); assert(start) 4043 #endif 4044 4045 #ifndef PERL_NO_INLINE_FUNCTIONS 4046 PERL_STATIC_INLINE U8* Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 *end) 4047 __attribute__warn_unused_result__; 4048 #define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD \ 4049 assert(s); assert(end) 4050 #endif 4051 4052 #ifndef PERL_NO_INLINE_FUNCTIONS 4053 PERL_STATIC_INLINE U8* Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 *start, const U8 *end) 4054 __attribute__warn_unused_result__; 4055 #define PERL_ARGS_ASSERT_UTF8_HOP_SAFE \ 4056 assert(s); assert(start); assert(end) 4057 #endif 4058 4059 PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) 4060 __attribute__warn_unused_result__; 4061 #define PERL_ARGS_ASSERT_UTF8_LENGTH \ 4062 assert(s); assert(e) 4063 4064 PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); 4065 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ 4066 assert(s); assert(lenp) 4067 PERL_CALLCONV U8* Perl_utf8_to_utf16_base(pTHX_ U8* s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); 4068 #define PERL_ARGS_ASSERT_UTF8_TO_UTF16_BASE \ 4069 assert(s); assert(d); assert(newlen) 4070 #ifndef NO_MATHOMS 4071 PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 4072 __attribute__deprecated__; 4073 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ 4074 assert(s) 4075 #endif 4076 4077 PERL_CALLCONV UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); 4078 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ 4079 assert(s); assert(send) 4080 #ifndef PERL_NO_INLINE_FUNCTIONS 4081 PERL_STATIC_INLINE UV Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); 4082 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER \ 4083 assert(s); assert(send) 4084 #endif 4085 #ifndef NO_MATHOMS 4086 PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4087 __attribute__deprecated__; 4088 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ 4089 assert(s) 4090 #endif 4091 4092 PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) 4093 __attribute__deprecated__; 4094 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \ 4095 assert(s); assert(send) 4096 4097 PERL_CALLCONV UV Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); 4098 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 4099 assert(s) 4100 PERL_CALLCONV UV Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors); 4101 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR \ 4102 assert(s) 4103 #ifndef PERL_NO_INLINE_FUNCTIONS 4104 PERL_STATIC_INLINE UV Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); 4105 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ 4106 assert(s) 4107 #endif 4108 #ifndef NO_MATHOMS 4109 PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 4110 __attribute__deprecated__; 4111 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ 4112 assert(s) 4113 #endif 4114 4115 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg); 4116 #define PERL_ARGS_ASSERT_UTILIZE \ 4117 assert(idop) 4118 /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ 4119 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 4120 /* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ 4121 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS 4122 /* PERL_CALLCONV U8* uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV ** msgs); */ 4123 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS_MSGS 4124 PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); 4125 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ 4126 assert(d) 4127 PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV** msgs); 4128 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ 4129 assert(d) 4130 PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv); 4131 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ 4132 assert(d) 4133 #ifndef NO_MATHOMS 4134 PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4135 __attribute__deprecated__; 4136 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ 4137 assert(d) 4138 #endif 4139 4140 #ifndef PERL_NO_INLINE_FUNCTIONS 4141 PERL_STATIC_INLINE UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) 4142 __attribute__warn_unused_result__; 4143 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ 4144 assert(s) 4145 #endif 4146 4147 #ifndef NO_MATHOMS 4148 PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4149 __attribute__deprecated__; 4150 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ 4151 assert(s) 4152 #endif 4153 4154 PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash); 4155 #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ 4156 assert(name) 4157 PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv); 4158 #define PERL_ARGS_ASSERT_VCMP \ 4159 assert(lhv); assert(rhv) 4160 PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args) 4161 __attribute__noreturn__; 4162 #define PERL_ARGS_ASSERT_VCROAK 4163 4164 PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args); 4165 #define PERL_ARGS_ASSERT_VDEB \ 4166 assert(pat) 4167 PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args); 4168 #define PERL_ARGS_ASSERT_VFORM \ 4169 assert(pat) 4170 PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv); 4171 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ 4172 assert(sv) 4173 PERL_CALLCONV SV* Perl_vivify_ref(pTHX_ SV* sv, U32 to_what) 4174 __attribute__warn_unused_result__; 4175 #define PERL_ARGS_ASSERT_VIVIFY_REF \ 4176 assert(sv) 4177 4178 PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args); 4179 #define PERL_ARGS_ASSERT_VLOAD_MODULE \ 4180 assert(name) 4181 PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args); 4182 #define PERL_ARGS_ASSERT_VMESS \ 4183 assert(pat) 4184 PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args) 4185 __attribute__warn_unused_result__; 4186 #define PERL_ARGS_ASSERT_VNEWSVPVF \ 4187 assert(pat) 4188 4189 PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs); 4190 #define PERL_ARGS_ASSERT_VNORMAL \ 4191 assert(vs) 4192 PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs); 4193 #define PERL_ARGS_ASSERT_VNUMIFY \ 4194 assert(vs) 4195 PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs); 4196 #define PERL_ARGS_ASSERT_VSTRINGIFY \ 4197 assert(vs) 4198 PERL_CALLCONV SV* Perl_vverify(pTHX_ SV *vs); 4199 #define PERL_ARGS_ASSERT_VVERIFY \ 4200 assert(vs) 4201 PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args); 4202 #define PERL_ARGS_ASSERT_VWARN \ 4203 assert(pat) 4204 PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args); 4205 #define PERL_ARGS_ASSERT_VWARNER \ 4206 assert(pat) 4207 PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags); 4208 #define PERL_ARGS_ASSERT_WAIT4PID \ 4209 assert(statusp) 4210 PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...) 4211 __attribute__format__(__printf__,pTHX_1,pTHX_2); 4212 #define PERL_ARGS_ASSERT_WARN \ 4213 assert(pat) 4214 4215 PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex); 4216 #define PERL_ARGS_ASSERT_WARN_SV \ 4217 assert(baseex) 4218 PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) 4219 __attribute__format__(__printf__,pTHX_2,pTHX_3); 4220 #define PERL_ARGS_ASSERT_WARNER \ 4221 assert(pat) 4222 4223 PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) 4224 __attribute__warn_unused_result__; 4225 #define PERL_ARGS_ASSERT_WAS_LVALUE_SUB 4226 4227 PERL_CALLCONV void Perl_watch(pTHX_ char** addr); 4228 #define PERL_ARGS_ASSERT_WATCH \ 4229 assert(addr) 4230 /* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig); */ 4231 #define PERL_ARGS_ASSERT_WHICHSIG 4232 PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig); 4233 #define PERL_ARGS_ASSERT_WHICHSIG_PV \ 4234 assert(sig) 4235 PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char* sig, STRLEN len); 4236 #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ 4237 assert(sig) 4238 PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV* sigsv); 4239 #define PERL_ARGS_ASSERT_WHICHSIG_SV \ 4240 assert(sigsv) 4241 PERL_CALLCONV void Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p); 4242 #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN \ 4243 assert(new_plugin); assert(old_plugin_p) 4244 PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p); 4245 #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ 4246 assert(new_checker); assert(old_checker_p) 4247 PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv); 4248 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ 4249 assert(msv) 4250 PERL_CALLCONV void Perl_xs_boot_epilog(pTHX_ const I32 ax); 4251 #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG 4252 PERL_CALLCONV I32 Perl_xs_handshake(const U32 key, void * v_my_perl, const char * file, ...); 4253 #define PERL_ARGS_ASSERT_XS_HANDSHAKE \ 4254 assert(v_my_perl); assert(file) 4255 PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s); 4256 #define PERL_ARGS_ASSERT_YYERROR \ 4257 assert(s) 4258 PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags); 4259 #define PERL_ARGS_ASSERT_YYERROR_PV \ 4260 assert(s) 4261 PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags); 4262 #define PERL_ARGS_ASSERT_YYERROR_PVN 4263 PERL_CALLCONV int Perl_yylex(pTHX); 4264 #define PERL_ARGS_ASSERT_YYLEX 4265 PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); 4266 #define PERL_ARGS_ASSERT_YYPARSE 4267 PERL_CALLCONV void Perl_yyquit(pTHX); 4268 #define PERL_ARGS_ASSERT_YYQUIT 4269 PERL_CALLCONV void Perl_yyunlex(pTHX); 4270 #define PERL_ARGS_ASSERT_YYUNLEX 4271 #if ! defined(HAS_MEMRCHR) && (defined(PERL_CORE) || defined(PERL_EXT)) 4272 #ifndef PERL_NO_INLINE_FUNCTIONS 4273 PERL_STATIC_INLINE void * S_my_memrchr(const char * s, const char c, const STRLEN len); 4274 #define PERL_ARGS_ASSERT_MY_MEMRCHR \ 4275 assert(s) 4276 #endif 4277 #endif 4278 #if !(!defined(PERL_EXT_RE_BUILD)) 4279 # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 4280 PERL_CALLCONV SV* Perl_get_re_gclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist); 4281 #define PERL_ARGS_ASSERT_GET_RE_GCLASS_NONBITMAP_DATA \ 4282 assert(node) 4283 # endif 4284 #endif 4285 #if !(defined(DEBUGGING)) 4286 # if !defined(NV_PRESERVES_UV) 4287 # if defined(PERL_IN_SV_C) 4288 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv); 4289 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 4290 assert(sv) 4291 # endif 4292 # endif 4293 #endif 4294 #if !(defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H)) 4295 PERL_CALLCONV const char* Perl_langinfo(const int item); 4296 #define PERL_ARGS_ASSERT_PERL_LANGINFO 4297 #endif 4298 #if !(defined(HAS_NL_LANGINFO)) 4299 # if defined(PERL_IN_LOCALE_C) 4300 STATIC const char* S_my_nl_langinfo(const int item, bool toggle); 4301 #define PERL_ARGS_ASSERT_MY_NL_LANGINFO 4302 # endif 4303 #endif 4304 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) 4305 PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); 4306 #define PERL_ARGS_ASSERT_DO_EXEC \ 4307 assert(cmd) 4308 #endif 4309 #if !(defined(PERL_USE_3ARG_SIGHANDLER)) 4310 PERL_CALLCONV Signal_t Perl_csighandler(int sig); 4311 #define PERL_ARGS_ASSERT_CSIGHANDLER 4312 PERL_CALLCONV Signal_t Perl_sighandler(int sig); 4313 #define PERL_ARGS_ASSERT_SIGHANDLER 4314 #endif 4315 #if !(defined(_MSC_VER)) 4316 PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 4317 __attribute__noreturn__; 4318 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 4319 assert(sv); assert(mg) 4320 4321 #endif 4322 #if !defined(EBCDIC) 4323 #ifndef PERL_NO_INLINE_FUNCTIONS 4324 PERL_STATIC_INLINE unsigned int Perl_variant_byte_number(PERL_UINTMAX_T word) 4325 __attribute__warn_unused_result__; 4326 #define PERL_ARGS_ASSERT_VARIANT_BYTE_NUMBER 4327 #endif 4328 4329 #endif 4330 #if !defined(HAS_GETENV_LEN) 4331 PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len); 4332 #define PERL_ARGS_ASSERT_GETENV_LEN \ 4333 assert(env_elem); assert(len) 4334 #endif 4335 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) 4336 # if defined(PERL_IN_PP_SYS_C) 4337 STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) 4338 __attribute__warn_unused_result__; 4339 #define PERL_ARGS_ASSERT_DOONELINER \ 4340 assert(cmd); assert(filename) 4341 4342 # endif 4343 #endif 4344 #if !defined(HAS_MKOSTEMP) 4345 PERL_CALLCONV int Perl_my_mkostemp(char *templte, int flags); 4346 #define PERL_ARGS_ASSERT_MY_MKOSTEMP \ 4347 assert(templte) 4348 #endif 4349 #if !defined(HAS_MKSTEMP) 4350 PERL_CALLCONV int Perl_my_mkstemp(char *templte); 4351 #define PERL_ARGS_ASSERT_MY_MKSTEMP \ 4352 assert(templte) 4353 #endif 4354 #if !defined(HAS_RENAME) 4355 PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b); 4356 #define PERL_ARGS_ASSERT_SAME_DIRENT \ 4357 assert(a); assert(b) 4358 #endif 4359 #if !defined(HAS_SIGNBIT) 4360 PERL_CALLCONV int Perl_signbit(NV f) 4361 __attribute__warn_unused_result__ 4362 __attribute__pure__; 4363 #define PERL_ARGS_ASSERT_PERL_SIGNBIT 4364 4365 #endif 4366 #if !defined(HAS_STRLCAT) 4367 PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); 4368 #define PERL_ARGS_ASSERT_MY_STRLCAT 4369 #endif 4370 #if !defined(HAS_STRLCPY) 4371 PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); 4372 #define PERL_ARGS_ASSERT_MY_STRLCPY 4373 #endif 4374 #if !defined(HAS_STRNLEN) 4375 #ifndef PERL_NO_INLINE_FUNCTIONS 4376 PERL_STATIC_INLINE Size_t Perl_my_strnlen(const char *str, Size_t maxlen); 4377 #define PERL_ARGS_ASSERT_MY_STRNLEN \ 4378 assert(str) 4379 #endif 4380 #endif 4381 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) 4382 PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) 4383 __attribute__warn_unused_result__; 4384 #define PERL_ARGS_ASSERT_MY_CHSIZE 4385 4386 #endif 4387 #if !defined(NV_PRESERVES_UV) 4388 # if defined(DEBUGGING) 4389 # if defined(PERL_IN_SV_C) 4390 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype); 4391 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 4392 assert(sv) 4393 # endif 4394 # endif 4395 #endif 4396 #if !defined(PERL_DISABLE_PMC) 4397 # if defined(PERL_IN_PP_CTL_C) 4398 STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) 4399 __attribute__warn_unused_result__; 4400 #define PERL_ARGS_ASSERT_DOOPEN_PM \ 4401 assert(name) 4402 4403 # endif 4404 #endif 4405 #if !defined(PERL_EXT_RE_BUILD) 4406 # if defined(PERL_IN_REGCOMP_C) 4407 STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end); 4408 #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ 4409 assert(invlist) 4410 #ifndef PERL_NO_INLINE_FUNCTIONS 4411 PERL_STATIC_INLINE UV* S__invlist_array_init(SV* const invlist, const bool will_have_0) 4412 __attribute__warn_unused_result__; 4413 #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ 4414 assert(invlist) 4415 #endif 4416 4417 #ifndef PERL_NO_INLINE_FUNCTIONS 4418 PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist) 4419 __attribute__warn_unused_result__; 4420 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ 4421 assert(invlist) 4422 #endif 4423 4424 STATIC void S_initialize_invlist_guts(pTHX_ SV* invlist, const Size_t initial_size); 4425 #define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ 4426 assert(invlist) 4427 #ifndef PERL_NO_INLINE_FUNCTIONS 4428 PERL_STATIC_INLINE void S_invlist_clear(pTHX_ SV* invlist); 4429 #define PERL_ARGS_ASSERT_INVLIST_CLEAR \ 4430 assert(invlist) 4431 #endif 4432 #ifndef PERL_NO_INLINE_FUNCTIONS 4433 PERL_STATIC_INLINE UV S_invlist_max(SV* const invlist) 4434 __attribute__warn_unused_result__; 4435 #define PERL_ARGS_ASSERT_INVLIST_MAX \ 4436 assert(invlist) 4437 #endif 4438 4439 #ifndef PERL_NO_INLINE_FUNCTIONS 4440 PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist) 4441 __attribute__warn_unused_result__; 4442 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ 4443 assert(invlist) 4444 #endif 4445 4446 STATIC void S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); 4447 #define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC \ 4448 assert(dest); assert(src) 4449 #ifndef PERL_NO_INLINE_FUNCTIONS 4450 PERL_STATIC_INLINE void S_invlist_set_previous_index(SV* const invlist, const IV index); 4451 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ 4452 assert(invlist) 4453 #endif 4454 #ifndef PERL_NO_INLINE_FUNCTIONS 4455 PERL_STATIC_INLINE void S_invlist_trim(SV* invlist); 4456 #define PERL_ARGS_ASSERT_INVLIST_TRIM \ 4457 assert(invlist) 4458 #endif 4459 # endif 4460 # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 4461 PERL_CALLCONV SV* Perl_get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist); 4462 #define PERL_ARGS_ASSERT_GET_REGCLASS_NONBITMAP_DATA \ 4463 assert(node) 4464 # endif 4465 #endif 4466 #if !defined(PERL_IMPLICIT_SYS) 4467 PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); 4468 #define PERL_ARGS_ASSERT_MY_PCLOSE 4469 PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode); 4470 #define PERL_ARGS_ASSERT_MY_POPEN \ 4471 assert(cmd); assert(mode) 4472 #endif 4473 #if !defined(PERL_IS_MINIPERL) 4474 # if defined(PERL_IN_PERL_C) 4475 STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem); 4476 #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ 4477 assert(av); assert(dir); assert(stem) 4478 # endif 4479 #endif 4480 #if !defined(PERL_NO_INLINE_FUNCTIONS) 4481 #ifndef PERL_NO_INLINE_FUNCTIONS 4482 PERL_STATIC_INLINE void Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx); 4483 #define PERL_ARGS_ASSERT_CX_POPBLOCK \ 4484 assert(cx) 4485 #endif 4486 #ifndef PERL_NO_INLINE_FUNCTIONS 4487 PERL_STATIC_INLINE void Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx); 4488 #define PERL_ARGS_ASSERT_CX_POPEVAL \ 4489 assert(cx) 4490 #endif 4491 #ifndef PERL_NO_INLINE_FUNCTIONS 4492 PERL_STATIC_INLINE void Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx); 4493 #define PERL_ARGS_ASSERT_CX_POPFORMAT \ 4494 assert(cx) 4495 #endif 4496 #ifndef PERL_NO_INLINE_FUNCTIONS 4497 PERL_STATIC_INLINE void Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx); 4498 #define PERL_ARGS_ASSERT_CX_POPGIVEN \ 4499 assert(cx) 4500 #endif 4501 #ifndef PERL_NO_INLINE_FUNCTIONS 4502 PERL_STATIC_INLINE void Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx); 4503 #define PERL_ARGS_ASSERT_CX_POPLOOP \ 4504 assert(cx) 4505 #endif 4506 #ifndef PERL_NO_INLINE_FUNCTIONS 4507 PERL_STATIC_INLINE void Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx); 4508 #define PERL_ARGS_ASSERT_CX_POPSUB \ 4509 assert(cx) 4510 #endif 4511 #ifndef PERL_NO_INLINE_FUNCTIONS 4512 PERL_STATIC_INLINE void Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); 4513 #define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ 4514 assert(cx) 4515 #endif 4516 #ifndef PERL_NO_INLINE_FUNCTIONS 4517 PERL_STATIC_INLINE void Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); 4518 #define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ 4519 assert(cx) 4520 #endif 4521 #ifndef PERL_NO_INLINE_FUNCTIONS 4522 PERL_STATIC_INLINE void Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx); 4523 #define PERL_ARGS_ASSERT_CX_POPWHEN \ 4524 assert(cx) 4525 #endif 4526 #ifndef PERL_NO_INLINE_FUNCTIONS 4527 PERL_STATIC_INLINE PERL_CONTEXT * Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix); 4528 #define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ 4529 assert(sp) 4530 #endif 4531 #ifndef PERL_NO_INLINE_FUNCTIONS 4532 PERL_STATIC_INLINE void Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); 4533 #define PERL_ARGS_ASSERT_CX_PUSHEVAL \ 4534 assert(cx) 4535 #endif 4536 #ifndef PERL_NO_INLINE_FUNCTIONS 4537 PERL_STATIC_INLINE void Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); 4538 #define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ 4539 assert(cx); assert(cv) 4540 #endif 4541 #ifndef PERL_NO_INLINE_FUNCTIONS 4542 PERL_STATIC_INLINE void Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); 4543 #define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ 4544 assert(cx) 4545 #endif 4546 #ifndef PERL_NO_INLINE_FUNCTIONS 4547 PERL_STATIC_INLINE void Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); 4548 #define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ 4549 assert(cx); assert(itervarp) 4550 #endif 4551 #ifndef PERL_NO_INLINE_FUNCTIONS 4552 PERL_STATIC_INLINE void Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); 4553 #define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ 4554 assert(cx) 4555 #endif 4556 #ifndef PERL_NO_INLINE_FUNCTIONS 4557 PERL_STATIC_INLINE void Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); 4558 #define PERL_ARGS_ASSERT_CX_PUSHSUB \ 4559 assert(cx); assert(cv) 4560 #endif 4561 #ifndef PERL_NO_INLINE_FUNCTIONS 4562 PERL_STATIC_INLINE void Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop); 4563 #define PERL_ARGS_ASSERT_CX_PUSHTRY \ 4564 assert(cx) 4565 #endif 4566 #ifndef PERL_NO_INLINE_FUNCTIONS 4567 PERL_STATIC_INLINE void Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); 4568 #define PERL_ARGS_ASSERT_CX_PUSHWHEN \ 4569 assert(cx) 4570 #endif 4571 #ifndef PERL_NO_INLINE_FUNCTIONS 4572 PERL_STATIC_INLINE void Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx); 4573 #define PERL_ARGS_ASSERT_CX_TOPBLOCK \ 4574 assert(cx) 4575 #endif 4576 #ifndef PERL_NO_INLINE_FUNCTIONS 4577 PERL_STATIC_INLINE U8 Perl_gimme_V(pTHX); 4578 #define PERL_ARGS_ASSERT_GIMME_V 4579 #endif 4580 #endif 4581 #if !defined(PERL_NO_UTF16_FILTER) 4582 # if defined(PERL_IN_TOKE_C) 4583 STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed); 4584 #define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ 4585 assert(s) 4586 STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); 4587 #define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ 4588 assert(sv) 4589 # endif 4590 #endif 4591 #if !defined(PURIFY) 4592 # if defined(PERL_IN_HV_C) 4593 STATIC HE* S_new_he(pTHX) 4594 __attribute__warn_unused_result__; 4595 #define PERL_ARGS_ASSERT_NEW_HE 4596 4597 # endif 4598 #endif 4599 #if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) 4600 # if defined(PERL_IN_PERL_C) 4601 STATIC void S_validate_suid(pTHX_ PerlIO *rsfp); 4602 #define PERL_ARGS_ASSERT_VALIDATE_SUID \ 4603 assert(rsfp) 4604 # endif 4605 #endif 4606 #if !defined(USE_ITHREADS) 4607 /* PERL_CALLCONV void CopFILEGV_set(pTHX_ COP * c, GV * gv); */ 4608 #define PERL_ARGS_ASSERT_COPFILEGV_SET 4609 #endif 4610 #if !defined(WIN32) 4611 PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report); 4612 #define PERL_ARGS_ASSERT_DO_EXEC3 \ 4613 assert(incmd) 4614 #endif 4615 #if 0 /* Not currently used, but may be needed in the future */ 4616 # if defined(PERL_IN_UTF8_C) 4617 STATIC void S_warn_on_first_deprecated_use(pTHX_ const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line); 4618 #define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \ 4619 assert(name); assert(alternative); assert(file) 4620 # endif 4621 #endif 4622 #if defined (HAS_SOCKETPAIR) || (defined (HAS_SOCKET) && defined(SOCK_DGRAM) && defined(AF_INET) && defined(PF_INET)) 4623 PERL_CALLCONV int Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int *pairfd) 4624 __attribute__warn_unused_result__; 4625 #define PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC \ 4626 assert(pairfd) 4627 4628 #endif 4629 #if defined(DEBUGGING) 4630 PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) 4631 __attribute__warn_unused_result__; 4632 #define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ 4633 assert(s) 4634 4635 PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv); 4636 #define PERL_ARGS_ASSERT_HV_ASSERT \ 4637 assert(hv) 4638 PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv); 4639 #define PERL_ARGS_ASSERT_PAD_SETSV \ 4640 assert(sv) 4641 PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); 4642 #define PERL_ARGS_ASSERT_PAD_SV 4643 PERL_CALLCONV void Perl_set_padlist(CV * cv, PADLIST * padlist); 4644 #define PERL_ARGS_ASSERT_SET_PADLIST \ 4645 assert(cv) 4646 # if defined(PERL_IN_LOCALE_C) 4647 # if defined(USE_LOCALE) 4648 STATIC void S_print_bytes_for_locale(pTHX_ const char * const s, const char * const e, const bool is_utf8); 4649 #define PERL_ARGS_ASSERT_PRINT_BYTES_FOR_LOCALE \ 4650 assert(s); assert(e) 4651 STATIC void S_print_collxfrm_input_and_return(pTHX_ const char * const s, const char * const e, const STRLEN * const xlen, const bool is_utf8); 4652 #define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ 4653 assert(s); assert(e) 4654 STATIC char * S_setlocale_debug_string(const int category, const char* const locale, const char* const retval) 4655 __attribute__warn_unused_result__; 4656 #define PERL_ARGS_ASSERT_SETLOCALE_DEBUG_STRING 4657 4658 # endif 4659 # endif 4660 # if defined(PERL_IN_PAD_C) 4661 STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title); 4662 #define PERL_ARGS_ASSERT_CV_DUMP \ 4663 assert(cv); assert(title) 4664 # endif 4665 # if defined(PERL_IN_REGCOMP_C) 4666 STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth); 4667 #define PERL_ARGS_ASSERT_DUMP_TRIE \ 4668 assert(trie); assert(revcharmap) 4669 STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); 4670 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ 4671 assert(trie); assert(revcharmap) 4672 STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); 4673 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ 4674 assert(trie); assert(revcharmap) 4675 STATIC const regnode* S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV* sv, I32 indent, U32 depth); 4676 #define PERL_ARGS_ASSERT_DUMPUNTIL \ 4677 assert(r); assert(start); assert(node); assert(sv) 4678 STATIC bool S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV* nonbitmap_invlist, SV* only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display); 4679 #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \ 4680 assert(sv) 4681 STATIC SV* S_put_charclass_bitmap_innards_common(pTHX_ SV* invlist, SV* posixes, SV* only_utf8, SV* not_utf8, SV* only_utf8_locale, const bool invert); 4682 #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON \ 4683 assert(invlist) 4684 STATIC void S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV* invlist); 4685 #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST \ 4686 assert(sv); assert(invlist) 4687 STATIC void S_put_code_point(pTHX_ SV* sv, UV c); 4688 #define PERL_ARGS_ASSERT_PUT_CODE_POINT \ 4689 assert(sv) 4690 STATIC void S_put_range(pTHX_ SV* sv, UV start, const UV end, const bool allow_literals); 4691 #define PERL_ARGS_ASSERT_PUT_RANGE \ 4692 assert(sv) 4693 PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...); 4694 #define PERL_ARGS_ASSERT_RE_INDENTF \ 4695 assert(fmt) 4696 STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); 4697 #define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS 4698 STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags); 4699 #define PERL_ARGS_ASSERT_REGDUMP_INTFLAGS 4700 STATIC bool S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) 4701 __attribute__warn_unused_result__; 4702 #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ 4703 assert(pRExC_state); assert(p); assert(val) 4704 4705 # endif 4706 # if defined(PERL_IN_REGEXEC_C) 4707 STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb); 4708 #define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ 4709 assert(prog); assert(start); assert(end); assert(blurb) 4710 STATIC void S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth); 4711 #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ 4712 assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry) 4713 PERL_CALLCONV int Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...); 4714 #define PERL_ARGS_ASSERT_RE_EXEC_INDENTF \ 4715 assert(fmt) 4716 # endif 4717 # if defined(PERL_IN_SV_C) 4718 STATIC void S_del_sv(pTHX_ SV *p); 4719 #define PERL_ARGS_ASSERT_DEL_SV \ 4720 assert(p) 4721 # endif 4722 # if defined(PERL_IN_TOKE_C) 4723 STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s) 4724 __attribute__format__(__printf__,pTHX_1,0); 4725 #define PERL_ARGS_ASSERT_PRINTBUF \ 4726 assert(fmt); assert(s) 4727 4728 STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp); 4729 #define PERL_ARGS_ASSERT_TOKEREPORT \ 4730 assert(lvalp) 4731 # endif 4732 #endif 4733 #if defined(DEBUGGING) && defined(ENABLE_REGEX_SETS_DEBUGGING) 4734 # if defined(PERL_IN_REGCOMP_C) 4735 STATIC void S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV * stack, const IV fence, AV * fence_stack); 4736 #define PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES \ 4737 assert(pRExC_state); assert(stack); assert(fence_stack) 4738 # endif 4739 #endif 4740 #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) 4741 PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv); 4742 #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ 4743 assert(sv) 4744 #endif 4745 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) 4746 PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp); 4747 #define PERL_ARGS_ASSERT_DO_IPCCTL \ 4748 assert(mark); assert(sp) 4749 PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV** mark, SV** sp); 4750 #define PERL_ARGS_ASSERT_DO_IPCGET \ 4751 assert(mark); assert(sp) 4752 PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV** mark, SV** sp); 4753 #define PERL_ARGS_ASSERT_DO_MSGRCV \ 4754 assert(mark); assert(sp) 4755 PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV** mark, SV** sp); 4756 #define PERL_ARGS_ASSERT_DO_MSGSND \ 4757 assert(mark); assert(sp) 4758 PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV** mark, SV** sp); 4759 #define PERL_ARGS_ASSERT_DO_SEMOP \ 4760 assert(mark); assert(sp) 4761 PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp); 4762 #define PERL_ARGS_ASSERT_DO_SHMIO \ 4763 assert(mark); assert(sp) 4764 #endif 4765 #if defined(HAS_NL_LANGINFO) 4766 # if defined(PERL_IN_LOCALE_C) 4767 STATIC const char* S_my_nl_langinfo(const nl_item item, bool toggle); 4768 #define PERL_ARGS_ASSERT_MY_NL_LANGINFO 4769 # endif 4770 #endif 4771 #if defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H) 4772 PERL_CALLCONV const char* Perl_langinfo(const nl_item item); 4773 #define PERL_ARGS_ASSERT_PERL_LANGINFO 4774 #endif 4775 #if defined(HAS_PIPE) 4776 PERL_CALLCONV int Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) 4777 __attribute__warn_unused_result__; 4778 #define PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC \ 4779 assert(pipefd) 4780 4781 #endif 4782 #if defined(HAS_SOCKET) 4783 PERL_CALLCONV int Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen) 4784 __attribute__warn_unused_result__; 4785 #define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC 4786 4787 PERL_CALLCONV int Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) 4788 __attribute__warn_unused_result__; 4789 #define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC 4790 4791 #endif 4792 #if defined(HAVE_INTERP_INTERN) 4793 PERL_CALLCONV void Perl_sys_intern_clear(pTHX); 4794 #define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR 4795 PERL_CALLCONV void Perl_sys_intern_init(pTHX); 4796 #define PERL_ARGS_ASSERT_SYS_INTERN_INIT 4797 # if defined(USE_ITHREADS) 4798 PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst); 4799 #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ 4800 assert(src); assert(dst) 4801 # endif 4802 #endif 4803 #if defined(MULTIPLICITY) 4804 PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...) 4805 __attribute__noreturn__ 4806 __attribute__format__null_ok__(__printf__,1,2); 4807 #define PERL_ARGS_ASSERT_CROAK_NOCONTEXT 4808 4809 PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) 4810 __attribute__format__(__printf__,1,2); 4811 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ 4812 assert(pat) 4813 4814 PERL_CALLCONV_NO_RET OP* Perl_die_nocontext(const char* pat, ...) 4815 __attribute__noreturn__ 4816 __attribute__format__null_ok__(__printf__,1,2); 4817 #define PERL_ARGS_ASSERT_DIE_NOCONTEXT 4818 4819 PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) 4820 __attribute__format__(__printf__,1,2); 4821 #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ 4822 assert(pat) 4823 4824 #ifndef NO_MATHOMS 4825 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) 4826 __attribute__deprecated__ 4827 __attribute__format__(__printf__,2,3); 4828 #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ 4829 assert(stream); assert(format) 4830 #endif 4831 4832 PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...); 4833 #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ 4834 assert(name) 4835 PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...) 4836 __attribute__format__(__printf__,1,2); 4837 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ 4838 assert(pat) 4839 4840 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *indexp, size_t size); 4841 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 4842 assert(indexp) 4843 PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) 4844 __attribute__format__(__printf__,1,2); 4845 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ 4846 assert(pat) 4847 4848 #ifndef NO_MATHOMS 4849 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) 4850 __attribute__deprecated__ 4851 __attribute__format__(__printf__,1,2); 4852 #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ 4853 assert(format) 4854 #endif 4855 4856 PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 4857 __attribute__format__(__printf__,2,3); 4858 #define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ 4859 assert(sv); assert(pat) 4860 4861 PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...) 4862 __attribute__format__(__printf__,2,3); 4863 #define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ 4864 assert(sv); assert(pat) 4865 4866 PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 4867 __attribute__format__(__printf__,2,3); 4868 #define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ 4869 assert(sv); assert(pat) 4870 4871 PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...) 4872 __attribute__format__(__printf__,2,3); 4873 #define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ 4874 assert(sv); assert(pat) 4875 4876 PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...) 4877 __attribute__format__(__printf__,1,2); 4878 #define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ 4879 assert(pat) 4880 4881 PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) 4882 __attribute__format__(__printf__,2,3); 4883 #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ 4884 assert(pat) 4885 4886 #endif 4887 #if defined(MYMALLOC) 4888 PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s); 4889 #define PERL_ARGS_ASSERT_DUMP_MSTATS \ 4890 assert(s) 4891 PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level); 4892 #define PERL_ARGS_ASSERT_GET_MSTATS \ 4893 assert(buf) 4894 PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) 4895 __attribute__warn_unused_result__; 4896 #define PERL_ARGS_ASSERT_MALLOC_GOOD_SIZE 4897 4898 PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) 4899 __attribute__warn_unused_result__; 4900 #define PERL_ARGS_ASSERT_MALLOCED_SIZE \ 4901 assert(p) 4902 4903 #endif 4904 #if defined(PERL_ANY_COW) 4905 PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dsv, SV* ssv); 4906 #define PERL_ARGS_ASSERT_SV_SETSV_COW \ 4907 assert(ssv) 4908 #endif 4909 #if defined(PERL_CORE) 4910 PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab); 4911 #define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ 4912 assert(slab) 4913 PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab); 4914 #define PERL_ARGS_ASSERT_OPSLAB_FREE \ 4915 assert(slab) 4916 PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab); 4917 #define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ 4918 assert(slab) 4919 PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab); 4920 #define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ 4921 assert(parser); assert(slab) 4922 #ifndef PERL_NO_INLINE_FUNCTIONS 4923 PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv) 4924 __attribute__warn_unused_result__; 4925 #define PERL_ARGS_ASSERT_SHOULD_WARN_NL \ 4926 assert(pv) 4927 #endif 4928 4929 # if defined(PERL_DEBUG_READONLY_OPS) 4930 PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab); 4931 #define PERL_ARGS_ASSERT_SLAB_TO_RO \ 4932 assert(slab) 4933 PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab); 4934 #define PERL_ARGS_ASSERT_SLAB_TO_RW \ 4935 assert(slab) 4936 # endif 4937 #endif 4938 #if defined(PERL_CORE) || defined (PERL_EXT) 4939 #ifndef PERL_NO_INLINE_FUNCTIONS 4940 PERL_STATIC_INLINE bool Perl_is_utf8_non_invariant_string(const U8* const s, STRLEN len) 4941 __attribute__warn_unused_result__; 4942 #define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \ 4943 assert(s) 4944 #endif 4945 4946 #ifndef PERL_NO_INLINE_FUNCTIONS 4947 PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp); 4948 #define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ 4949 assert(sv); assert(pv) 4950 #endif 4951 #endif 4952 #if defined(PERL_CORE) || defined(PERL_EXT) 4953 PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) 4954 __attribute__warn_unused_result__; 4955 #define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ 4956 assert(s); assert(send) 4957 4958 #ifndef PERL_NO_INLINE_FUNCTIONS 4959 PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8* const s, const U8* const e) 4960 __attribute__warn_unused_result__; 4961 #define PERL_ARGS_ASSERT_VARIANT_UNDER_UTF8_COUNT \ 4962 assert(s); assert(e) 4963 #endif 4964 4965 #endif 4966 #if defined(PERL_CR_FILTER) 4967 # if defined(PERL_IN_TOKE_C) 4968 STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); 4969 #define PERL_ARGS_ASSERT_CR_TEXTFILTER 4970 STATIC void S_strip_return(pTHX_ SV *sv); 4971 #define PERL_ARGS_ASSERT_STRIP_RETURN \ 4972 assert(sv) 4973 # endif 4974 #endif 4975 #if defined(PERL_DEBUG_READONLY_COW) 4976 PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv); 4977 #define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ 4978 assert(sv) 4979 # if defined(PERL_IN_SV_C) 4980 STATIC void S_sv_buf_to_rw(pTHX_ SV *sv); 4981 #define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ 4982 assert(sv) 4983 # endif 4984 #endif 4985 #if defined(PERL_DEBUG_READONLY_OPS) 4986 PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o); 4987 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ 4988 assert(o) 4989 PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); 4990 #define PERL_ARGS_ASSERT_OP_REFCNT_INC 4991 #endif 4992 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) 4993 PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); 4994 #define PERL_ARGS_ASSERT_DO_EXEC \ 4995 assert(cmd) 4996 #endif 4997 #if defined(PERL_DONT_CREATE_GVSV) 4998 #ifndef NO_MATHOMS 4999 PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); 5000 #define PERL_ARGS_ASSERT_GV_SVADD 5001 #endif 5002 #endif 5003 #if defined(PERL_IMPLICIT_SYS) 5004 PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP); 5005 #define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ 5006 assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5007 # if defined(USE_ITHREADS) 5008 PERL_CALLCONV PerlInterpreter* perl_clone_using(PerlInterpreter *proto_perl, UV flags, struct IPerlMem* ipM, struct IPerlMem* ipMS, struct IPerlMem* ipMP, struct IPerlEnv* ipE, struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO, struct IPerlDir* ipD, struct IPerlSock* ipS, struct IPerlProc* ipP); 5009 #define PERL_ARGS_ASSERT_PERL_CLONE_USING \ 5010 assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5011 # endif 5012 #endif 5013 #if defined(PERL_IN_AV_C) 5014 STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av); 5015 #define PERL_ARGS_ASSERT_GET_AUX_MG \ 5016 assert(av) 5017 #endif 5018 #if defined(PERL_IN_DEB_C) 5019 STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max); 5020 #define PERL_ARGS_ASSERT_DEB_STACK_N \ 5021 assert(stack_base) 5022 #endif 5023 #if defined(PERL_IN_DOIO_C) 5024 STATIC bool S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool not_implicit); 5025 #define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ 5026 assert(mg); assert(io) 5027 STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); 5028 #define PERL_ARGS_ASSERT_EXEC_FAILED \ 5029 assert(cmd) 5030 STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) 5031 __attribute__warn_unused_result__; 5032 #define PERL_ARGS_ASSERT_INGROUP 5033 5034 STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp); 5035 #define PERL_ARGS_ASSERT_OPENN_CLEANUP \ 5036 assert(gv); assert(io); assert(mode); assert(oname) 5037 STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype); 5038 #define PERL_ARGS_ASSERT_OPENN_SETUP \ 5039 assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype) 5040 #endif 5041 #if defined(PERL_IN_DOOP_C) 5042 STATIC Size_t S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) 5043 __attribute__warn_unused_result__; 5044 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ 5045 assert(sv); assert(tbl) 5046 5047 STATIC Size_t S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) 5048 __attribute__warn_unused_result__; 5049 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ 5050 assert(sv); assert(tbl) 5051 5052 STATIC Size_t S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const map) 5053 __attribute__warn_unused_result__; 5054 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \ 5055 assert(sv); assert(map) 5056 5057 STATIC Size_t S_do_trans_invmap(pTHX_ SV * const sv, AV * const map) 5058 __attribute__warn_unused_result__; 5059 #define PERL_ARGS_ASSERT_DO_TRANS_INVMAP \ 5060 assert(sv); assert(map) 5061 5062 STATIC Size_t S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) 5063 __attribute__warn_unused_result__; 5064 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ 5065 assert(sv); assert(tbl) 5066 5067 #endif 5068 #if defined(PERL_IN_DUMP_C) 5069 STATIC CV* S_deb_curcv(pTHX_ I32 ix); 5070 #define PERL_ARGS_ASSERT_DEB_CURCV 5071 STATIC void S_debprof(pTHX_ const OP *o); 5072 #define PERL_ARGS_ASSERT_DEBPROF \ 5073 assert(o) 5074 STATIC SV* S_pm_description(pTHX_ const PMOP *pm); 5075 #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ 5076 assert(pm) 5077 STATIC UV S_sequence_num(pTHX_ const OP *o); 5078 #define PERL_ARGS_ASSERT_SEQUENCE_NUM 5079 #endif 5080 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) 5081 PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv); 5082 #define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ 5083 assert(hv) 5084 #endif 5085 #if defined(PERL_IN_GV_C) 5086 STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type); 5087 #define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ 5088 assert(stash); assert(name) 5089 #ifndef PERL_NO_INLINE_FUNCTIONS 5090 PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags); 5091 #define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL 5092 #endif 5093 STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); 5094 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ 5095 assert(gv) 5096 STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8); 5097 #define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ 5098 assert(name) 5099 STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type); 5100 #define PERL_ARGS_ASSERT_GV_MAGICALIZE \ 5101 assert(gv); assert(stash); assert(name) 5102 STATIC void S_gv_magicalize_isa(pTHX_ GV *gv); 5103 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ 5104 assert(gv) 5105 #ifndef PERL_NO_INLINE_FUNCTIONS 5106 PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags); 5107 #define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ 5108 assert(name) 5109 #endif 5110 STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type); 5111 #define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ 5112 assert(gv); assert(name) 5113 STATIC bool S_parse_gv_stash_name(pTHX_ HV **stash, GV **gv, const char **name, STRLEN *len, const char *nambeg, STRLEN full_len, const U32 is_utf8, const I32 add); 5114 #define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ 5115 assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) 5116 STATIC void S_require_tie_mod(pTHX_ GV *gv, const char varname, const char * name, STRLEN len, const U32 flags); 5117 #define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ 5118 assert(gv); assert(varname); assert(name) 5119 #endif 5120 #if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) 5121 PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv); 5122 #define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ 5123 assert(tsv); assert(sv) 5124 #endif 5125 #if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) 5126 PERL_CALLCONV HV* Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags); 5127 #endif 5128 #if defined(PERL_IN_HV_C) 5129 STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items); 5130 #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ 5131 assert(hv) 5132 STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize); 5133 #define PERL_ARGS_ASSERT_HSPLIT \ 5134 assert(hv) 5135 STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv); 5136 #define PERL_ARGS_ASSERT_HV_AUXINIT \ 5137 assert(hv) 5138 STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); 5139 #define PERL_ARGS_ASSERT_HV_DELETE_COMMON 5140 STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry); 5141 #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ 5142 assert(hv); assert(entry) 5143 STATIC void S_hv_free_entries(pTHX_ HV *hv); 5144 #define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ 5145 assert(hv) 5146 STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store); 5147 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ 5148 assert(hv); assert(needs_copy); assert(needs_store) 5149 PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) 5150 __attribute__noreturn__; 5151 #define PERL_ARGS_ASSERT_HV_NOTALLOWED \ 5152 assert(key); assert(msg) 5153 5154 #ifndef PERL_NO_INLINE_FUNCTIONS 5155 PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); 5156 #define PERL_ARGS_ASSERT_PTR_HASH 5157 #endif 5158 STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he); 5159 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ 5160 assert(he) 5161 STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) 5162 __attribute__malloc__ 5163 __attribute__warn_unused_result__; 5164 #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ 5165 assert(str) 5166 5167 STATIC HEK* S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) 5168 __attribute__warn_unused_result__; 5169 #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ 5170 assert(str) 5171 5172 STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); 5173 #define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN 5174 #endif 5175 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) 5176 PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av); 5177 #define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ 5178 assert(sv) 5179 #endif 5180 #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) 5181 PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp); 5182 #define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ 5183 assert(hv); assert(indexp) 5184 #endif 5185 #if defined(PERL_IN_LOCALE_C) 5186 #ifndef PERL_NO_INLINE_FUNCTIONS 5187 PERL_STATIC_INLINE const char * S_save_to_buffer(const char * string, char **buf, Size_t *buf_size, const Size_t offset) 5188 __attribute__warn_unused_result__; 5189 #define PERL_ARGS_ASSERT_SAVE_TO_BUFFER \ 5190 assert(buf_size) 5191 #endif 5192 5193 # if defined(USE_LOCALE) 5194 STATIC const char* S_category_name(const int category); 5195 #define PERL_ARGS_ASSERT_CATEGORY_NAME 5196 STATIC void S_new_collate(pTHX_ const char* newcoll); 5197 #define PERL_ARGS_ASSERT_NEW_COLLATE 5198 STATIC void S_new_ctype(pTHX_ const char* newctype); 5199 #define PERL_ARGS_ASSERT_NEW_CTYPE \ 5200 assert(newctype) 5201 STATIC void S_new_numeric(pTHX_ const char* newnum); 5202 #define PERL_ARGS_ASSERT_NEW_NUMERIC 5203 STATIC void S_restore_switched_locale(pTHX_ const int category, const char * const original_locale); 5204 #define PERL_ARGS_ASSERT_RESTORE_SWITCHED_LOCALE 5205 STATIC void S_set_numeric_radix(pTHX_ const bool use_locale); 5206 #define PERL_ARGS_ASSERT_SET_NUMERIC_RADIX 5207 STATIC char* S_stdize_locale(pTHX_ char* locs); 5208 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ 5209 assert(locs) 5210 STATIC const char* S_switch_category_locale_to_template(pTHX_ const int switch_category, const int template_category, const char * template_locale); 5211 #define PERL_ARGS_ASSERT_SWITCH_CATEGORY_LOCALE_TO_TEMPLATE 5212 # if defined(USE_POSIX_2008_LOCALE) 5213 STATIC const char* S_emulate_setlocale(const int category, const char* locale, unsigned int index, const bool is_index_valid); 5214 #define PERL_ARGS_ASSERT_EMULATE_SETLOCALE 5215 # endif 5216 # if defined(WIN32) 5217 STATIC char* S_win32_setlocale(pTHX_ int category, const char* locale); 5218 #define PERL_ARGS_ASSERT_WIN32_SETLOCALE 5219 # endif 5220 # endif 5221 #endif 5222 #if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_MATHOMS_C) 5223 # if defined(USE_LOCALE_COLLATE) 5224 PERL_CALLCONV char* Perl__mem_collxfrm(pTHX_ const char* input_string, STRLEN len, STRLEN* xlen, bool utf8); 5225 #define PERL_ARGS_ASSERT__MEM_COLLXFRM \ 5226 assert(input_string); assert(xlen) 5227 # endif 5228 #endif 5229 #if defined(PERL_IN_MALLOC_C) 5230 STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p); 5231 #define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ 5232 assert(nbytes_p) 5233 #endif 5234 #if defined(PERL_IN_MG_C) 5235 STATIC void S_fixup_errno_string(pTHX_ SV* sv); 5236 #define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ 5237 assert(sv) 5238 STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val); 5239 #define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ 5240 assert(sv); assert(mg); assert(meth) 5241 STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth); 5242 #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ 5243 assert(sv); assert(mg); assert(meth) 5244 STATIC void S_restore_magic(pTHX_ const void *p); 5245 #define PERL_ARGS_ASSERT_RESTORE_MAGIC 5246 STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags); 5247 #define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ 5248 assert(sv) 5249 STATIC void S_unwind_handler_stack(pTHX_ const void *p); 5250 #define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK 5251 #endif 5252 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) 5253 PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp); 5254 #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ 5255 assert(posp); assert(lenp) 5256 #endif 5257 #if defined(PERL_IN_MRO_C) 5258 STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags); 5259 #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ 5260 assert(isa); assert(name) 5261 STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv); 5262 #define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ 5263 assert(stashes); assert(seen_stashes); assert(namesv) 5264 STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level); 5265 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ 5266 assert(stash) 5267 #endif 5268 #if defined(PERL_IN_NUMERIC_C) 5269 STATIC void S_output_non_portable(pTHX_ const U8 shift); 5270 #define PERL_ARGS_ASSERT_OUTPUT_NON_PORTABLE 5271 #endif 5272 #if defined(PERL_IN_OP_C) 5273 STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs); 5274 #define PERL_ARGS_ASSERT_APPLY_ATTRS \ 5275 assert(stash); assert(target) 5276 STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp); 5277 #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ 5278 assert(stash); assert(target); assert(imopsp) 5279 STATIC I32 S_assignment_type(pTHX_ const OP *o) 5280 __attribute__warn_unused_result__; 5281 #define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE 5282 5283 STATIC void S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t); 5284 #define PERL_ARGS_ASSERT_BAD_TYPE_GV \ 5285 assert(gv); assert(kid); assert(t) 5286 STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid); 5287 #define PERL_ARGS_ASSERT_BAD_TYPE_PV \ 5288 assert(t); assert(o); assert(kid) 5289 STATIC void S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv); 5290 #define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \ 5291 assert(fullname); assert(gv); assert(cv) 5292 STATIC void S_cop_free(pTHX_ COP *cop); 5293 #define PERL_ARGS_ASSERT_COP_FREE \ 5294 assert(cop) 5295 STATIC OP * S_dup_attrlist(pTHX_ OP *o); 5296 #define PERL_ARGS_ASSERT_DUP_ATTRLIST \ 5297 assert(o) 5298 STATIC void S_finalize_op(pTHX_ OP* o); 5299 #define PERL_ARGS_ASSERT_FINALIZE_OP \ 5300 assert(o) 5301 STATIC void S_find_and_forget_pmops(pTHX_ OP *o); 5302 #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ 5303 assert(o) 5304 STATIC OP* S_fold_constants(pTHX_ OP * const o); 5305 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ 5306 assert(o) 5307 STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit); 5308 #define PERL_ARGS_ASSERT_FORCE_LIST 5309 STATIC void S_forget_pmop(pTHX_ PMOP *const o); 5310 #define PERL_ARGS_ASSERT_FORGET_PMOP \ 5311 assert(o) 5312 STATIC void S_gen_constant_list(pTHX_ OP* o); 5313 #define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST 5314 STATIC void S_inplace_aassign(pTHX_ OP* o); 5315 #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ 5316 assert(o) 5317 STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) 5318 __attribute__warn_unused_result__; 5319 #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ 5320 assert(o) 5321 5322 STATIC OP* S_listkids(pTHX_ OP* o); 5323 #define PERL_ARGS_ASSERT_LISTKIDS 5324 STATIC bool S_looks_like_bool(pTHX_ const OP* o); 5325 #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ 5326 assert(o) 5327 STATIC OP* S_modkids(pTHX_ OP *o, I32 type); 5328 #define PERL_ARGS_ASSERT_MODKIDS 5329 STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash); 5330 #define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ 5331 assert(proto); assert(attrs); assert(name) 5332 STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp); 5333 #define PERL_ARGS_ASSERT_MY_KID \ 5334 assert(imopsp) 5335 STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg); 5336 #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ 5337 assert(block) 5338 #ifndef PERL_NO_INLINE_FUNCTIONS 5339 PERL_STATIC_INLINE OP* S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP* dynamic_meth, SV* const_meth); 5340 #define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL 5341 #endif 5342 STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) 5343 __attribute__warn_unused_result__; 5344 #define PERL_ARGS_ASSERT_NEW_LOGOP \ 5345 assert(firstp); assert(otherp) 5346 5347 STATIC void S_no_bareword_allowed(pTHX_ OP *o); 5348 #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ 5349 assert(o) 5350 STATIC OP* S_no_fh_allowed(pTHX_ OP *o) 5351 __attribute__warn_unused_result__; 5352 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ 5353 assert(o) 5354 5355 #ifndef PERL_NO_INLINE_FUNCTIONS 5356 PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o); 5357 #define PERL_ARGS_ASSERT_OP_INTEGERIZE \ 5358 assert(o) 5359 #endif 5360 #ifndef PERL_NO_INLINE_FUNCTIONS 5361 PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o); 5362 #define PERL_ARGS_ASSERT_OP_STD_INIT \ 5363 assert(o) 5364 #endif 5365 STATIC void S_optimize_op(pTHX_ OP* o); 5366 #define PERL_ARGS_ASSERT_OPTIMIZE_OP \ 5367 assert(o) 5368 STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl); 5369 #define PERL_ARGS_ASSERT_PMTRANS \ 5370 assert(o); assert(expr); assert(repl) 5371 STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv); 5372 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ 5373 assert(fullname); assert(gv); assert(cv) 5374 STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); 5375 #define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH 5376 STATIC OP* S_refkids(pTHX_ OP* o, I32 type); 5377 #define PERL_ARGS_ASSERT_REFKIDS 5378 STATIC bool S_scalar_mod_type(const OP *o, I32 type) 5379 __attribute__warn_unused_result__; 5380 #define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE 5381 5382 STATIC OP* S_scalarboolean(pTHX_ OP *o); 5383 #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ 5384 assert(o) 5385 STATIC OP* S_scalarkids(pTHX_ OP* o); 5386 #define PERL_ARGS_ASSERT_SCALARKIDS 5387 STATIC OP* S_search_const(pTHX_ OP *o) 5388 __attribute__warn_unused_result__; 5389 #define PERL_ARGS_ASSERT_SEARCH_CONST \ 5390 assert(o) 5391 5392 STATIC void S_simplify_sort(pTHX_ OP *o); 5393 #define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ 5394 assert(o) 5395 STATIC OP* S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 5396 __attribute__warn_unused_result__; 5397 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ 5398 assert(o); assert(name) 5399 5400 STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags); 5401 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ 5402 assert(o); assert(name) 5403 STATIC OP* S_traverse_op_tree(pTHX_ OP* top, OP* o); 5404 #define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ 5405 assert(top); assert(o) 5406 STATIC OP* S_voidnonfinal(pTHX_ OP* o); 5407 #define PERL_ARGS_ASSERT_VOIDNONFINAL 5408 # if defined(USE_ITHREADS) 5409 #ifndef PERL_NO_INLINE_FUNCTIONS 5410 PERL_STATIC_INLINE void S_op_relocate_sv(pTHX_ SV** svp, PADOFFSET* targp); 5411 #define PERL_ARGS_ASSERT_OP_RELOCATE_SV \ 5412 assert(svp); assert(targp) 5413 #endif 5414 # endif 5415 #endif 5416 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) 5417 PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp); 5418 #define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ 5419 assert(name); assert(old_cv) 5420 #endif 5421 #if defined(PERL_IN_PAD_C) 5422 STATIC PADOFFSET S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash); 5423 #define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ 5424 assert(name) 5425 STATIC void S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash); 5426 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ 5427 assert(name) 5428 STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, PADNAME** out_name, int *out_flags); 5429 #define PERL_ARGS_ASSERT_PAD_FINDLEX \ 5430 assert(namepv); assert(cv); assert(out_name); assert(out_flags) 5431 STATIC void S_pad_reset(pTHX); 5432 #define PERL_ARGS_ASSERT_PAD_RESET 5433 #endif 5434 #if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) 5435 #ifndef PERL_NO_INLINE_FUNCTIONS 5436 PERL_STATIC_INLINE bool S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); 5437 #define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE \ 5438 assert(pn) 5439 #endif 5440 #endif 5441 #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) 5442 #ifndef NO_MATHOMS 5443 PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); 5444 #define PERL_ARGS_ASSERT_REF 5445 #endif 5446 #endif 5447 #if defined(PERL_IN_PERL_C) 5448 STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp); 5449 #define PERL_ARGS_ASSERT_FIND_BEGINNING \ 5450 assert(linestr_sv); assert(rsfp) 5451 STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); 5452 #define PERL_ARGS_ASSERT_FORBID_SETID 5453 STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags); 5454 #define PERL_ARGS_ASSERT_INCPUSH \ 5455 assert(dir) 5456 STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags); 5457 #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ 5458 assert(p) 5459 STATIC void S_init_ids(pTHX); 5460 #define PERL_ARGS_ASSERT_INIT_IDS 5461 STATIC void S_init_interp(pTHX); 5462 #define PERL_ARGS_ASSERT_INIT_INTERP 5463 STATIC void S_init_main_stash(pTHX); 5464 #define PERL_ARGS_ASSERT_INIT_MAIN_STASH 5465 STATIC void S_init_perllib(pTHX); 5466 #define PERL_ARGS_ASSERT_INIT_PERLLIB 5467 STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env); 5468 #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ 5469 assert(argv) 5470 STATIC void S_init_predump_symbols(pTHX); 5471 #define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS 5472 STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags); 5473 #define PERL_ARGS_ASSERT_MAYBERELOCATE \ 5474 assert(dir) 5475 PERL_STATIC_NO_RET void S_minus_v(pTHX) 5476 __attribute__noreturn__; 5477 #define PERL_ARGS_ASSERT_MINUS_V 5478 5479 PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) 5480 __attribute__noreturn__; 5481 #define PERL_ARGS_ASSERT_MY_EXIT_JUMP 5482 5483 STATIC void S_nuke_stacks(pTHX); 5484 #define PERL_ARGS_ASSERT_NUKE_STACKS 5485 STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript); 5486 #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ 5487 assert(scriptname); assert(suidscript) 5488 STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); 5489 #define PERL_ARGS_ASSERT_PARSE_BODY 5490 PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) 5491 __attribute__noreturn__; 5492 #define PERL_ARGS_ASSERT_RUN_BODY 5493 5494 PERL_STATIC_NO_RET void S_usage(pTHX) 5495 __attribute__noreturn__; 5496 #define PERL_ARGS_ASSERT_USAGE 5497 5498 #endif 5499 #if defined(PERL_IN_PP_C) 5500 STATIC size_t S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping); 5501 #define PERL_ARGS_ASSERT_DO_CHOMP \ 5502 assert(retval); assert(sv) 5503 STATIC OP* S_do_delete_local(pTHX); 5504 #define PERL_ARGS_ASSERT_DO_DELETE_LOCAL 5505 STATIC SV* S_refto(pTHX_ SV* sv) 5506 __attribute__warn_unused_result__; 5507 #define PERL_ARGS_ASSERT_REFTO \ 5508 assert(sv) 5509 5510 #endif 5511 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) 5512 #ifndef PERL_NO_INLINE_FUNCTIONS 5513 PERL_STATIC_INLINE bool S_lossless_NV_to_IV(const NV nv, IV * ivp) 5514 __attribute__warn_unused_result__; 5515 #define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV \ 5516 assert(ivp) 5517 #endif 5518 5519 PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) 5520 __attribute__warn_unused_result__; 5521 #define PERL_ARGS_ASSERT_SOFTREF2XV \ 5522 assert(sv); assert(what); assert(spp) 5523 5524 #endif 5525 #if defined(PERL_IN_PP_CTL_C) 5526 STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) 5527 __attribute__warn_unused_result__; 5528 #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ 5529 assert(name) 5530 5531 STATIC void S_destroy_matcher(pTHX_ PMOP* matcher); 5532 #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ 5533 assert(matcher) 5534 STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); 5535 #define PERL_ARGS_ASSERT_DO_SMARTMATCH 5536 STATIC OP* S_docatch(pTHX_ Perl_ppaddr_t firstpp) 5537 __attribute__warn_unused_result__; 5538 #define PERL_ARGS_ASSERT_DOCATCH 5539 5540 STATIC bool S_doeval_compile(pTHX_ U8 gimme, CV* outside, U32 seq, HV* hh); 5541 #define PERL_ARGS_ASSERT_DOEVAL_COMPILE 5542 STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) 5543 __attribute__warn_unused_result__; 5544 #define PERL_ARGS_ASSERT_DOFINDLABEL \ 5545 assert(o); assert(label); assert(opstack); assert(oplimit) 5546 5547 STATIC MAGIC * S_doparseform(pTHX_ SV *sv); 5548 #define PERL_ARGS_ASSERT_DOPARSEFORM \ 5549 assert(sv) 5550 STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) 5551 __attribute__warn_unused_result__; 5552 #define PERL_ARGS_ASSERT_DOPOPTOEVAL 5553 5554 STATIC I32 S_dopoptogivenfor(pTHX_ I32 startingblock) 5555 __attribute__warn_unused_result__; 5556 #define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR 5557 5558 STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) 5559 __attribute__warn_unused_result__; 5560 #define PERL_ARGS_ASSERT_DOPOPTOLABEL \ 5561 assert(label) 5562 5563 STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) 5564 __attribute__warn_unused_result__; 5565 #define PERL_ARGS_ASSERT_DOPOPTOLOOP 5566 5567 STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) 5568 __attribute__warn_unused_result__; 5569 #define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ 5570 assert(cxstk) 5571 5572 STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) 5573 __attribute__warn_unused_result__; 5574 #define PERL_ARGS_ASSERT_DOPOPTOWHEN 5575 5576 STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) 5577 __attribute__warn_unused_result__; 5578 #define PERL_ARGS_ASSERT_MAKE_MATCHER \ 5579 assert(re) 5580 5581 STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) 5582 __attribute__warn_unused_result__; 5583 #define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ 5584 assert(matcher); assert(sv) 5585 5586 STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) 5587 __attribute__warn_unused_result__; 5588 #define PERL_ARGS_ASSERT_NUM_OVERFLOW 5589 5590 #ifndef PERL_NO_INLINE_FUNCTIONS 5591 PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) 5592 __attribute__warn_unused_result__; 5593 #define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ 5594 assert(name) 5595 #endif 5596 5597 STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) 5598 __attribute__warn_unused_result__; 5599 #define PERL_ARGS_ASSERT_RUN_USER_FILTER \ 5600 assert(buf_sv) 5601 5602 STATIC void S_rxres_free(pTHX_ void** rsp); 5603 #define PERL_ARGS_ASSERT_RXRES_FREE \ 5604 assert(rsp) 5605 STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx); 5606 #define PERL_ARGS_ASSERT_RXRES_RESTORE \ 5607 assert(rsp); assert(rx) 5608 STATIC void S_save_lines(pTHX_ AV *array, SV *sv); 5609 #define PERL_ARGS_ASSERT_SAVE_LINES \ 5610 assert(sv) 5611 #endif 5612 #if defined(PERL_IN_PP_HOT_C) 5613 STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey); 5614 #define PERL_ARGS_ASSERT_DO_ODDBALL \ 5615 assert(oddkey); assert(firstkey) 5616 #ifndef PERL_NO_INLINE_FUNCTIONS 5617 PERL_STATIC_INLINE HV* S_opmethod_stash(pTHX_ SV* meth); 5618 #define PERL_ARGS_ASSERT_OPMETHOD_STASH \ 5619 assert(meth) 5620 #endif 5621 #ifndef PERL_NO_INLINE_FUNCTIONS 5622 PERL_STATIC_FORCE_INLINE bool S_should_we_output_Debug_r(pTHX_ regexp * prog) 5623 __attribute__warn_unused_result__ 5624 __attribute__always_inline__; 5625 #define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R \ 5626 assert(prog) 5627 #endif 5628 5629 #endif 5630 #if defined(PERL_IN_PP_PACK_C) 5631 STATIC int S_div128(pTHX_ SV *pnum, bool *done); 5632 #define PERL_ARGS_ASSERT_DIV128 \ 5633 assert(pnum); assert(done) 5634 STATIC char S_first_symbol(const char *pat, const char *patend); 5635 #define PERL_ARGS_ASSERT_FIRST_SYMBOL \ 5636 assert(pat); assert(patend) 5637 STATIC const char * S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) 5638 __attribute__warn_unused_result__; 5639 #define PERL_ARGS_ASSERT_GET_NUM \ 5640 assert(patptr); assert(lenptr) 5641 5642 STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender); 5643 #define PERL_ARGS_ASSERT_GROUP_END \ 5644 assert(patptr); assert(patend) 5645 STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l) 5646 __attribute__warn_unused_result__; 5647 #define PERL_ARGS_ASSERT_IS_AN_INT \ 5648 assert(s) 5649 5650 STATIC SSize_t S_measure_struct(pTHX_ struct tempsym* symptr); 5651 #define PERL_ARGS_ASSERT_MEASURE_STRUCT \ 5652 assert(symptr) 5653 STATIC SV* S_mul128(pTHX_ SV *sv, U8 m); 5654 #define PERL_ARGS_ASSERT_MUL128 \ 5655 assert(sv) 5656 STATIC char * S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap) 5657 __attribute__warn_unused_result__; 5658 #define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \ 5659 assert(start); assert(dest) 5660 5661 STATIC bool S_need_utf8(const char *pat, const char *patend); 5662 #define PERL_ARGS_ASSERT_NEED_UTF8 \ 5663 assert(pat); assert(patend) 5664 STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr); 5665 #define PERL_ARGS_ASSERT_NEXT_SYMBOL \ 5666 assert(symptr) 5667 STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym* symptr, SV **beglist, SV **endlist); 5668 #define PERL_ARGS_ASSERT_PACK_REC \ 5669 assert(cat); assert(symptr); assert(beglist); assert(endlist) 5670 STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) 5671 __attribute__warn_unused_result__; 5672 #define PERL_ARGS_ASSERT_SV_EXP_GROW \ 5673 assert(sv) 5674 5675 STATIC SSize_t S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const char *strbeg, const char *strend, const char **new_s); 5676 #define PERL_ARGS_ASSERT_UNPACK_REC \ 5677 assert(symptr); assert(s); assert(strbeg); assert(strend) 5678 #endif 5679 #if defined(PERL_IN_PP_SORT_C) 5680 #ifndef PERL_NO_INLINE_FUNCTIONS 5681 PERL_STATIC_FORCE_INLINE I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) 5682 __attribute__always_inline__; 5683 #define PERL_ARGS_ASSERT_AMAGIC_CMP \ 5684 assert(str1); assert(str2) 5685 #endif 5686 5687 #ifndef PERL_NO_INLINE_FUNCTIONS 5688 PERL_STATIC_FORCE_INLINE I32 S_amagic_cmp_desc(pTHX_ SV *const str1, SV *const str2) 5689 __attribute__always_inline__; 5690 #define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC \ 5691 assert(str1); assert(str2) 5692 #endif 5693 5694 #ifndef PERL_NO_INLINE_FUNCTIONS 5695 PERL_STATIC_FORCE_INLINE I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) 5696 __attribute__always_inline__; 5697 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ 5698 assert(a); assert(b) 5699 #endif 5700 5701 #ifndef PERL_NO_INLINE_FUNCTIONS 5702 PERL_STATIC_FORCE_INLINE I32 S_amagic_i_ncmp_desc(pTHX_ SV *const a, SV *const b) 5703 __attribute__always_inline__; 5704 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC \ 5705 assert(a); assert(b) 5706 #endif 5707 5708 #ifndef PERL_NO_INLINE_FUNCTIONS 5709 PERL_STATIC_FORCE_INLINE I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b) 5710 __attribute__always_inline__; 5711 #define PERL_ARGS_ASSERT_AMAGIC_NCMP \ 5712 assert(a); assert(b) 5713 #endif 5714 5715 #ifndef PERL_NO_INLINE_FUNCTIONS 5716 PERL_STATIC_FORCE_INLINE I32 S_amagic_ncmp_desc(pTHX_ SV *const a, SV *const b) 5717 __attribute__always_inline__; 5718 #define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC \ 5719 assert(a); assert(b) 5720 #endif 5721 5722 #ifndef PERL_NO_INLINE_FUNCTIONS 5723 PERL_STATIC_FORCE_INLINE I32 S_cmp_desc(pTHX_ SV *const str1, SV *const str2) 5724 __attribute__always_inline__; 5725 #define PERL_ARGS_ASSERT_CMP_DESC \ 5726 assert(str1); assert(str2) 5727 #endif 5728 5729 STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b); 5730 #define PERL_ARGS_ASSERT_SORTCV \ 5731 assert(a); assert(b) 5732 STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b); 5733 #define PERL_ARGS_ASSERT_SORTCV_STACKED \ 5734 assert(a); assert(b) 5735 STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b); 5736 #define PERL_ARGS_ASSERT_SORTCV_XSUB \ 5737 assert(a); assert(b) 5738 #ifndef PERL_NO_INLINE_FUNCTIONS 5739 PERL_STATIC_FORCE_INLINE void S_sortsv_flags_impl(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) 5740 __attribute__always_inline__; 5741 #define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL \ 5742 assert(cmp) 5743 #endif 5744 5745 #ifndef PERL_NO_INLINE_FUNCTIONS 5746 PERL_STATIC_FORCE_INLINE I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b) 5747 __attribute__always_inline__; 5748 #define PERL_ARGS_ASSERT_SV_I_NCMP \ 5749 assert(a); assert(b) 5750 #endif 5751 5752 #ifndef PERL_NO_INLINE_FUNCTIONS 5753 PERL_STATIC_FORCE_INLINE I32 S_sv_i_ncmp_desc(pTHX_ SV *const a, SV *const b) 5754 __attribute__always_inline__; 5755 #define PERL_ARGS_ASSERT_SV_I_NCMP_DESC \ 5756 assert(a); assert(b) 5757 #endif 5758 5759 #ifndef PERL_NO_INLINE_FUNCTIONS 5760 PERL_STATIC_FORCE_INLINE I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) 5761 __attribute__always_inline__; 5762 #define PERL_ARGS_ASSERT_SV_NCMP \ 5763 assert(a); assert(b) 5764 #endif 5765 5766 #ifndef PERL_NO_INLINE_FUNCTIONS 5767 PERL_STATIC_FORCE_INLINE I32 S_sv_ncmp_desc(pTHX_ SV *const a, SV *const b) 5768 __attribute__always_inline__; 5769 #define PERL_ARGS_ASSERT_SV_NCMP_DESC \ 5770 assert(a); assert(b) 5771 #endif 5772 5773 # if defined(USE_LOCALE_COLLATE) 5774 #ifndef PERL_NO_INLINE_FUNCTIONS 5775 PERL_STATIC_FORCE_INLINE I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) 5776 __attribute__always_inline__; 5777 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ 5778 assert(str1); assert(str2) 5779 #endif 5780 5781 #ifndef PERL_NO_INLINE_FUNCTIONS 5782 PERL_STATIC_FORCE_INLINE I32 S_amagic_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2) 5783 __attribute__always_inline__; 5784 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \ 5785 assert(str1); assert(str2) 5786 #endif 5787 5788 #ifndef PERL_NO_INLINE_FUNCTIONS 5789 PERL_STATIC_FORCE_INLINE I32 S_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2) 5790 __attribute__always_inline__; 5791 #define PERL_ARGS_ASSERT_CMP_LOCALE_DESC \ 5792 assert(str1); assert(str2) 5793 #endif 5794 5795 # endif 5796 #endif 5797 #if defined(PERL_IN_PP_SYS_C) 5798 STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop); 5799 #define PERL_ARGS_ASSERT_DOFORM \ 5800 assert(cv); assert(gv) 5801 STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array); 5802 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL 5803 #endif 5804 #if defined(PERL_IN_REGCOMP_C) 5805 STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist); 5806 #define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ 5807 assert(pRExC_state); assert(invlist) 5808 STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n) 5809 __attribute__warn_unused_result__; 5810 #define PERL_ARGS_ASSERT_ADD_DATA \ 5811 assert(pRExC_state); assert(s) 5812 5813 STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count); 5814 #define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ 5815 assert(multi_string) 5816 STATIC void S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size); 5817 #define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE \ 5818 assert(pRExC_state) 5819 STATIC REGEXP* S_compile_wildcard(pTHX_ const char * subpattern, const STRLEN len, const bool ignore_case) 5820 __attribute__warn_unused_result__; 5821 #define PERL_ARGS_ASSERT_COMPILE_WILDCARD \ 5822 assert(subpattern) 5823 5824 STATIC U8 S_compute_EXACTish(RExC_state_t *pRExC_state); 5825 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ 5826 assert(pRExC_state) 5827 STATIC regnode * S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth); 5828 #define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \ 5829 assert(pRExC_state); assert(source) 5830 STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance) 5831 __attribute__warn_unused_result__; 5832 #define PERL_ARGS_ASSERT_EDIT_DISTANCE \ 5833 assert(src); assert(tgt) 5834 5835 STATIC I32 S_execute_wildcard(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave); 5836 #define PERL_ARGS_ASSERT_EXECUTE_WILDCARD \ 5837 assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) 5838 #ifndef PERL_NO_INLINE_FUNCTIONS 5839 PERL_STATIC_INLINE Size_t S_find_first_differing_byte_pos(const U8 * s1, const U8 * s2, const Size_t max); 5840 #define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \ 5841 assert(s1); assert(s2) 5842 #endif 5843 STATIC SV * S_get_ANYOFM_contents(pTHX_ const regnode * n) 5844 __attribute__warn_unused_result__; 5845 #define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS \ 5846 assert(n) 5847 5848 STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node); 5849 #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ 5850 assert(pRExC_state); assert(node) 5851 STATIC U32 S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char * start, const char * end); 5852 #define PERL_ARGS_ASSERT_GET_QUANTIFIER_VALUE \ 5853 assert(pRExC_state); assert(start); assert(end) 5854 STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset* nodep, UV *code_point_p, int* cp_count, I32 *flagp, const bool strict, const U32 depth); 5855 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \ 5856 assert(pRExC_state); assert(flagp) 5857 STATIC regnode_offset S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch); 5858 #define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF \ 5859 assert(pRExC_state); assert(flagp); assert(parse_start) 5860 STATIC bool S_handle_names_wildcard(pTHX_ const char * wname, const STRLEN wname_len, SV ** prop_definition, AV ** strings); 5861 #define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \ 5862 assert(wname); assert(prop_definition); assert(strings) 5863 STATIC int S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char* const s, char ** updated_parse_ptr, AV** posix_warnings, const bool check_only); 5864 #define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \ 5865 assert(pRExC_state); assert(s) 5866 STATIC regnode_offset S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse); 5867 #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ 5868 assert(pRExC_state); assert(flagp); assert(oregcomp_parse) 5869 STATIC SV * S_handle_user_defined_property(pTHX_ const char * name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV* contents, bool *user_defined_ptr, SV * msg, const STRLEN level); 5870 #define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \ 5871 assert(name); assert(contents); assert(user_defined_ptr); assert(msg) 5872 #ifndef PERL_NO_INLINE_FUNCTIONS 5873 PERL_STATIC_INLINE SV* S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style) 5874 __attribute__warn_unused_result__; 5875 #define PERL_ARGS_ASSERT_INVLIST_CONTENTS \ 5876 assert(invlist) 5877 #endif 5878 5879 #ifndef PERL_NO_INLINE_FUNCTIONS 5880 PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist) 5881 __attribute__warn_unused_result__; 5882 #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ 5883 assert(invlist) 5884 #endif 5885 5886 #ifndef PERL_NO_INLINE_FUNCTIONS 5887 PERL_STATIC_INLINE UV S_invlist_lowest(SV* const invlist) 5888 __attribute__warn_unused_result__; 5889 #define PERL_ARGS_ASSERT_INVLIST_LOWEST \ 5890 assert(invlist) 5891 #endif 5892 5893 STATIC bool S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc); 5894 #define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT \ 5895 assert(pRExC_state); assert(ssc) 5896 STATIC U32 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth); 5897 #define PERL_ARGS_ASSERT_JOIN_EXACT \ 5898 assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char) 5899 STATIC SV* S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) 5900 __attribute__warn_unused_result__; 5901 #define PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST \ 5902 assert(pRExC_state); assert(node) 5903 5904 STATIC I32 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth); 5905 #define PERL_ARGS_ASSERT_MAKE_TRIE \ 5906 assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) 5907 STATIC void S_nextchar(pTHX_ RExC_state_t *pRExC_state); 5908 #define PERL_ARGS_ASSERT_NEXTCHAR \ 5909 assert(pRExC_state) 5910 STATIC U8 S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV* cp_list, SV* only_utf8_locale_list, SV* upper_latin1_only_utf8_matches, const U32 has_runtime_dependency, const U32 posixl, U8 * anyof_flags, bool * invert, regnode_offset * ret, I32 *flagp); 5911 #define PERL_ARGS_ASSERT_OPTIMIZE_REGCLASS \ 5912 assert(pRExC_state); assert(anyof_flags); assert(invert); assert(ret); assert(flagp) 5913 STATIC void S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings); 5914 #define PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS \ 5915 assert(pRExC_state); assert(posix_warnings) 5916 STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state); 5917 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ 5918 assert(pRExC_state) 5919 STATIC SV * S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV ** strings, bool * user_defined_ptr, SV * msg, const STRLEN level); 5920 #define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING \ 5921 assert(name); assert(user_defined_ptr); assert(msg) 5922 STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr); 5923 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \ 5924 assert(node); assert(invlist_ptr) 5925 STATIC void S_rck_elide_nothing(pTHX_ regnode *node); 5926 #define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING \ 5927 assert(node) 5928 PERL_STATIC_NO_RET void S_re_croak(pTHX_ bool utf8, const char* pat, ...) 5929 __attribute__noreturn__ 5930 __attribute__format__(__printf__,pTHX_2,pTHX_3); 5931 #define PERL_ARGS_ASSERT_RE_CROAK \ 5932 assert(pat) 5933 5934 STATIC regnode_offset S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); 5935 #define PERL_ARGS_ASSERT_REG \ 5936 assert(pRExC_state); assert(flagp) 5937 STATIC regnode_offset S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2); 5938 #define PERL_ARGS_ASSERT_REG2LANODE \ 5939 assert(pRExC_state) 5940 STATIC regnode_offset S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); 5941 #define PERL_ARGS_ASSERT_REG_NODE \ 5942 assert(pRExC_state) 5943 STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags); 5944 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ 5945 assert(pRExC_state) 5946 #ifndef PERL_NO_INLINE_FUNCTIONS 5947 PERL_STATIC_INLINE char * S_reg_skipcomment(RExC_state_t *pRExC_state, char * p); 5948 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ 5949 assert(pRExC_state); assert(p) 5950 #endif 5951 STATIC regnode_offset S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg); 5952 #define PERL_ARGS_ASSERT_REGANODE \ 5953 assert(pRExC_state) 5954 STATIC regnode_offset S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); 5955 #define PERL_ARGS_ASSERT_REGATOM \ 5956 assert(pRExC_state); assert(flagp) 5957 STATIC regnode_offset S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth); 5958 #define PERL_ARGS_ASSERT_REGBRANCH \ 5959 assert(pRExC_state); assert(flagp) 5960 STATIC regnode_offset S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV** ret_invlist); 5961 #define PERL_ARGS_ASSERT_REGCLASS \ 5962 assert(pRExC_state); assert(flagp) 5963 STATIC unsigned int S_regex_set_precedence(const U8 my_operator) 5964 __attribute__warn_unused_result__; 5965 #define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE 5966 5967 STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth); 5968 #define PERL_ARGS_ASSERT_REGINSERT \ 5969 assert(pRExC_state) 5970 STATIC regnode_offset S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len, const char* const name); 5971 #define PERL_ARGS_ASSERT_REGNODE_GUTS \ 5972 assert(pRExC_state); assert(name) 5973 STATIC regnode_offset S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); 5974 #define PERL_ARGS_ASSERT_REGPIECE \ 5975 assert(pRExC_state); assert(flagp) 5976 STATIC regnode_offset S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV * arg); 5977 #define PERL_ARGS_ASSERT_REGPNODE \ 5978 assert(pRExC_state); assert(arg) 5979 STATIC bool S_regtail(pTHX_ RExC_state_t * pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth) 5980 __attribute__warn_unused_result__; 5981 #define PERL_ARGS_ASSERT_REGTAIL \ 5982 assert(pRExC_state); assert(p); assert(val) 5983 5984 STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf); 5985 #define PERL_ARGS_ASSERT_SCAN_COMMIT \ 5986 assert(pRExC_state); assert(data); assert(minlenp) 5987 STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const only_utf8_locale_list); 5988 #define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ 5989 assert(pRExC_state); assert(node) 5990 STATIC void S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx); 5991 #define PERL_ARGS_ASSERT_SET_REGEX_PV \ 5992 assert(pRExC_state); assert(Rx) 5993 STATIC void S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char ** p, const bool force_to_xmod); 5994 #define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT \ 5995 assert(pRExC_state); assert(p) 5996 STATIC void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end); 5997 #define PERL_ARGS_ASSERT_SSC_ADD_RANGE \ 5998 assert(ssc) 5999 STATIC void S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with); 6000 #define PERL_ARGS_ASSERT_SSC_AND \ 6001 assert(pRExC_state); assert(ssc); assert(and_with) 6002 STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc); 6003 #define PERL_ARGS_ASSERT_SSC_ANYTHING \ 6004 assert(ssc) 6005 STATIC void S_ssc_clear_locale(regnode_ssc *ssc); 6006 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ 6007 assert(ssc) 6008 STATIC void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp); 6009 #define PERL_ARGS_ASSERT_SSC_CP_AND \ 6010 assert(ssc) 6011 STATIC void S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc); 6012 #define PERL_ARGS_ASSERT_SSC_FINALIZE \ 6013 assert(pRExC_state); assert(ssc) 6014 STATIC void S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc); 6015 #define PERL_ARGS_ASSERT_SSC_INIT \ 6016 assert(pRExC_state); assert(ssc) 6017 STATIC void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd); 6018 #define PERL_ARGS_ASSERT_SSC_INTERSECTION \ 6019 assert(ssc); assert(invlist) 6020 STATIC int S_ssc_is_anything(const regnode_ssc *ssc) 6021 __attribute__warn_unused_result__; 6022 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ 6023 assert(ssc) 6024 6025 STATIC int S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) 6026 __attribute__warn_unused_result__; 6027 #define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ 6028 assert(pRExC_state); assert(ssc) 6029 6030 STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with); 6031 #define PERL_ARGS_ASSERT_SSC_OR \ 6032 assert(pRExC_state); assert(ssc); assert(or_with) 6033 STATIC void S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd); 6034 #define PERL_ARGS_ASSERT_SSC_UNION \ 6035 assert(ssc); assert(invlist) 6036 STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok); 6037 #define PERL_ARGS_ASSERT_STUDY_CHUNK \ 6038 assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) 6039 #endif 6040 #if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) 6041 PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist); 6042 #define PERL_ARGS_ASSERT__INVLIST_DUMP \ 6043 assert(file); assert(indent); assert(invlist) 6044 #endif 6045 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) 6046 #ifndef PERL_NO_INLINE_FUNCTIONS 6047 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) 6048 __attribute__warn_unused_result__; 6049 #define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST 6050 #endif 6051 6052 #ifndef PERL_NO_INLINE_FUNCTIONS 6053 PERL_STATIC_INLINE void S_invlist_extend(pTHX_ SV* const invlist, const UV len); 6054 #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ 6055 assert(invlist) 6056 #endif 6057 #ifndef PERL_NO_INLINE_FUNCTIONS 6058 PERL_STATIC_INLINE UV S_invlist_highest(SV* const invlist) 6059 __attribute__warn_unused_result__; 6060 #define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ 6061 assert(invlist) 6062 #endif 6063 6064 #ifndef PERL_NO_INLINE_FUNCTIONS 6065 PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset); 6066 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ 6067 assert(invlist) 6068 #endif 6069 #endif 6070 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_UTF8_C) 6071 PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end) 6072 __attribute__warn_unused_result__; 6073 #define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST 6074 6075 /* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */ 6076 #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION 6077 PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i); 6078 #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ 6079 assert(b); assert(i) 6080 PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist); 6081 #define PERL_ARGS_ASSERT__INVLIST_INVERT \ 6082 assert(invlist) 6083 /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */ 6084 #define PERL_ARGS_ASSERT__INVLIST_SUBTRACT 6085 /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */ 6086 #define PERL_ARGS_ASSERT__INVLIST_UNION 6087 PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output); 6088 #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ 6089 assert(b); assert(output) 6090 PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) 6091 __attribute__warn_unused_result__; 6092 #define PERL_ARGS_ASSERT__NEW_INVLIST 6093 6094 PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) 6095 __attribute__warn_unused_result__; 6096 #define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ 6097 assert(other_elements_ptr) 6098 6099 #endif 6100 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C) 6101 PERL_CALLCONV const char * Perl_form_alien_digit_msg(pTHX_ const U8 which, const STRLEN valids_len, const char * const first_bad, const char * const send, const bool UTF, const bool braced) 6102 __attribute__warn_unused_result__; 6103 #define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG \ 6104 assert(first_bad); assert(send) 6105 6106 PERL_CALLCONV bool Perl_grok_bslash_c(pTHX_ const char source, U8 * result, const char** message, U32 * packed_warn) 6107 __attribute__warn_unused_result__; 6108 #define PERL_ARGS_ASSERT_GROK_BSLASH_C \ 6109 assert(result); assert(message) 6110 6111 PERL_CALLCONV bool Perl_grok_bslash_o(pTHX_ char** s, const char* const send, UV* uv, const char** message, U32 * packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) 6112 __attribute__warn_unused_result__; 6113 #define PERL_ARGS_ASSERT_GROK_BSLASH_O \ 6114 assert(s); assert(send); assert(uv); assert(message) 6115 6116 PERL_CALLCONV bool Perl_grok_bslash_x(pTHX_ char** s, const char* const send, UV* uv, const char** message, U32 * packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) 6117 __attribute__warn_unused_result__; 6118 #define PERL_ARGS_ASSERT_GROK_BSLASH_X \ 6119 assert(s); assert(send); assert(uv); assert(message) 6120 6121 #endif 6122 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) 6123 PERL_CALLCONV const char * Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char * string, const Size_t len, const UV cp) 6124 __attribute__warn_unused_result__; 6125 #define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG 6126 6127 #endif 6128 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C) 6129 #ifndef PERL_NO_INLINE_FUNCTIONS 6130 PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) 6131 __attribute__warn_unused_result__; 6132 #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ 6133 assert(invlist) 6134 #endif 6135 6136 #ifndef PERL_NO_INLINE_FUNCTIONS 6137 PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist); 6138 #define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ 6139 assert(invlist) 6140 #endif 6141 #ifndef PERL_NO_INLINE_FUNCTIONS 6142 PERL_STATIC_INLINE void S_invlist_iterinit(SV* invlist); 6143 #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ 6144 assert(invlist) 6145 #endif 6146 #ifndef PERL_NO_INLINE_FUNCTIONS 6147 PERL_STATIC_INLINE bool S_invlist_iternext(SV* invlist, UV* start, UV* end) 6148 __attribute__warn_unused_result__; 6149 #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ 6150 assert(invlist); assert(start); assert(end) 6151 #endif 6152 6153 #endif 6154 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C) 6155 PERL_CALLCONV bool Perl__invlistEQ(pTHX_ SV* const a, SV* const b, const bool complement_b); 6156 #define PERL_ARGS_ASSERT__INVLISTEQ \ 6157 assert(a); assert(b) 6158 PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list) 6159 __attribute__warn_unused_result__; 6160 #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ 6161 assert(list) 6162 6163 #endif 6164 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) 6165 #ifndef PERL_NO_INLINE_FUNCTIONS 6166 PERL_STATIC_INLINE const char * S_get_regex_charset_name(const U32 flags, STRLEN* const lenp); 6167 #define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ 6168 assert(lenp) 6169 #endif 6170 #endif 6171 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 6172 PERL_CALLCONV int Perl_re_printf(pTHX_ const char *fmt, ...) 6173 __attribute__format__(__printf__,pTHX_1,pTHX_2); 6174 #define PERL_ARGS_ASSERT_RE_PRINTF \ 6175 assert(fmt) 6176 6177 PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state); 6178 #define PERL_ARGS_ASSERT_REGPROP \ 6179 assert(sv); assert(o) 6180 #endif 6181 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_DOOP_C) 6182 #ifndef PERL_NO_INLINE_FUNCTIONS 6183 PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp) 6184 __attribute__warn_unused_result__; 6185 #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ 6186 assert(invlist) 6187 #endif 6188 6189 #ifndef PERL_NO_INLINE_FUNCTIONS 6190 PERL_STATIC_INLINE UV S__invlist_len(SV* const invlist) 6191 __attribute__warn_unused_result__; 6192 #define PERL_ARGS_ASSERT__INVLIST_LEN \ 6193 assert(invlist) 6194 #endif 6195 6196 PERL_CALLCONV SSize_t Perl__invlist_search(SV* const invlist, const UV cp) 6197 __attribute__warn_unused_result__; 6198 #define PERL_ARGS_ASSERT__INVLIST_SEARCH \ 6199 assert(invlist) 6200 6201 #ifndef PERL_NO_INLINE_FUNCTIONS 6202 PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(SV* invlist) 6203 __attribute__warn_unused_result__; 6204 #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ 6205 assert(invlist) 6206 #endif 6207 6208 #ifndef PERL_NO_INLINE_FUNCTIONS 6209 PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist) 6210 __attribute__warn_unused_result__; 6211 #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ 6212 assert(invlist) 6213 #endif 6214 6215 #ifndef PERL_NO_INLINE_FUNCTIONS 6216 PERL_STATIC_INLINE bool S_is_invlist(SV* const invlist) 6217 __attribute__warn_unused_result__; 6218 #define PERL_ARGS_ASSERT_IS_INVLIST 6219 #endif 6220 6221 #endif 6222 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) 6223 PERL_CALLCONV bool Perl_is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, const U8 *strend, const UV cp) 6224 __attribute__warn_unused_result__; 6225 #define PERL_ARGS_ASSERT_IS_GRAPHEME \ 6226 assert(strbeg); assert(s); assert(strend) 6227 6228 #endif 6229 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) 6230 PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); 6231 #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ 6232 assert(p); assert(lenp) 6233 #endif 6234 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_SV_C) 6235 PERL_CALLCONV SV* Perl_invlist_clone(pTHX_ SV* const invlist, SV* newlist); 6236 #define PERL_ARGS_ASSERT_INVLIST_CLONE \ 6237 assert(invlist) 6238 #endif 6239 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) 6240 PERL_CALLCONV bool Perl_regcurly(const char *s, const char *e, const char * result[5]) 6241 __attribute__warn_unused_result__; 6242 #define PERL_ARGS_ASSERT_REGCURLY \ 6243 assert(s); assert(e) 6244 6245 #endif 6246 #if defined(PERL_IN_REGEXEC_C) 6247 STATIC LB_enum S_advance_one_LB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target) 6248 __attribute__warn_unused_result__; 6249 #define PERL_ARGS_ASSERT_ADVANCE_ONE_LB \ 6250 assert(curpos); assert(strend) 6251 6252 STATIC SB_enum S_advance_one_SB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target) 6253 __attribute__warn_unused_result__; 6254 #define PERL_ARGS_ASSERT_ADVANCE_ONE_SB \ 6255 assert(curpos); assert(strend) 6256 6257 STATIC WB_enum S_advance_one_WB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target, const bool skip_Extend_Format) 6258 __attribute__warn_unused_result__; 6259 #define PERL_ARGS_ASSERT_ADVANCE_ONE_WB \ 6260 assert(curpos); assert(strend) 6261 6262 STATIC GCB_enum S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target) 6263 __attribute__warn_unused_result__; 6264 #define PERL_ARGS_ASSERT_BACKUP_ONE_GCB \ 6265 assert(strbeg); assert(curpos) 6266 6267 STATIC LB_enum S_backup_one_LB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target) 6268 __attribute__warn_unused_result__; 6269 #define PERL_ARGS_ASSERT_BACKUP_ONE_LB \ 6270 assert(strbeg); assert(curpos) 6271 6272 STATIC SB_enum S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 ** curpos, const bool utf8_target) 6273 __attribute__warn_unused_result__; 6274 #define PERL_ARGS_ASSERT_BACKUP_ONE_SB \ 6275 assert(strbeg); assert(curpos) 6276 6277 STATIC WB_enum S_backup_one_WB(pTHX_ WB_enum * previous, const U8 * const strbeg, U8 ** curpos, const bool utf8_target) 6278 __attribute__warn_unused_result__; 6279 #define PERL_ARGS_ASSERT_BACKUP_ONE_WB \ 6280 assert(previous); assert(strbeg); assert(curpos) 6281 6282 STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) 6283 __attribute__warn_unused_result__; 6284 #define PERL_ARGS_ASSERT_FIND_BYCLASS \ 6285 assert(prog); assert(c); assert(s); assert(strend) 6286 6287 STATIC U8 * S_find_next_masked(U8 * s, const U8 * send, const U8 byte, const U8 mask) 6288 __attribute__warn_unused_result__; 6289 #define PERL_ARGS_ASSERT_FIND_NEXT_MASKED \ 6290 assert(s); assert(send) 6291 6292 STATIC U8 * S_find_span_end(U8* s, const U8 * send, const U8 span_byte) 6293 __attribute__warn_unused_result__; 6294 #define PERL_ARGS_ASSERT_FIND_SPAN_END \ 6295 assert(s); assert(send) 6296 6297 STATIC U8 * S_find_span_end_mask(U8 * s, const U8 * send, const U8 span_byte, const U8 mask) 6298 __attribute__warn_unused_result__; 6299 #define PERL_ARGS_ASSERT_FIND_SPAN_END_MASK \ 6300 assert(s); assert(send) 6301 6302 #ifndef PERL_NO_INLINE_FUNCTIONS 6303 PERL_STATIC_INLINE I32 S_foldEQ_latin1_s2_folded(const char* a, const char* b, I32 len); 6304 #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1_S2_FOLDED \ 6305 assert(a); assert(b) 6306 #endif 6307 STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) 6308 __attribute__warn_unused_result__; 6309 #define PERL_ARGS_ASSERT_ISFOO_LC 6310 6311 STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character, const U8* e) 6312 __attribute__warn_unused_result__; 6313 #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ 6314 assert(character); assert(e) 6315 6316 STATIC bool S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target) 6317 __attribute__warn_unused_result__; 6318 #define PERL_ARGS_ASSERT_ISGCB \ 6319 assert(strbeg); assert(curpos) 6320 6321 STATIC bool S_isLB(pTHX_ LB_enum before, LB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 6322 __attribute__warn_unused_result__; 6323 #define PERL_ARGS_ASSERT_ISLB \ 6324 assert(strbeg); assert(curpos); assert(strend) 6325 6326 STATIC bool S_isSB(pTHX_ SB_enum before, SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 6327 __attribute__warn_unused_result__; 6328 #define PERL_ARGS_ASSERT_ISSB \ 6329 assert(strbeg); assert(curpos); assert(strend) 6330 6331 STATIC bool S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 6332 __attribute__warn_unused_result__; 6333 #define PERL_ARGS_ASSERT_ISWB \ 6334 assert(strbeg); assert(curpos); assert(strend) 6335 6336 STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) 6337 __attribute__warn_unused_result__; 6338 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ 6339 assert(rex); assert(scan) 6340 6341 STATIC void S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p _pDEPTH); 6342 #define PERL_ARGS_ASSERT_REGCP_RESTORE \ 6343 assert(rex); assert(maxopenparen_p) 6344 STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p _pDEPTH); 6345 #define PERL_ARGS_ASSERT_REGCPPOP \ 6346 assert(rex); assert(maxopenparen_p) 6347 STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen _pDEPTH); 6348 #define PERL_ARGS_ASSERT_REGCPPUSH \ 6349 assert(rex) 6350 STATIC U8* S_reghop3(U8 *s, SSize_t off, const U8 *lim) 6351 __attribute__warn_unused_result__; 6352 #define PERL_ARGS_ASSERT_REGHOP3 \ 6353 assert(s); assert(lim) 6354 6355 STATIC U8* S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim) 6356 __attribute__warn_unused_result__; 6357 #define PERL_ARGS_ASSERT_REGHOP4 \ 6358 assert(s); assert(llim); assert(rlim) 6359 6360 STATIC U8* S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim) 6361 __attribute__warn_unused_result__; 6362 #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ 6363 assert(s); assert(lim) 6364 6365 STATIC bool S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target) 6366 __attribute__warn_unused_result__; 6367 #define PERL_ARGS_ASSERT_REGINCLASS \ 6368 assert(n); assert(p); assert(p_end) 6369 6370 STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) 6371 __attribute__warn_unused_result__; 6372 #define PERL_ARGS_ASSERT_REGMATCH \ 6373 assert(reginfo); assert(startpos); assert(prog) 6374 6375 STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info *const reginfo, I32 max _pDEPTH) 6376 __attribute__warn_unused_result__; 6377 #define PERL_ARGS_ASSERT_REGREPEAT \ 6378 assert(prog); assert(startposp); assert(p); assert(loceol); assert(reginfo) 6379 6380 STATIC bool S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) 6381 __attribute__warn_unused_result__; 6382 #define PERL_ARGS_ASSERT_REGTRY \ 6383 assert(reginfo); assert(startposp) 6384 6385 STATIC bool S_to_byte_substr(pTHX_ regexp * prog); 6386 #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ 6387 assert(prog) 6388 STATIC void S_to_utf8_substr(pTHX_ regexp * prog); 6389 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ 6390 assert(prog) 6391 #endif 6392 #if defined(PERL_IN_SCOPE_C) 6393 STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); 6394 #define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR 6395 STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); 6396 #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ 6397 assert(sptr) 6398 #endif 6399 #if defined(PERL_IN_SV_C) 6400 STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len); 6401 #define PERL_ARGS_ASSERT_F0CONVERT \ 6402 assert(endbuf); assert(len) 6403 STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv); 6404 #define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ 6405 assert(gv); assert(cv) 6406 STATIC void S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN from_cache, STRLEN real, SV *const sv); 6407 #define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ 6408 assert(func); assert(sv) 6409 STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt); 6410 #define PERL_ARGS_ASSERT_CURSE \ 6411 assert(sv) 6412 STATIC STRLEN S_expect_number(pTHX_ const char **const pattern) 6413 __attribute__warn_unused_result__; 6414 #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ 6415 assert(pattern) 6416 6417 STATIC SSize_t S_find_array_subscript(pTHX_ const AV *const av, const SV *const val); 6418 #define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ 6419 assert(val) 6420 STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val); 6421 #define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ 6422 assert(val) 6423 STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool match, const char **desc_p); 6424 #define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \ 6425 assert(desc_p) 6426 STATIC bool S_glob_2number(pTHX_ GV* const gv); 6427 #define PERL_ARGS_ASSERT_GLOB_2NUMBER \ 6428 assert(gv) 6429 STATIC void S_glob_assign_glob(pTHX_ SV *const dsv, SV *const ssv, const int dtype); 6430 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ 6431 assert(dsv); assert(ssv) 6432 STATIC SV * S_more_sv(pTHX); 6433 #define PERL_ARGS_ASSERT_MORE_SV 6434 STATIC void S_not_a_number(pTHX_ SV *const sv); 6435 #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ 6436 assert(sv) 6437 STATIC void S_not_incrementable(pTHX_ SV *const sv); 6438 #define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ 6439 assert(sv) 6440 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) 6441 __attribute__warn_unused_result__; 6442 #define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ 6443 assert(tbl) 6444 6445 STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv); 6446 #define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ 6447 assert(sv) 6448 STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags); 6449 #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ 6450 assert(ptr) 6451 STATIC const char * S_sv_display(pTHX_ SV *const sv, char *tmpbuf, STRLEN tmpbuf_size); 6452 #define PERL_ARGS_ASSERT_SV_DISPLAY \ 6453 assert(sv); assert(tmpbuf) 6454 STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu); 6455 #define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ 6456 assert(s); assert(target); assert(end) 6457 STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV *const sv, MAGIC **const mgp, const U8 *const start, const U8 *const send, STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0); 6458 #define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ 6459 assert(sv); assert(mgp); assert(start); assert(send) 6460 STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STRLEN *const uoffset, bool *const at_end, bool *canonical_position); 6461 #define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ 6462 assert(start); assert(send); assert(uoffset); assert(at_end); assert(canonical_position) 6463 STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, const STRLEN uend); 6464 #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ 6465 assert(start); assert(send) 6466 #ifndef PERL_NO_INLINE_FUNCTIONS 6467 PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags); 6468 #define PERL_ARGS_ASSERT_SV_UNGLOB \ 6469 assert(sv) 6470 #endif 6471 #ifndef PERL_NO_INLINE_FUNCTIONS 6472 PERL_STATIC_INLINE char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) 6473 __attribute__warn_unused_result__; 6474 #define PERL_ARGS_ASSERT_UIV_2BUF \ 6475 assert(buf); assert(peob) 6476 #endif 6477 6478 STATIC void S_utf8_mg_len_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN ulen); 6479 #define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ 6480 assert(sv); assert(mgp) 6481 STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen); 6482 #define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ 6483 assert(sv); assert(mgp) 6484 STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask); 6485 #define PERL_ARGS_ASSERT_VISIT \ 6486 assert(f) 6487 # if defined(USE_ITHREADS) 6488 STATIC SV* S_sv_dup_common(pTHX_ const SV *const ssv, CLONE_PARAMS *const param) 6489 __attribute__warn_unused_result__; 6490 #define PERL_ARGS_ASSERT_SV_DUP_COMMON \ 6491 assert(ssv); assert(param) 6492 6493 STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param); 6494 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ 6495 assert(source); assert(dest); assert(param) 6496 STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced); 6497 #define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ 6498 assert(unreferenced) 6499 # endif 6500 #endif 6501 #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) 6502 PERL_CALLCONV SV * Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, SSize_t aindex, int subscript_type) 6503 __attribute__warn_unused_result__; 6504 #define PERL_ARGS_ASSERT_VARNAME 6505 6506 #endif 6507 #if defined(PERL_IN_TOKE_C) 6508 STATIC int S_ao(pTHX_ int toketype); 6509 #define PERL_ARGS_ASSERT_AO 6510 STATIC void S_check_uni(pTHX); 6511 #define PERL_ARGS_ASSERT_CHECK_UNI 6512 STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what); 6513 #define PERL_ARGS_ASSERT_CHECKCOMMA \ 6514 assert(s); assert(name); assert(what) 6515 STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) 6516 __attribute__warn_unused_result__; 6517 #define PERL_ARGS_ASSERT_FILTER_GETS \ 6518 assert(sv) 6519 6520 STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) 6521 __attribute__warn_unused_result__; 6522 #define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ 6523 assert(pkgname) 6524 6525 STATIC void S_force_ident(pTHX_ const char *s, int kind); 6526 #define PERL_ARGS_ASSERT_FORCE_IDENT \ 6527 assert(s) 6528 STATIC void S_force_ident_maybe_lex(pTHX_ char pit); 6529 #define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX 6530 STATIC void S_force_next(pTHX_ I32 type); 6531 #define PERL_ARGS_ASSERT_FORCE_NEXT 6532 STATIC char* S_force_strict_version(pTHX_ char *s); 6533 #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ 6534 assert(s) 6535 STATIC char* S_force_version(pTHX_ char *s, int guessing); 6536 #define PERL_ARGS_ASSERT_FORCE_VERSION \ 6537 assert(s) 6538 STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack); 6539 #define PERL_ARGS_ASSERT_FORCE_WORD \ 6540 assert(start) 6541 STATIC SV* S_get_and_check_backslash_N_name_wrapper(pTHX_ const char* s, const char* const e) 6542 __attribute__warn_unused_result__; 6543 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \ 6544 assert(s); assert(e) 6545 6546 STATIC void S_incline(pTHX_ const char *s, const char *end); 6547 #define PERL_ARGS_ASSERT_INCLINE \ 6548 assert(s); assert(end) 6549 STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv); 6550 #define PERL_ARGS_ASSERT_INTUIT_METHOD \ 6551 assert(s) 6552 STATIC int S_intuit_more(pTHX_ char *s, char *e); 6553 #define PERL_ARGS_ASSERT_INTUIT_MORE \ 6554 assert(s); assert(e) 6555 STATIC I32 S_lop(pTHX_ I32 f, U8 x, char *s); 6556 #define PERL_ARGS_ASSERT_LOP \ 6557 assert(s) 6558 PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s, STRLEN len) 6559 __attribute__noreturn__; 6560 #define PERL_ARGS_ASSERT_MISSINGTERM 6561 6562 STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char ** error_msg); 6563 #define PERL_ARGS_ASSERT_NEW_CONSTANT \ 6564 assert(key); assert(sv) 6565 STATIC void S_no_op(pTHX_ const char *const what, char *s); 6566 #define PERL_ARGS_ASSERT_NO_OP \ 6567 assert(what) 6568 STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar, bool tick_warn); 6569 #define PERL_ARGS_ASSERT_PARSE_IDENT \ 6570 assert(s); assert(d); assert(e) 6571 STATIC int S_pending_ident(pTHX); 6572 #define PERL_ARGS_ASSERT_PENDING_IDENT 6573 STATIC char* S_scan_const(pTHX_ char *start) 6574 __attribute__warn_unused_result__; 6575 #define PERL_ARGS_ASSERT_SCAN_CONST \ 6576 assert(start) 6577 6578 STATIC char* S_scan_formline(pTHX_ char *s) 6579 __attribute__warn_unused_result__; 6580 #define PERL_ARGS_ASSERT_SCAN_FORMLINE \ 6581 assert(s) 6582 6583 STATIC char* S_scan_heredoc(pTHX_ char *s) 6584 __attribute__warn_unused_result__; 6585 #define PERL_ARGS_ASSERT_SCAN_HEREDOC \ 6586 assert(s) 6587 6588 STATIC char* S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni); 6589 #define PERL_ARGS_ASSERT_SCAN_IDENT \ 6590 assert(s); assert(dest) 6591 STATIC char* S_scan_inputsymbol(pTHX_ char *start) 6592 __attribute__warn_unused_result__; 6593 #define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ 6594 assert(start) 6595 6596 STATIC char* S_scan_pat(pTHX_ char *start, I32 type) 6597 __attribute__warn_unused_result__; 6598 #define PERL_ARGS_ASSERT_SCAN_PAT \ 6599 assert(start) 6600 6601 STATIC char* S_scan_subst(pTHX_ char *start) 6602 __attribute__warn_unused_result__; 6603 #define PERL_ARGS_ASSERT_SCAN_SUBST \ 6604 assert(start) 6605 6606 STATIC char* S_scan_trans(pTHX_ char *start) 6607 __attribute__warn_unused_result__; 6608 #define PERL_ARGS_ASSERT_SCAN_TRANS \ 6609 assert(start) 6610 6611 STATIC I32 S_sublex_done(pTHX) 6612 __attribute__warn_unused_result__; 6613 #define PERL_ARGS_ASSERT_SUBLEX_DONE 6614 6615 STATIC I32 S_sublex_push(pTHX) 6616 __attribute__warn_unused_result__; 6617 #define PERL_ARGS_ASSERT_SUBLEX_PUSH 6618 6619 STATIC I32 S_sublex_start(pTHX) 6620 __attribute__warn_unused_result__; 6621 #define PERL_ARGS_ASSERT_SUBLEX_START 6622 6623 STATIC char* S_swallow_bom(pTHX_ U8 *s) 6624 __attribute__warn_unused_result__; 6625 #define PERL_ARGS_ASSERT_SWALLOW_BOM \ 6626 assert(s) 6627 6628 STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) 6629 __attribute__warn_unused_result__; 6630 #define PERL_ARGS_ASSERT_TOKENIZE_USE \ 6631 assert(s) 6632 6633 STATIC SV* S_tokeq(pTHX_ SV *sv); 6634 #define PERL_ARGS_ASSERT_TOKEQ \ 6635 assert(sv) 6636 STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); 6637 #define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO 6638 STATIC int S_yywarn(pTHX_ const char *const s, U32 flags); 6639 #define PERL_ARGS_ASSERT_YYWARN \ 6640 assert(s) 6641 #endif 6642 #if defined(PERL_IN_UNIVERSAL_C) 6643 STATIC bool S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char * name, STRLEN len, U32 flags); 6644 STATIC bool S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char * name, const STRLEN len, U32 flags); 6645 #endif 6646 #if defined(PERL_IN_UTF8_C) 6647 STATIC UV S__to_utf8_case(pTHX_ const UV original, const U8 *p, U8* ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); 6648 #define PERL_ARGS_ASSERT__TO_UTF8_CASE \ 6649 assert(ustrp); assert(lenp); assert(invlist); assert(invmap); assert(normal) 6650 STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp) 6651 __attribute__warn_unused_result__; 6652 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ 6653 assert(p); assert(ustrp); assert(lenp) 6654 6655 #ifndef PERL_NO_INLINE_FUNCTIONS 6656 PERL_STATIC_INLINE int S_does_utf8_overflow(const U8 * const s, const U8 * e, const bool consider_overlongs) 6657 __attribute__warn_unused_result__; 6658 #define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW \ 6659 assert(s); assert(e) 6660 #endif 6661 6662 #ifndef PERL_NO_INLINE_FUNCTIONS 6663 PERL_STATIC_INLINE int S_isFF_overlong(const U8 * const s, const STRLEN len) 6664 __attribute__warn_unused_result__; 6665 #define PERL_ARGS_ASSERT_ISFF_OVERLONG \ 6666 assert(s) 6667 #endif 6668 6669 #ifndef PERL_NO_INLINE_FUNCTIONS 6670 PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, const U8 *const e, SV* const invlist) 6671 __attribute__warn_unused_result__; 6672 #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ 6673 assert(p); assert(e) 6674 #endif 6675 6676 #ifndef PERL_NO_INLINE_FUNCTIONS 6677 PERL_STATIC_INLINE int S_is_utf8_overlong(const U8 * const s, const STRLEN len) 6678 __attribute__warn_unused_result__; 6679 #define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG \ 6680 assert(s) 6681 #endif 6682 6683 STATIC HV * S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) 6684 __attribute__warn_unused_result__; 6685 #define PERL_ARGS_ASSERT_NEW_MSG_HV \ 6686 assert(message) 6687 6688 STATIC UV S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t * remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); 6689 #define PERL_ARGS_ASSERT_TO_CASE_CP_LIST \ 6690 assert(invlist); assert(invmap); assert(normal) 6691 STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) 6692 __attribute__warn_unused_result__; 6693 #define PERL_ARGS_ASSERT_TO_LOWER_LATIN1 6694 6695 STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp); 6696 #define PERL_ARGS_ASSERT_TURKIC_FC \ 6697 assert(p); assert(e); assert(ustrp); assert(lenp) 6698 STATIC UV S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8* ustrp, STRLEN *lenp); 6699 #define PERL_ARGS_ASSERT_TURKIC_LC \ 6700 assert(p0); assert(e); assert(ustrp); assert(lenp) 6701 STATIC UV S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp); 6702 #define PERL_ARGS_ASSERT_TURKIC_UC \ 6703 assert(p); assert(e); assert(ustrp); assert(lenp) 6704 STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) 6705 __attribute__warn_unused_result__; 6706 #define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ 6707 assert(s) 6708 6709 #endif 6710 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) 6711 PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s); 6712 #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ 6713 assert(p); assert(lenp) 6714 #endif 6715 #if defined(PERL_IN_UTIL_C) 6716 STATIC bool S_ckwarn_common(pTHX_ U32 w); 6717 #define PERL_ARGS_ASSERT_CKWARN_COMMON 6718 STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn); 6719 #define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK 6720 STATIC SV* S_mess_alloc(pTHX); 6721 #define PERL_ARGS_ASSERT_MESS_ALLOC 6722 STATIC SV * S_with_queued_errors(pTHX_ SV *ex); 6723 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ 6724 assert(ex) 6725 STATIC void S_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len); 6726 #define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ 6727 assert(xs_p) 6728 # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) 6729 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); 6730 #define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ 6731 assert(type_name); assert(filename); assert(funcname) 6732 # endif 6733 #endif 6734 #if defined(PERL_MEM_LOG) 6735 PERL_CALLCONV Malloc_t Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); 6736 #define PERL_ARGS_ASSERT_MEM_LOG_ALLOC \ 6737 assert(type_name); assert(filename); assert(funcname) 6738 PERL_CALLCONV Malloc_t Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); 6739 #define PERL_ARGS_ASSERT_MEM_LOG_FREE \ 6740 assert(filename); assert(funcname) 6741 PERL_CALLCONV Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); 6742 #define PERL_ARGS_ASSERT_MEM_LOG_REALLOC \ 6743 assert(type_name); assert(filename); assert(funcname) 6744 #endif 6745 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) 6746 STATIC void S_pidgone(pTHX_ Pid_t pid, int status); 6747 #define PERL_ARGS_ASSERT_PIDGONE 6748 #endif 6749 #if defined(PERL_USE_3ARG_SIGHANDLER) 6750 PERL_CALLCONV Signal_t Perl_csighandler(int sig, Siginfo_t *info, void *uap); 6751 #define PERL_ARGS_ASSERT_CSIGHANDLER 6752 PERL_CALLCONV Signal_t Perl_sighandler(int sig, Siginfo_t *info, void *uap); 6753 #define PERL_ARGS_ASSERT_SIGHANDLER 6754 #endif 6755 #if defined(U64TYPE) /* HAS_QUAD undefined outside of core */ 6756 #ifndef PERL_NO_INLINE_FUNCTIONS 6757 PERL_STATIC_INLINE unsigned Perl_lsbit_pos64(U64 word) 6758 __attribute__warn_unused_result__; 6759 #define PERL_ARGS_ASSERT_LSBIT_POS64 6760 #endif 6761 6762 #ifndef PERL_NO_INLINE_FUNCTIONS 6763 PERL_STATIC_INLINE unsigned Perl_msbit_pos64(U64 word) 6764 __attribute__warn_unused_result__; 6765 #define PERL_ARGS_ASSERT_MSBIT_POS64 6766 #endif 6767 6768 #ifndef PERL_NO_INLINE_FUNCTIONS 6769 PERL_STATIC_INLINE unsigned Perl_single_1bit_pos64(U64 word) 6770 __attribute__warn_unused_result__; 6771 #define PERL_ARGS_ASSERT_SINGLE_1BIT_POS64 6772 #endif 6773 6774 #endif 6775 #if defined(UNLINK_ALL_VERSIONS) 6776 PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f); 6777 #define PERL_ARGS_ASSERT_UNLNK \ 6778 assert(f) 6779 #endif 6780 #if defined(USE_C_BACKTRACE) 6781 PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int skip); 6782 #define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ 6783 assert(fp) 6784 /* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace* bt); */ 6785 #define PERL_ARGS_ASSERT_FREE_C_BACKTRACE 6786 PERL_CALLCONV Perl_c_backtrace* Perl_get_c_backtrace(pTHX_ int max_depth, int skip); 6787 #define PERL_ARGS_ASSERT_GET_C_BACKTRACE 6788 PERL_CALLCONV SV* Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); 6789 #define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP 6790 #endif 6791 #if defined(USE_DTRACE) 6792 PERL_CALLCONV void Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); 6793 #define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL \ 6794 assert(cv) 6795 PERL_CALLCONV void Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading); 6796 #define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD \ 6797 assert(name) 6798 PERL_CALLCONV void Perl_dtrace_probe_op(pTHX_ const OP *op); 6799 #define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ 6800 assert(op) 6801 PERL_CALLCONV void Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); 6802 #define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE 6803 #endif 6804 #if defined(USE_ITHREADS) 6805 PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv); 6806 #define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ 6807 assert(hv) 6808 PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) 6809 __attribute__warn_unused_result__; 6810 #define PERL_ARGS_ASSERT_ANY_DUP \ 6811 assert(proto_perl) 6812 6813 PERL_CALLCONV void Perl_clone_params_del(CLONE_PARAMS *param); 6814 #define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ 6815 assert(param) 6816 PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter *const from, PerlInterpreter *const to) 6817 __attribute__warn_unused_result__; 6818 #define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ 6819 assert(from); assert(to) 6820 6821 PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param) 6822 __attribute__warn_unused_result__; 6823 #define PERL_ARGS_ASSERT_CX_DUP \ 6824 assert(param) 6825 6826 PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp, CLONE_PARAMS *const param) 6827 __attribute__warn_unused_result__; 6828 #define PERL_ARGS_ASSERT_DIRP_DUP \ 6829 assert(param) 6830 6831 PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param); 6832 #define PERL_ARGS_ASSERT_FP_DUP \ 6833 assert(param) 6834 PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param) 6835 __attribute__warn_unused_result__; 6836 #define PERL_ARGS_ASSERT_GP_DUP \ 6837 assert(param) 6838 6839 PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param) 6840 __attribute__warn_unused_result__; 6841 #define PERL_ARGS_ASSERT_HE_DUP \ 6842 assert(param) 6843 6844 PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param) 6845 __attribute__warn_unused_result__; 6846 #define PERL_ARGS_ASSERT_HEK_DUP \ 6847 assert(param) 6848 6849 PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param) 6850 __attribute__warn_unused_result__; 6851 #define PERL_ARGS_ASSERT_MG_DUP \ 6852 assert(param) 6853 6854 PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param); 6855 #define PERL_ARGS_ASSERT_MRO_META_DUP \ 6856 assert(smeta); assert(param) 6857 PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) 6858 __attribute__warn_unused_result__; 6859 #define PERL_ARGS_ASSERT_NEWPADOP \ 6860 assert(sv) 6861 6862 PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) 6863 __attribute__warn_unused_result__; 6864 #define PERL_ARGS_ASSERT_PADLIST_DUP \ 6865 assert(srcpad); assert(param) 6866 6867 PERL_CALLCONV PADNAME * Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) 6868 __attribute__warn_unused_result__; 6869 #define PERL_ARGS_ASSERT_PADNAME_DUP \ 6870 assert(src); assert(param) 6871 6872 PERL_CALLCONV PADNAMELIST * Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) 6873 __attribute__warn_unused_result__; 6874 #define PERL_ARGS_ASSERT_PADNAMELIST_DUP \ 6875 assert(srcpad); assert(param) 6876 6877 PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param); 6878 #define PERL_ARGS_ASSERT_PARSER_DUP \ 6879 assert(param) 6880 PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags); 6881 #define PERL_ARGS_ASSERT_PERL_CLONE \ 6882 assert(proto_perl) 6883 PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS* param); 6884 #define PERL_ARGS_ASSERT_RE_DUP_GUTS \ 6885 assert(sstr); assert(dstr); assert(param) 6886 PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param); 6887 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ 6888 assert(r); assert(param) 6889 PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dsv, const SV *const ssv, CLONE_PARAMS *const param); 6890 #define PERL_ARGS_ASSERT_RVPV_DUP \ 6891 assert(dsv); assert(ssv); assert(param) 6892 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param) 6893 __attribute__warn_unused_result__; 6894 #define PERL_ARGS_ASSERT_SI_DUP \ 6895 assert(param) 6896 6897 PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param) 6898 __attribute__warn_unused_result__; 6899 #define PERL_ARGS_ASSERT_SS_DUP \ 6900 assert(proto_perl); assert(param) 6901 6902 PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const ssv, CLONE_PARAMS *const param) 6903 __attribute__warn_unused_result__; 6904 #define PERL_ARGS_ASSERT_SV_DUP \ 6905 assert(param) 6906 6907 PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const ssv, CLONE_PARAMS *const param) 6908 __attribute__warn_unused_result__; 6909 #define PERL_ARGS_ASSERT_SV_DUP_INC \ 6910 assert(param) 6911 6912 #endif 6913 #if defined(USE_LOCALE) && ( defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MG_C) || defined (PERL_EXT_POSIX) || defined (PERL_EXT_LANGINFO)) 6914 PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category); 6915 #define PERL_ARGS_ASSERT__IS_CUR_LC_CATEGORY_UTF8 6916 #endif 6917 #if defined(USE_LOCALE_COLLATE) 6918 PERL_CALLCONV int Perl_magic_freecollxfrm(pTHX_ SV* sv, MAGIC* mg); 6919 #define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM \ 6920 assert(sv); assert(mg) 6921 PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg); 6922 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ 6923 assert(sv); assert(mg) 6924 #ifndef NO_MATHOMS 6925 PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* input_string, STRLEN len, STRLEN* xlen) 6926 __attribute__deprecated__; 6927 #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ 6928 assert(input_string); assert(xlen) 6929 #endif 6930 6931 #ifndef NO_MATHOMS 6932 PERL_CALLCONV char* Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp); 6933 #define PERL_ARGS_ASSERT_SV_COLLXFRM \ 6934 assert(sv); assert(nxp) 6935 #endif 6936 PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags); 6937 #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ 6938 assert(sv); assert(nxp) 6939 #endif 6940 #if defined(USE_PERLIO) 6941 PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); 6942 #define PERL_ARGS_ASSERT_PERLIO_CLEARERR 6943 PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); 6944 #define PERL_ARGS_ASSERT_PERLIO_CLOSE 6945 PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); 6946 #define PERL_ARGS_ASSERT_PERLIO_EOF 6947 PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); 6948 #define PERL_ARGS_ASSERT_PERLIO_ERROR 6949 PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); 6950 #define PERL_ARGS_ASSERT_PERLIO_FILENO 6951 PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); 6952 #define PERL_ARGS_ASSERT_PERLIO_FILL 6953 PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); 6954 #define PERL_ARGS_ASSERT_PERLIO_FLUSH 6955 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); 6956 #define PERL_ARGS_ASSERT_PERLIO_GET_BASE 6957 PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) 6958 __attribute__warn_unused_result__; 6959 #define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ 6960 6961 PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) 6962 __attribute__warn_unused_result__; 6963 #define PERL_ARGS_ASSERT_PERLIO_GET_CNT 6964 6965 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); 6966 #define PERL_ARGS_ASSERT_PERLIO_GET_PTR 6967 PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); 6968 #define PERL_ARGS_ASSERT_PERLIO_READ \ 6969 assert(vbuf) 6970 PERL_CALLCONV void Perl_PerlIO_restore_errno(pTHX_ PerlIO *f); 6971 #define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO 6972 PERL_CALLCONV void Perl_PerlIO_save_errno(pTHX_ PerlIO *f); 6973 #define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO 6974 PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); 6975 #define PERL_ARGS_ASSERT_PERLIO_SEEK 6976 PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); 6977 #define PERL_ARGS_ASSERT_PERLIO_SET_CNT 6978 PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); 6979 #define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT 6980 PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); 6981 #define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF 6982 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) 6983 __attribute__warn_unused_result__; 6984 #define PERL_ARGS_ASSERT_PERLIO_STDERR 6985 6986 PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) 6987 __attribute__warn_unused_result__; 6988 #define PERL_ARGS_ASSERT_PERLIO_STDIN 6989 6990 PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) 6991 __attribute__warn_unused_result__; 6992 #define PERL_ARGS_ASSERT_PERLIO_STDOUT 6993 6994 PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); 6995 #define PERL_ARGS_ASSERT_PERLIO_TELL 6996 PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); 6997 #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ 6998 assert(vbuf) 6999 PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); 7000 #define PERL_ARGS_ASSERT_PERLIO_WRITE \ 7001 assert(vbuf) 7002 #endif 7003 #if defined(USE_QUADMATH) 7004 PERL_CALLCONV bool Perl_quadmath_format_needed(const char* format); 7005 #define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \ 7006 assert(format) 7007 PERL_CALLCONV bool Perl_quadmath_format_valid(const char* format); 7008 #define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \ 7009 assert(format) 7010 #endif 7011 #if defined(WIN32) 7012 PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname) 7013 __attribute__noreturn__; 7014 #define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ 7015 assert(fname) 7016 7017 #endif 7018 #if defined(WIN32) || defined(VMS) 7019 PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp); 7020 #define PERL_ARGS_ASSERT_DO_ASPAWN \ 7021 assert(mark); assert(sp) 7022 PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd); 7023 #define PERL_ARGS_ASSERT_DO_SPAWN \ 7024 assert(cmd) 7025 PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd); 7026 #define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ 7027 assert(cmd) 7028 #endif 7029 #if defined(_MSC_VER) 7030 PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg); 7031 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 7032 assert(sv); assert(mg) 7033 #endif 7034 #ifdef PERL_CORE 7035 # include "pp_proto.h" 7036 #endif 7037 END_EXTERN_C 7038 7039 /* ex: set ro: */ 7040