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 PERL_CALLCONV UV ASCII_TO_NEED(const UV enc, const UV ch) 21 __attribute__deprecated__ 22 __attribute__warn_unused_result__ 23 __attribute__pure__; 24 25 PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing) 26 __attribute__nonnull__(pTHX_1); 27 #define PERL_ARGS_ASSERT_GV_AMUPDATE \ 28 assert(stash) 29 30 PERL_CALLCONV UV NATIVE_TO_NEED(const UV enc, const UV ch) 31 __attribute__deprecated__ 32 __attribute__warn_unused_result__ 33 __attribute__pure__; 34 35 PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); 36 PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) 37 __attribute__malloc__ 38 __attribute__warn_unused_result__; 39 40 PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) 41 __attribute__nonnull__(pTHX_1); 42 #define PERL_ARGS_ASSERT_SLAB_FREE \ 43 assert(op) 44 45 PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) 46 __attribute__warn_unused_result__; 47 48 PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c) 49 __attribute__warn_unused_result__; 50 51 PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) 52 __attribute__warn_unused_result__; 53 54 PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p) 55 __attribute__warn_unused_result__ 56 __attribute__nonnull__(pTHX_2); 57 #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ 58 assert(p) 59 60 PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p) 61 __attribute__warn_unused_result__ 62 __attribute__nonnull__(pTHX_1); 63 #define PERL_ARGS_ASSERT__IS_UTF8_MARK \ 64 assert(p) 65 66 PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p) 67 __attribute__warn_unused_result__ 68 __attribute__nonnull__(pTHX_1); 69 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ 70 assert(p) 71 72 PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p) 73 __attribute__warn_unused_result__ 74 __attribute__nonnull__(pTHX_1); 75 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ 76 assert(p) 77 78 PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) 79 __attribute__nonnull__(pTHX_2) 80 __attribute__nonnull__(pTHX_3); 81 #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ 82 assert(p); assert(lenp) 83 84 PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags) 85 __attribute__nonnull__(pTHX_1) 86 __attribute__nonnull__(pTHX_2); 87 #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ 88 assert(p); assert(ustrp) 89 90 PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) 91 __attribute__nonnull__(pTHX_1) 92 __attribute__nonnull__(pTHX_2); 93 #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ 94 assert(p); assert(ustrp) 95 96 PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) 97 __attribute__nonnull__(pTHX_1) 98 __attribute__nonnull__(pTHX_2); 99 #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ 100 assert(p); assert(ustrp) 101 102 PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags) 103 __attribute__nonnull__(pTHX_1) 104 __attribute__nonnull__(pTHX_2); 105 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ 106 assert(p); assert(ustrp) 107 108 PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags) 109 __attribute__nonnull__(pTHX_1); 110 #define PERL_ARGS_ASSERT_ALLOCMY \ 111 assert(name) 112 113 PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir) 114 __attribute__nonnull__(pTHX_1) 115 __attribute__nonnull__(pTHX_2); 116 #define PERL_ARGS_ASSERT_AMAGIC_CALL \ 117 assert(left); assert(right) 118 119 PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method) 120 __attribute__nonnull__(pTHX_1); 121 #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ 122 assert(ref) 123 124 PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); 125 PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest) 126 __attribute__nonnull__(2); 127 #define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ 128 assert(dest) 129 130 PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp) 131 __attribute__nonnull__(pTHX_2) 132 __attribute__nonnull__(pTHX_3); 133 #define PERL_ARGS_ASSERT_APPLY \ 134 assert(mark); assert(sp) 135 136 PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) 137 __attribute__nonnull__(pTHX_1) 138 __attribute__nonnull__(pTHX_2) 139 __attribute__nonnull__(pTHX_3); 140 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ 141 assert(stashpv); assert(cv); assert(attrstr) 142 143 PERL_CALLCONV void Perl_atfork_lock(void); 144 PERL_CALLCONV void Perl_atfork_unlock(void); 145 PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av) 146 __attribute__nonnull__(pTHX_1); 147 #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ 148 assert(av) 149 150 PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av) 151 __attribute__nonnull__(pTHX_1); 152 #define PERL_ARGS_ASSERT_AV_CLEAR \ 153 assert(av) 154 155 PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val) 156 __attribute__nonnull__(pTHX_1) 157 __attribute__nonnull__(pTHX_2); 158 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ 159 assert(avp); assert(val) 160 161 PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val) 162 __attribute__nonnull__(pTHX_1) 163 __attribute__nonnull__(pTHX_2); 164 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ 165 assert(avp); assert(val) 166 167 PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags) 168 __attribute__nonnull__(pTHX_1); 169 #define PERL_ARGS_ASSERT_AV_DELETE \ 170 assert(av) 171 172 PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, SSize_t key) 173 __attribute__warn_unused_result__ 174 __attribute__nonnull__(pTHX_1); 175 #define PERL_ARGS_ASSERT_AV_EXISTS \ 176 assert(av) 177 178 PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, SSize_t key) 179 __attribute__nonnull__(pTHX_1); 180 #define PERL_ARGS_ASSERT_AV_EXTEND \ 181 assert(av) 182 183 PERL_CALLCONV void Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp) 184 __attribute__nonnull__(pTHX_3) 185 __attribute__nonnull__(pTHX_4) 186 __attribute__nonnull__(pTHX_5); 187 #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ 188 assert(maxp); assert(allocp); assert(arrayp) 189 190 PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) 191 __attribute__warn_unused_result__ 192 __attribute__nonnull__(pTHX_1); 193 #define PERL_ARGS_ASSERT_AV_FETCH \ 194 assert(av) 195 196 PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, SSize_t fill) 197 __attribute__nonnull__(pTHX_1); 198 #define PERL_ARGS_ASSERT_AV_FILL \ 199 assert(av) 200 201 PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av) 202 __attribute__nonnull__(pTHX_1); 203 #define PERL_ARGS_ASSERT_AV_ITER_P \ 204 assert(av) 205 206 PERL_CALLCONV SSize_t Perl_av_len(pTHX_ AV *av) 207 __attribute__warn_unused_result__ 208 __attribute__nonnull__(pTHX_1); 209 #define PERL_ARGS_ASSERT_AV_LEN \ 210 assert(av) 211 212 PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp) 213 __attribute__warn_unused_result__ 214 __attribute__nonnull__(pTHX_2); 215 #define PERL_ARGS_ASSERT_AV_MAKE \ 216 assert(strp) 217 218 PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av) 219 __attribute__nonnull__(pTHX_1); 220 #define PERL_ARGS_ASSERT_AV_POP \ 221 assert(av) 222 223 PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val) 224 __attribute__nonnull__(pTHX_1) 225 __attribute__nonnull__(pTHX_2); 226 #define PERL_ARGS_ASSERT_AV_PUSH \ 227 assert(av); assert(val) 228 229 PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av) 230 __attribute__nonnull__(pTHX_1); 231 #define PERL_ARGS_ASSERT_AV_REIFY \ 232 assert(av) 233 234 PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) 235 __attribute__warn_unused_result__ 236 __attribute__nonnull__(pTHX_1); 237 #define PERL_ARGS_ASSERT_AV_SHIFT \ 238 assert(av) 239 240 PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val) 241 __attribute__nonnull__(pTHX_1); 242 #define PERL_ARGS_ASSERT_AV_STORE \ 243 assert(av) 244 245 /* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av) 246 __attribute__warn_unused_result__ 247 __attribute__nonnull__(pTHX_1); */ 248 249 PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av) 250 __attribute__warn_unused_result__ 251 __attribute__nonnull__(pTHX_1); 252 #define PERL_ARGS_ASSERT_AV_TOP_INDEX \ 253 assert(av) 254 255 PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) 256 __attribute__nonnull__(pTHX_1); 257 #define PERL_ARGS_ASSERT_AV_UNDEF \ 258 assert(av) 259 260 PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, SSize_t num) 261 __attribute__nonnull__(pTHX_1); 262 #define PERL_ARGS_ASSERT_AV_UNSHIFT \ 263 assert(av) 264 265 PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) 266 __attribute__warn_unused_result__ 267 __attribute__nonnull__(pTHX_2) 268 __attribute__nonnull__(pTHX_3); 269 #define PERL_ARGS_ASSERT_BIND_MATCH \ 270 assert(left); assert(right) 271 272 PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq) 273 __attribute__warn_unused_result__; 274 275 PERL_CALLCONV I32 Perl_block_gimme(pTHX) 276 __attribute__warn_unused_result__; 277 278 PERL_CALLCONV int Perl_block_start(pTHX_ int full) 279 __attribute__warn_unused_result__; 280 281 PERL_CALLCONV void Perl_blockhook_register(pTHX_ BHK *hk) 282 __attribute__nonnull__(pTHX_1); 283 #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ 284 assert(hk) 285 286 PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); 287 PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); 288 PERL_CALLCONV void Perl_boot_core_mro(pTHX); 289 PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen) 290 __attribute__nonnull__(pTHX_1) 291 __attribute__nonnull__(pTHX_3); 292 #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ 293 assert(b); assert(u) 294 295 PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8) 296 __attribute__nonnull__(pTHX_1) 297 __attribute__nonnull__(pTHX_2); 298 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ 299 assert(s); assert(len) 300 301 PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len) 302 __attribute__nonnull__(pTHX_1) 303 __attribute__nonnull__(pTHX_2); 304 #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ 305 assert(s); assert(len) 306 307 PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv) 308 __attribute__nonnull__(pTHX_1) 309 __attribute__nonnull__(pTHX_3); 310 #define PERL_ARGS_ASSERT_CALL_ARGV \ 311 assert(sub_name); assert(argv) 312 313 PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); 314 PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList) 315 __attribute__nonnull__(pTHX_2); 316 #define PERL_ARGS_ASSERT_CALL_LIST \ 317 assert(paramList) 318 319 PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags) 320 __attribute__nonnull__(pTHX_1); 321 #define PERL_ARGS_ASSERT_CALL_METHOD \ 322 assert(methname) 323 324 PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags) 325 __attribute__nonnull__(pTHX_1); 326 #define PERL_ARGS_ASSERT_CALL_PV \ 327 assert(sub_name) 328 329 PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags) 330 __attribute__nonnull__(pTHX_1); 331 #define PERL_ARGS_ASSERT_CALL_SV \ 332 assert(sv) 333 334 PERL_CALLCONV const PERL_CONTEXT * Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); 335 PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) 336 __attribute__malloc__ 337 __attribute__warn_unused_result__; 338 339 PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) 340 __attribute__warn_unused_result__ 341 __attribute__nonnull__(pTHX_3); 342 #define PERL_ARGS_ASSERT_CANDO \ 343 assert(statbufp) 344 345 PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f) 346 __attribute__warn_unused_result__; 347 348 PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f) 349 __attribute__warn_unused_result__; 350 351 PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f) 352 __attribute__warn_unused_result__; 353 354 PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f) 355 __attribute__warn_unused_result__; 356 357 PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) 358 __attribute__nonnull__(pTHX_1); 359 #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ 360 assert(s) 361 362 PERL_CALLCONV OP * Perl_ck_anoncode(pTHX_ OP *o) 363 __attribute__warn_unused_result__ 364 __attribute__nonnull__(pTHX_1); 365 #define PERL_ARGS_ASSERT_CK_ANONCODE \ 366 assert(o) 367 368 PERL_CALLCONV OP * Perl_ck_backtick(pTHX_ OP *o) 369 __attribute__warn_unused_result__ 370 __attribute__nonnull__(pTHX_1); 371 #define PERL_ARGS_ASSERT_CK_BACKTICK \ 372 assert(o) 373 374 PERL_CALLCONV OP * Perl_ck_bitop(pTHX_ OP *o) 375 __attribute__warn_unused_result__ 376 __attribute__nonnull__(pTHX_1); 377 #define PERL_ARGS_ASSERT_CK_BITOP \ 378 assert(o) 379 380 PERL_CALLCONV OP * Perl_ck_cmp(pTHX_ OP *o) 381 __attribute__warn_unused_result__ 382 __attribute__nonnull__(pTHX_1); 383 #define PERL_ARGS_ASSERT_CK_CMP \ 384 assert(o) 385 386 PERL_CALLCONV OP * Perl_ck_concat(pTHX_ OP *o) 387 __attribute__warn_unused_result__ 388 __attribute__nonnull__(pTHX_1); 389 #define PERL_ARGS_ASSERT_CK_CONCAT \ 390 assert(o) 391 392 PERL_CALLCONV OP * Perl_ck_defined(pTHX_ OP *o) 393 __attribute__warn_unused_result__ 394 __attribute__nonnull__(pTHX_1); 395 #define PERL_ARGS_ASSERT_CK_DEFINED \ 396 assert(o) 397 398 PERL_CALLCONV OP * Perl_ck_delete(pTHX_ OP *o) 399 __attribute__warn_unused_result__ 400 __attribute__nonnull__(pTHX_1); 401 #define PERL_ARGS_ASSERT_CK_DELETE \ 402 assert(o) 403 404 PERL_CALLCONV OP * Perl_ck_each(pTHX_ OP *o) 405 __attribute__warn_unused_result__ 406 __attribute__nonnull__(pTHX_1); 407 #define PERL_ARGS_ASSERT_CK_EACH \ 408 assert(o) 409 410 PERL_CALLCONV OP* Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) 411 __attribute__nonnull__(pTHX_1) 412 __attribute__nonnull__(pTHX_2) 413 __attribute__nonnull__(pTHX_3); 414 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ 415 assert(entersubop); assert(namegv); assert(protosv) 416 417 PERL_CALLCONV OP* Perl_ck_entersub_args_list(pTHX_ OP *entersubop) 418 __attribute__nonnull__(pTHX_1); 419 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ 420 assert(entersubop) 421 422 PERL_CALLCONV OP* Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv) 423 __attribute__nonnull__(pTHX_1) 424 __attribute__nonnull__(pTHX_2) 425 __attribute__nonnull__(pTHX_3); 426 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ 427 assert(entersubop); assert(namegv); assert(protosv) 428 429 PERL_CALLCONV OP* Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv) 430 __attribute__nonnull__(pTHX_1) 431 __attribute__nonnull__(pTHX_2) 432 __attribute__nonnull__(pTHX_3); 433 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ 434 assert(entersubop); assert(namegv); assert(protosv) 435 436 PERL_CALLCONV OP * Perl_ck_eof(pTHX_ OP *o) 437 __attribute__warn_unused_result__ 438 __attribute__nonnull__(pTHX_1); 439 #define PERL_ARGS_ASSERT_CK_EOF \ 440 assert(o) 441 442 PERL_CALLCONV OP * Perl_ck_eval(pTHX_ OP *o) 443 __attribute__warn_unused_result__ 444 __attribute__nonnull__(pTHX_1); 445 #define PERL_ARGS_ASSERT_CK_EVAL \ 446 assert(o) 447 448 PERL_CALLCONV OP * Perl_ck_exec(pTHX_ OP *o) 449 __attribute__warn_unused_result__ 450 __attribute__nonnull__(pTHX_1); 451 #define PERL_ARGS_ASSERT_CK_EXEC \ 452 assert(o) 453 454 PERL_CALLCONV OP * Perl_ck_exists(pTHX_ OP *o) 455 __attribute__warn_unused_result__ 456 __attribute__nonnull__(pTHX_1); 457 #define PERL_ARGS_ASSERT_CK_EXISTS \ 458 assert(o) 459 460 PERL_CALLCONV OP * Perl_ck_ftst(pTHX_ OP *o) 461 __attribute__warn_unused_result__ 462 __attribute__nonnull__(pTHX_1); 463 #define PERL_ARGS_ASSERT_CK_FTST \ 464 assert(o) 465 466 PERL_CALLCONV OP * Perl_ck_fun(pTHX_ OP *o) 467 __attribute__warn_unused_result__ 468 __attribute__nonnull__(pTHX_1); 469 #define PERL_ARGS_ASSERT_CK_FUN \ 470 assert(o) 471 472 PERL_CALLCONV OP * Perl_ck_glob(pTHX_ OP *o) 473 __attribute__warn_unused_result__ 474 __attribute__nonnull__(pTHX_1); 475 #define PERL_ARGS_ASSERT_CK_GLOB \ 476 assert(o) 477 478 PERL_CALLCONV OP * Perl_ck_grep(pTHX_ OP *o) 479 __attribute__warn_unused_result__ 480 __attribute__nonnull__(pTHX_1); 481 #define PERL_ARGS_ASSERT_CK_GREP \ 482 assert(o) 483 484 PERL_CALLCONV OP * Perl_ck_index(pTHX_ OP *o) 485 __attribute__warn_unused_result__ 486 __attribute__nonnull__(pTHX_1); 487 #define PERL_ARGS_ASSERT_CK_INDEX \ 488 assert(o) 489 490 PERL_CALLCONV OP * Perl_ck_join(pTHX_ OP *o) 491 __attribute__warn_unused_result__ 492 __attribute__nonnull__(pTHX_1); 493 #define PERL_ARGS_ASSERT_CK_JOIN \ 494 assert(o) 495 496 PERL_CALLCONV OP * Perl_ck_length(pTHX_ OP *o) 497 __attribute__warn_unused_result__ 498 __attribute__nonnull__(pTHX_1); 499 #define PERL_ARGS_ASSERT_CK_LENGTH \ 500 assert(o) 501 502 PERL_CALLCONV OP * Perl_ck_lfun(pTHX_ OP *o) 503 __attribute__warn_unused_result__ 504 __attribute__nonnull__(pTHX_1); 505 #define PERL_ARGS_ASSERT_CK_LFUN \ 506 assert(o) 507 508 PERL_CALLCONV OP * Perl_ck_listiob(pTHX_ OP *o) 509 __attribute__warn_unused_result__ 510 __attribute__nonnull__(pTHX_1); 511 #define PERL_ARGS_ASSERT_CK_LISTIOB \ 512 assert(o) 513 514 PERL_CALLCONV OP * Perl_ck_match(pTHX_ OP *o) 515 __attribute__warn_unused_result__ 516 __attribute__nonnull__(pTHX_1); 517 #define PERL_ARGS_ASSERT_CK_MATCH \ 518 assert(o) 519 520 PERL_CALLCONV OP * Perl_ck_method(pTHX_ OP *o) 521 __attribute__warn_unused_result__ 522 __attribute__nonnull__(pTHX_1); 523 #define PERL_ARGS_ASSERT_CK_METHOD \ 524 assert(o) 525 526 PERL_CALLCONV OP * Perl_ck_null(pTHX_ OP *o) 527 __attribute__warn_unused_result__ 528 __attribute__nonnull__(pTHX_1); 529 #define PERL_ARGS_ASSERT_CK_NULL \ 530 assert(o) 531 532 PERL_CALLCONV OP * Perl_ck_open(pTHX_ OP *o) 533 __attribute__warn_unused_result__ 534 __attribute__nonnull__(pTHX_1); 535 #define PERL_ARGS_ASSERT_CK_OPEN \ 536 assert(o) 537 538 PERL_CALLCONV OP * Perl_ck_readline(pTHX_ OP *o) 539 __attribute__warn_unused_result__ 540 __attribute__nonnull__(pTHX_1); 541 #define PERL_ARGS_ASSERT_CK_READLINE \ 542 assert(o) 543 544 PERL_CALLCONV OP * Perl_ck_repeat(pTHX_ OP *o) 545 __attribute__warn_unused_result__ 546 __attribute__nonnull__(pTHX_1); 547 #define PERL_ARGS_ASSERT_CK_REPEAT \ 548 assert(o) 549 550 PERL_CALLCONV OP * Perl_ck_require(pTHX_ OP *o) 551 __attribute__warn_unused_result__ 552 __attribute__nonnull__(pTHX_1); 553 #define PERL_ARGS_ASSERT_CK_REQUIRE \ 554 assert(o) 555 556 PERL_CALLCONV OP * Perl_ck_return(pTHX_ OP *o) 557 __attribute__warn_unused_result__ 558 __attribute__nonnull__(pTHX_1); 559 #define PERL_ARGS_ASSERT_CK_RETURN \ 560 assert(o) 561 562 PERL_CALLCONV OP * Perl_ck_rfun(pTHX_ OP *o) 563 __attribute__warn_unused_result__ 564 __attribute__nonnull__(pTHX_1); 565 #define PERL_ARGS_ASSERT_CK_RFUN \ 566 assert(o) 567 568 PERL_CALLCONV OP * Perl_ck_rvconst(pTHX_ OP *o) 569 __attribute__warn_unused_result__ 570 __attribute__nonnull__(pTHX_1); 571 #define PERL_ARGS_ASSERT_CK_RVCONST \ 572 assert(o) 573 574 PERL_CALLCONV OP * Perl_ck_sassign(pTHX_ OP *o) 575 __attribute__warn_unused_result__ 576 __attribute__nonnull__(pTHX_1); 577 #define PERL_ARGS_ASSERT_CK_SASSIGN \ 578 assert(o) 579 580 PERL_CALLCONV OP * Perl_ck_select(pTHX_ OP *o) 581 __attribute__warn_unused_result__ 582 __attribute__nonnull__(pTHX_1); 583 #define PERL_ARGS_ASSERT_CK_SELECT \ 584 assert(o) 585 586 PERL_CALLCONV OP * Perl_ck_shift(pTHX_ OP *o) 587 __attribute__warn_unused_result__ 588 __attribute__nonnull__(pTHX_1); 589 #define PERL_ARGS_ASSERT_CK_SHIFT \ 590 assert(o) 591 592 PERL_CALLCONV OP * Perl_ck_smartmatch(pTHX_ OP *o) 593 __attribute__warn_unused_result__ 594 __attribute__nonnull__(pTHX_1); 595 #define PERL_ARGS_ASSERT_CK_SMARTMATCH \ 596 assert(o) 597 598 PERL_CALLCONV OP * Perl_ck_sort(pTHX_ OP *o) 599 __attribute__warn_unused_result__ 600 __attribute__nonnull__(pTHX_1); 601 #define PERL_ARGS_ASSERT_CK_SORT \ 602 assert(o) 603 604 PERL_CALLCONV OP * Perl_ck_spair(pTHX_ OP *o) 605 __attribute__warn_unused_result__ 606 __attribute__nonnull__(pTHX_1); 607 #define PERL_ARGS_ASSERT_CK_SPAIR \ 608 assert(o) 609 610 PERL_CALLCONV OP * Perl_ck_split(pTHX_ OP *o) 611 __attribute__warn_unused_result__ 612 __attribute__nonnull__(pTHX_1); 613 #define PERL_ARGS_ASSERT_CK_SPLIT \ 614 assert(o) 615 616 PERL_CALLCONV OP * Perl_ck_subr(pTHX_ OP *o) 617 __attribute__warn_unused_result__ 618 __attribute__nonnull__(pTHX_1); 619 #define PERL_ARGS_ASSERT_CK_SUBR \ 620 assert(o) 621 622 PERL_CALLCONV OP * Perl_ck_substr(pTHX_ OP *o) 623 __attribute__warn_unused_result__ 624 __attribute__nonnull__(pTHX_1); 625 #define PERL_ARGS_ASSERT_CK_SUBSTR \ 626 assert(o) 627 628 PERL_CALLCONV OP * Perl_ck_svconst(pTHX_ OP *o) 629 __attribute__warn_unused_result__ 630 __attribute__nonnull__(pTHX_1); 631 #define PERL_ARGS_ASSERT_CK_SVCONST \ 632 assert(o) 633 634 PERL_CALLCONV OP * Perl_ck_tell(pTHX_ OP *o) 635 __attribute__warn_unused_result__ 636 __attribute__nonnull__(pTHX_1); 637 #define PERL_ARGS_ASSERT_CK_TELL \ 638 assert(o) 639 640 PERL_CALLCONV OP * Perl_ck_trunc(pTHX_ OP *o) 641 __attribute__warn_unused_result__ 642 __attribute__nonnull__(pTHX_1); 643 #define PERL_ARGS_ASSERT_CK_TRUNC \ 644 assert(o) 645 646 PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...) 647 __attribute__format__(__printf__,pTHX_2,pTHX_3) 648 __attribute__nonnull__(pTHX_2); 649 #define PERL_ARGS_ASSERT_CK_WARNER \ 650 assert(pat) 651 652 PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) 653 __attribute__format__(__printf__,pTHX_2,pTHX_3) 654 __attribute__nonnull__(pTHX_2); 655 #define PERL_ARGS_ASSERT_CK_WARNER_D \ 656 assert(pat) 657 658 PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w); 659 PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w); 660 PERL_CALLCONV const COP* Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) 661 __attribute__nonnull__(pTHX_1); 662 #define PERL_ARGS_ASSERT_CLOSEST_COP \ 663 assert(cop) 664 665 PERL_CALLCONV OP* Perl_convert(pTHX_ I32 optype, I32 flags, OP* o) 666 __attribute__warn_unused_result__; 667 668 PERL_CALLCONV const char * Perl_cop_fetch_label(pTHX_ COP *const cop, STRLEN *len, U32 *flags) 669 __attribute__nonnull__(pTHX_1); 670 #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ 671 assert(cop) 672 673 PERL_CALLCONV void Perl_cop_store_label(pTHX_ COP *const cop, const char *label, STRLEN len, U32 flags) 674 __attribute__nonnull__(pTHX_1) 675 __attribute__nonnull__(pTHX_2); 676 #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ 677 assert(cop); assert(label) 678 679 PERL_CALLCONV SV * Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) 680 __attribute__nonnull__(pTHX_2); 681 #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ 682 assert(name) 683 684 PERL_CALLCONV OP * Perl_coresub_op(pTHX_ SV *const coreargssv, const int code, const int opnum) 685 __attribute__nonnull__(pTHX_1); 686 #define PERL_ARGS_ASSERT_CORESUB_OP \ 687 assert(coreargssv) 688 689 PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags); 690 PERL_CALLCONV_NO_RET void Perl_croak(pTHX_ const char* pat, ...) 691 __attribute__noreturn__ 692 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 693 694 PERL_STATIC_NO_RET void S_croak_memory_wrap(void) 695 __attribute__noreturn__; 696 697 PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void) 698 __attribute__noreturn__; 699 700 PERL_CALLCONV_NO_RET void Perl_croak_no_modify(void) 701 __attribute__noreturn__; 702 703 PERL_CALLCONV_NO_RET void Perl_croak_popstack(void) 704 __attribute__noreturn__; 705 706 PERL_CALLCONV_NO_RET void Perl_croak_sv(pTHX_ SV *baseex) 707 __attribute__noreturn__ 708 __attribute__nonnull__(pTHX_1); 709 #define PERL_ARGS_ASSERT_CROAK_SV \ 710 assert(baseex) 711 712 PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *const params) 713 __attribute__noreturn__ 714 __attribute__nonnull__(1) 715 __attribute__nonnull__(2); 716 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ 717 assert(cv); assert(params) 718 719 PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); 720 PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) 721 __attribute__warn_unused_result__ 722 __attribute__nonnull__(pTHX_1); 723 #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ 724 assert(o) 725 726 PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) 727 __attribute__warn_unused_result__ 728 __attribute__nonnull__(pTHX_1); 729 #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ 730 assert(o) 731 732 PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) 733 __attribute__warn_unused_result__ 734 __attribute__nonnull__(pTHX_1); 735 #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ 736 assert(o) 737 738 PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop) 739 __attribute__nonnull__(pTHX_1) 740 __attribute__nonnull__(pTHX_2); 741 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ 742 assert(ppaddr); assert(xop) 743 744 /* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o) 745 __attribute__pure__ 746 __attribute__nonnull__(pTHX_1); */ 747 748 PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags) 749 __attribute__nonnull__(pTHX_1); 750 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ 751 assert(cv) 752 753 PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto) 754 __attribute__nonnull__(pTHX_1); 755 #define PERL_ARGS_ASSERT_CV_CLONE \ 756 assert(proto) 757 758 PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target) 759 __attribute__nonnull__(pTHX_1) 760 __attribute__nonnull__(pTHX_2); 761 #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ 762 assert(proto); assert(target) 763 764 PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv) 765 __attribute__warn_unused_result__; 766 767 PERL_CALLCONV SV* Perl_cv_const_sv_or_av(pTHX_ const CV *const cv) 768 __attribute__warn_unused_result__; 769 770 PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv) 771 __attribute__nonnull__(pTHX_1); 772 #define PERL_ARGS_ASSERT_CV_FORGET_SLAB \ 773 assert(cv) 774 775 PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p) 776 __attribute__nonnull__(pTHX_1) 777 __attribute__nonnull__(pTHX_2) 778 __attribute__nonnull__(pTHX_3); 779 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ 780 assert(cv); assert(ckfun_p); assert(ckobj_p) 781 782 PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) 783 __attribute__nonnull__(pTHX_1) 784 __attribute__nonnull__(pTHX_2) 785 __attribute__nonnull__(pTHX_3); 786 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ 787 assert(cv); assert(ckfun); assert(ckobj) 788 789 PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv) 790 __attribute__nonnull__(pTHX_1); 791 #define PERL_ARGS_ASSERT_CV_UNDEF \ 792 assert(cv) 793 794 PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv) 795 __attribute__nonnull__(pTHX_1); 796 #define PERL_ARGS_ASSERT_CVGV_SET \ 797 assert(cv) 798 799 PERL_CALLCONV void Perl_cvstash_set(pTHX_ CV* cv, HV* stash) 800 __attribute__nonnull__(pTHX_1); 801 #define PERL_ARGS_ASSERT_CVSTASH_SET \ 802 assert(cv) 803 804 PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx) 805 __attribute__nonnull__(pTHX_1); 806 #define PERL_ARGS_ASSERT_CX_DUMP \ 807 assert(cx) 808 809 PERL_CALLCONV I32 Perl_cxinc(pTHX) 810 __attribute__warn_unused_result__; 811 812 PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) 813 __attribute__format__(__printf__,pTHX_1,pTHX_2) 814 __attribute__nonnull__(pTHX_1); 815 #define PERL_ARGS_ASSERT_DEB \ 816 assert(pat) 817 818 PERL_CALLCONV void Perl_deb_stack_all(pTHX); 819 PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o) 820 __attribute__nonnull__(pTHX_1); 821 #define PERL_ARGS_ASSERT_DEBOP \ 822 assert(o) 823 824 PERL_CALLCONV void Perl_debprofdump(pTHX); 825 PERL_CALLCONV I32 Perl_debstack(pTHX); 826 PERL_CALLCONV I32 Perl_debstackptrs(pTHX); 827 PERL_CALLCONV SV * Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) 828 __attribute__warn_unused_result__ 829 __attribute__nonnull__(pTHX_1); 830 #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ 831 assert(sv) 832 833 PERL_CALLCONV void Perl_delete_eval_scope(pTHX); 834 PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen) 835 __attribute__nonnull__(1) 836 __attribute__nonnull__(2) 837 __attribute__nonnull__(3) 838 __attribute__nonnull__(4) 839 __attribute__nonnull__(6); 840 #define PERL_ARGS_ASSERT_DELIMCPY \ 841 assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) 842 843 PERL_CALLCONV void Perl_despatch_signals(pTHX); 844 PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...) 845 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 846 847 PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex) 848 __attribute__nonnull__(pTHX_1); 849 #define PERL_ARGS_ASSERT_DIE_SV \ 850 assert(baseex) 851 852 PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv) 853 __attribute__noreturn__ 854 __attribute__nonnull__(pTHX_1); 855 #define PERL_ARGS_ASSERT_DIE_UNWIND \ 856 assert(msv) 857 858 /* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp) 859 __attribute__nonnull__(pTHX_2) 860 __attribute__nonnull__(pTHX_3); */ 861 #define PERL_ARGS_ASSERT_DO_AEXEC \ 862 assert(mark); assert(sp) 863 864 PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report) 865 __attribute__nonnull__(pTHX_2) 866 __attribute__nonnull__(pTHX_3); 867 #define PERL_ARGS_ASSERT_DO_AEXEC5 \ 868 assert(mark); assert(sp) 869 870 PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) 871 __attribute__nonnull__(pTHX_1); 872 #define PERL_ARGS_ASSERT_DO_BINMODE \ 873 assert(fp) 874 875 PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); 876 PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) 877 __attribute__nonnull__(pTHX_2); 878 #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ 879 assert(file) 880 881 PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv) 882 __attribute__nonnull__(pTHX_1); 883 #define PERL_ARGS_ASSERT_DO_EOF \ 884 assert(gv) 885 886 PERL_CALLCONV void Perl_do_execfree(pTHX); 887 PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) 888 __attribute__nonnull__(pTHX_2) 889 __attribute__nonnull__(pTHX_3); 890 #define PERL_ARGS_ASSERT_DO_GV_DUMP \ 891 assert(file); assert(name) 892 893 PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) 894 __attribute__nonnull__(pTHX_2) 895 __attribute__nonnull__(pTHX_3); 896 #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ 897 assert(file); assert(name) 898 899 PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) 900 __attribute__nonnull__(pTHX_2) 901 __attribute__nonnull__(pTHX_3); 902 #define PERL_ARGS_ASSERT_DO_HV_DUMP \ 903 assert(file); assert(name) 904 905 PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) 906 __attribute__nonnull__(pTHX_1) 907 __attribute__nonnull__(pTHX_2) 908 __attribute__nonnull__(pTHX_3) 909 __attribute__nonnull__(pTHX_4); 910 #define PERL_ARGS_ASSERT_DO_JOIN \ 911 assert(sv); assert(delim); assert(mark); assert(sp) 912 913 PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) 914 __attribute__nonnull__(pTHX_2) 915 __attribute__nonnull__(pTHX_3); 916 #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ 917 assert(file); assert(mg) 918 919 PERL_CALLCONV I32 Perl_do_ncmp(pTHX_ SV *const left, SV *const right) 920 __attribute__warn_unused_result__ 921 __attribute__nonnull__(pTHX_1) 922 __attribute__nonnull__(pTHX_2); 923 #define PERL_ARGS_ASSERT_DO_NCMP \ 924 assert(left); assert(right) 925 926 PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) 927 __attribute__nonnull__(pTHX_2); 928 #define PERL_ARGS_ASSERT_DO_OP_DUMP \ 929 assert(file) 930 931 /* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp) 932 __attribute__nonnull__(pTHX_1) 933 __attribute__nonnull__(pTHX_2); */ 934 #define PERL_ARGS_ASSERT_DO_OPEN \ 935 assert(gv); assert(name) 936 937 PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) 938 __attribute__nonnull__(pTHX_1) 939 __attribute__nonnull__(pTHX_2); 940 #define PERL_ARGS_ASSERT_DO_OPEN6 \ 941 assert(gv); assert(oname) 942 943 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) 944 __attribute__nonnull__(pTHX_1) 945 __attribute__nonnull__(pTHX_2) 946 __attribute__nonnull__(pTHX_8); 947 #define PERL_ARGS_ASSERT_DO_OPEN9 \ 948 assert(gv); assert(name); assert(svs) 949 950 PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm) 951 __attribute__nonnull__(pTHX_1) 952 __attribute__nonnull__(pTHX_2); 953 #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ 954 assert(gv); assert(oname) 955 956 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) 957 __attribute__nonnull__(pTHX_1) 958 __attribute__nonnull__(pTHX_2); 959 #define PERL_ARGS_ASSERT_DO_OPENN \ 960 assert(gv); assert(oname) 961 962 PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) 963 __attribute__nonnull__(pTHX_2); 964 #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ 965 assert(file) 966 967 PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp) 968 __attribute__nonnull__(pTHX_2); 969 #define PERL_ARGS_ASSERT_DO_PRINT \ 970 assert(fp) 971 972 PERL_CALLCONV OP* Perl_do_readline(pTHX) 973 __attribute__warn_unused_result__; 974 975 PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); 976 PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg) 977 __attribute__nonnull__(pTHX_1) 978 __attribute__nonnull__(pTHX_3); 979 #define PERL_ARGS_ASSERT_DO_SPRINTF \ 980 assert(sv); assert(sarg) 981 982 PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) 983 __attribute__nonnull__(pTHX_2); 984 #define PERL_ARGS_ASSERT_DO_SV_DUMP \ 985 assert(file) 986 987 PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence) 988 __attribute__nonnull__(pTHX_1); 989 #define PERL_ARGS_ASSERT_DO_SYSSEEK \ 990 assert(gv) 991 992 PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) 993 __attribute__warn_unused_result__ 994 __attribute__nonnull__(pTHX_1); 995 #define PERL_ARGS_ASSERT_DO_TELL \ 996 assert(gv) 997 998 PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv) 999 __attribute__nonnull__(pTHX_1); 1000 #define PERL_ARGS_ASSERT_DO_TRANS \ 1001 assert(sv) 1002 1003 PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size) 1004 __attribute__nonnull__(pTHX_1); 1005 #define PERL_ARGS_ASSERT_DO_VECGET \ 1006 assert(sv) 1007 1008 PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv) 1009 __attribute__nonnull__(pTHX_1); 1010 #define PERL_ARGS_ASSERT_DO_VECSET \ 1011 assert(sv) 1012 1013 PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right) 1014 __attribute__nonnull__(pTHX_2) 1015 __attribute__nonnull__(pTHX_3) 1016 __attribute__nonnull__(pTHX_4); 1017 #define PERL_ARGS_ASSERT_DO_VOP \ 1018 assert(sv); assert(left); assert(right) 1019 1020 PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin) 1021 __attribute__nonnull__(pTHX_1); 1022 #define PERL_ARGS_ASSERT_DOFILE \ 1023 assert(term) 1024 1025 PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) 1026 __attribute__warn_unused_result__; 1027 1028 PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) 1029 __attribute__nonnull__(pTHX_1); 1030 #define PERL_ARGS_ASSERT_DOREF \ 1031 assert(o) 1032 1033 PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); 1034 PERL_CALLCONV I32 Perl_dowantarray(pTHX) 1035 __attribute__warn_unused_result__; 1036 1037 PERL_CALLCONV void Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed) 1038 __attribute__nonnull__(1); 1039 #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ 1040 assert(random_state) 1041 1042 PERL_CALLCONV double Perl_drand48_r(perl_drand48_t *random_state) 1043 __attribute__nonnull__(1); 1044 #define PERL_ARGS_ASSERT_DRAND48_R \ 1045 assert(random_state) 1046 1047 PERL_CALLCONV void Perl_dump_all(pTHX); 1048 PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); 1049 PERL_CALLCONV void Perl_dump_eval(pTHX); 1050 PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv) 1051 __attribute__nonnull__(pTHX_1); 1052 #define PERL_ARGS_ASSERT_DUMP_FORM \ 1053 assert(gv) 1054 1055 PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 1056 __attribute__format__(__printf__,pTHX_3,pTHX_4) 1057 __attribute__nonnull__(pTHX_2) 1058 __attribute__nonnull__(pTHX_3); 1059 #define PERL_ARGS_ASSERT_DUMP_INDENT \ 1060 assert(file); assert(pat) 1061 1062 PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash) 1063 __attribute__nonnull__(pTHX_1); 1064 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ 1065 assert(stash) 1066 1067 PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl) 1068 __attribute__nonnull__(pTHX_1); 1069 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ 1070 assert(stash) 1071 1072 PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv) 1073 __attribute__nonnull__(pTHX_1); 1074 #define PERL_ARGS_ASSERT_DUMP_SUB \ 1075 assert(gv) 1076 1077 PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl) 1078 __attribute__nonnull__(pTHX_1); 1079 #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ 1080 assert(gv) 1081 1082 PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) 1083 __attribute__nonnull__(pTHX_2) 1084 __attribute__nonnull__(pTHX_3); 1085 #define PERL_ARGS_ASSERT_DUMP_VINDENT \ 1086 assert(file); assert(pat) 1087 1088 PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv) 1089 __attribute__nonnull__(pTHX_1) 1090 __attribute__nonnull__(pTHX_2); 1091 #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ 1092 assert(c); assert(sv) 1093 1094 PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error) 1095 __attribute__nonnull__(pTHX_1); 1096 #define PERL_ARGS_ASSERT_EVAL_PV \ 1097 assert(p) 1098 1099 PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags) 1100 __attribute__nonnull__(pTHX_1); 1101 #define PERL_ARGS_ASSERT_EVAL_SV \ 1102 assert(sv) 1103 1104 PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags) 1105 __attribute__nonnull__(pTHX_1); 1106 #define PERL_ARGS_ASSERT_FBM_COMPILE \ 1107 assert(sv) 1108 1109 PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags) 1110 __attribute__warn_unused_result__ 1111 __attribute__nonnull__(pTHX_1) 1112 __attribute__nonnull__(pTHX_2) 1113 __attribute__nonnull__(pTHX_3); 1114 #define PERL_ARGS_ASSERT_FBM_INSTR \ 1115 assert(big); assert(bigend); assert(littlestr) 1116 1117 PERL_CALLCONV bool Perl_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen) 1118 __attribute__nonnull__(pTHX_1); 1119 #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \ 1120 assert(name) 1121 1122 PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); 1123 PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp) 1124 __attribute__nonnull__(pTHX_1); 1125 #define PERL_ARGS_ASSERT_FILTER_DEL \ 1126 assert(funcp) 1127 1128 PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) 1129 __attribute__warn_unused_result__ 1130 __attribute__nonnull__(pTHX_2); 1131 #define PERL_ARGS_ASSERT_FILTER_READ \ 1132 assert(buf_sv) 1133 1134 PERL_CALLCONV void Perl_finalize_optree(pTHX_ OP* o) 1135 __attribute__nonnull__(pTHX_1); 1136 #define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ 1137 assert(o) 1138 1139 PERL_CALLCONV CV * Perl_find_lexical_cv(pTHX_ PADOFFSET off); 1140 PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) 1141 __attribute__warn_unused_result__; 1142 1143 PERL_CALLCONV CV* Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp) 1144 __attribute__warn_unused_result__; 1145 1146 PERL_CALLCONV SV* Perl_find_rundefsv(pTHX); 1147 PERL_CALLCONV SV* Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq) 1148 __attribute__nonnull__(pTHX_1); 1149 #define PERL_ARGS_ASSERT_FIND_RUNDEFSV2 \ 1150 assert(cv) 1151 1152 PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) 1153 __attribute__deprecated__; 1154 1155 PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags) 1156 __attribute__nonnull__(pTHX_1); 1157 #define PERL_ARGS_ASSERT_FIND_SCRIPT \ 1158 assert(scriptname) 1159 1160 PERL_CALLCONV I32 Perl_foldEQ(const char* a, const char* b, I32 len) 1161 __attribute__pure__ 1162 __attribute__nonnull__(1) 1163 __attribute__nonnull__(2); 1164 #define PERL_ARGS_ASSERT_FOLDEQ \ 1165 assert(a); assert(b) 1166 1167 PERL_CALLCONV I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len) 1168 __attribute__pure__ 1169 __attribute__nonnull__(1) 1170 __attribute__nonnull__(2); 1171 #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ 1172 assert(a); assert(b) 1173 1174 PERL_CALLCONV I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len) 1175 __attribute__pure__ 1176 __attribute__nonnull__(1) 1177 __attribute__nonnull__(2); 1178 #define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ 1179 assert(a); assert(b) 1180 1181 /* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) 1182 __attribute__nonnull__(pTHX_1) 1183 __attribute__nonnull__(pTHX_5); */ 1184 1185 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) 1186 __attribute__nonnull__(pTHX_1) 1187 __attribute__nonnull__(pTHX_5); 1188 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ 1189 assert(s1); assert(s2) 1190 1191 PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) 1192 __attribute__format__(__printf__,pTHX_1,pTHX_2) 1193 __attribute__nonnull__(pTHX_1); 1194 #define PERL_ARGS_ASSERT_FORM \ 1195 assert(pat) 1196 1197 PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); 1198 PERL_CALLCONV void Perl_free_tmps(pTHX); 1199 PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags) 1200 __attribute__nonnull__(pTHX_1); 1201 #define PERL_ARGS_ASSERT_GET_AV \ 1202 assert(name) 1203 1204 PERL_CALLCONV void* Perl_get_context(void) 1205 __attribute__warn_unused_result__; 1206 1207 PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags) 1208 __attribute__nonnull__(pTHX_1); 1209 #define PERL_ARGS_ASSERT_GET_CV \ 1210 assert(name) 1211 1212 PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags) 1213 __attribute__nonnull__(pTHX_1); 1214 #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ 1215 assert(name) 1216 1217 PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) 1218 __attribute__nonnull__(pTHX_2); 1219 #define PERL_ARGS_ASSERT_GET_DB_SUB \ 1220 assert(cv) 1221 1222 PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) 1223 __attribute__nonnull__(pTHX_1); 1224 #define PERL_ARGS_ASSERT_GET_HASH_SEED \ 1225 assert(seed_buffer) 1226 1227 PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags) 1228 __attribute__nonnull__(pTHX_1); 1229 #define PERL_ARGS_ASSERT_GET_HV \ 1230 assert(name) 1231 1232 PERL_CALLCONV const char* Perl_get_no_modify(pTHX) 1233 __attribute__warn_unused_result__ 1234 __attribute__pure__; 1235 1236 PERL_CALLCONV char** Perl_get_op_descs(pTHX) 1237 __attribute__warn_unused_result__ 1238 __attribute__pure__; 1239 1240 PERL_CALLCONV char** Perl_get_op_names(pTHX) 1241 __attribute__warn_unused_result__ 1242 __attribute__pure__; 1243 1244 PERL_CALLCONV U32* Perl_get_opargs(pTHX) 1245 __attribute__warn_unused_result__ 1246 __attribute__pure__; 1247 1248 PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) 1249 __attribute__warn_unused_result__ 1250 __attribute__pure__; 1251 1252 PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); 1253 PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags) 1254 __attribute__nonnull__(pTHX_1); 1255 #define PERL_ARGS_ASSERT_GET_SV \ 1256 assert(name) 1257 1258 PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) 1259 __attribute__warn_unused_result__; 1260 1261 PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv) 1262 __attribute__nonnull__(pTHX_1); 1263 #define PERL_ARGS_ASSERT_GETCWD_SV \ 1264 assert(sv) 1265 1266 PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); 1267 PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); 1268 PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1269 __attribute__nonnull__(pTHX_1) 1270 __attribute__nonnull__(pTHX_2) 1271 __attribute__nonnull__(pTHX_3); 1272 #define PERL_ARGS_ASSERT_GROK_BIN \ 1273 assert(start); assert(len_p); assert(flags) 1274 1275 PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1276 __attribute__nonnull__(pTHX_1) 1277 __attribute__nonnull__(pTHX_2) 1278 __attribute__nonnull__(pTHX_3); 1279 #define PERL_ARGS_ASSERT_GROK_HEX \ 1280 assert(start); assert(len_p); assert(flags) 1281 1282 PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) 1283 __attribute__nonnull__(pTHX_1); 1284 #define PERL_ARGS_ASSERT_GROK_NUMBER \ 1285 assert(pv) 1286 1287 PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) 1288 __attribute__warn_unused_result__ 1289 __attribute__nonnull__(pTHX_1) 1290 __attribute__nonnull__(pTHX_2); 1291 #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ 1292 assert(sp); assert(send) 1293 1294 PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1295 __attribute__nonnull__(pTHX_1) 1296 __attribute__nonnull__(pTHX_2) 1297 __attribute__nonnull__(pTHX_3); 1298 #define PERL_ARGS_ASSERT_GROK_OCT \ 1299 assert(start); assert(len_p); assert(flags) 1300 1301 /* PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); */ 1302 /* PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); */ 1303 /* PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); */ 1304 PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); 1305 /* PERL_CALLCONV GV* gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) 1306 __attribute__warn_unused_result__ 1307 __attribute__nonnull__(pTHX_2); */ 1308 1309 PERL_CALLCONV GV* Perl_gv_autoload_pv(pTHX_ HV* stash, const char* namepv, U32 flags) 1310 __attribute__warn_unused_result__ 1311 __attribute__nonnull__(pTHX_2); 1312 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ 1313 assert(namepv) 1314 1315 PERL_CALLCONV GV* Perl_gv_autoload_pvn(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags) 1316 __attribute__warn_unused_result__ 1317 __attribute__nonnull__(pTHX_2); 1318 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ 1319 assert(name) 1320 1321 PERL_CALLCONV GV* Perl_gv_autoload_sv(pTHX_ HV* stash, SV* namesv, U32 flags) 1322 __attribute__warn_unused_result__ 1323 __attribute__nonnull__(pTHX_2); 1324 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ 1325 assert(namesv) 1326 1327 PERL_CALLCONV void Perl_gv_check(pTHX_ HV* stash) 1328 __attribute__nonnull__(pTHX_1); 1329 #define PERL_ARGS_ASSERT_GV_CHECK \ 1330 assert(stash) 1331 1332 PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) 1333 __attribute__warn_unused_result__ 1334 __attribute__nonnull__(pTHX_1); 1335 #define PERL_ARGS_ASSERT_GV_CONST_SV \ 1336 assert(gv) 1337 1338 PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv) 1339 __attribute__nonnull__(pTHX_1); 1340 #define PERL_ARGS_ASSERT_GV_DUMP \ 1341 assert(gv) 1342 1343 PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) 1344 __attribute__nonnull__(pTHX_1) 1345 __attribute__nonnull__(pTHX_2); 1346 #define PERL_ARGS_ASSERT_GV_EFULLNAME \ 1347 assert(sv); assert(gv) 1348 1349 /* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) 1350 __attribute__nonnull__(pTHX_1) 1351 __attribute__nonnull__(pTHX_2); */ 1352 #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ 1353 assert(sv); assert(gv) 1354 1355 PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) 1356 __attribute__nonnull__(pTHX_1) 1357 __attribute__nonnull__(pTHX_2); 1358 #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ 1359 assert(sv); assert(gv) 1360 1361 PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name) 1362 __attribute__nonnull__(pTHX_1); 1363 #define PERL_ARGS_ASSERT_GV_FETCHFILE \ 1364 assert(name) 1365 1366 PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags) 1367 __attribute__nonnull__(pTHX_1); 1368 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ 1369 assert(name) 1370 1371 /* PERL_CALLCONV GV* gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) 1372 __attribute__nonnull__(pTHX_2); */ 1373 1374 /* PERL_CALLCONV GV* gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) 1375 __attribute__nonnull__(pTHX_2); */ 1376 1377 PERL_CALLCONV GV* Perl_gv_fetchmeth_pv(pTHX_ HV* stash, const char* name, I32 level, U32 flags) 1378 __attribute__nonnull__(pTHX_2); 1379 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ 1380 assert(name) 1381 1382 PERL_CALLCONV GV* Perl_gv_fetchmeth_pv_autoload(pTHX_ HV* stash, const char* name, I32 level, U32 flags) 1383 __attribute__nonnull__(pTHX_2); 1384 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ 1385 assert(name) 1386 1387 PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) 1388 __attribute__nonnull__(pTHX_2); 1389 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ 1390 assert(name) 1391 1392 PERL_CALLCONV GV* Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level, U32 flags) 1393 __attribute__nonnull__(pTHX_2); 1394 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ 1395 assert(name) 1396 1397 PERL_CALLCONV GV* Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) 1398 __attribute__nonnull__(pTHX_2); 1399 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ 1400 assert(namesv) 1401 1402 PERL_CALLCONV GV* Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags) 1403 __attribute__nonnull__(pTHX_2); 1404 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ 1405 assert(namesv) 1406 1407 /* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name) 1408 __attribute__nonnull__(pTHX_1) 1409 __attribute__nonnull__(pTHX_2); */ 1410 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ 1411 assert(stash); assert(name) 1412 1413 PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload) 1414 __attribute__nonnull__(pTHX_1) 1415 __attribute__nonnull__(pTHX_2); 1416 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ 1417 assert(stash); assert(name) 1418 1419 PERL_CALLCONV GV* Perl_gv_fetchmethod_pv_flags(pTHX_ HV* stash, const char* name, U32 flags) 1420 __attribute__nonnull__(pTHX_1) 1421 __attribute__nonnull__(pTHX_2); 1422 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ 1423 assert(stash); assert(name) 1424 1425 PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* name, const STRLEN len, U32 flags) 1426 __attribute__nonnull__(pTHX_1) 1427 __attribute__nonnull__(pTHX_2); 1428 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ 1429 assert(stash); assert(name) 1430 1431 PERL_CALLCONV GV* Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags) 1432 __attribute__nonnull__(pTHX_1) 1433 __attribute__nonnull__(pTHX_2); 1434 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ 1435 assert(stash); assert(namesv) 1436 1437 PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) 1438 __attribute__nonnull__(pTHX_1); 1439 #define PERL_ARGS_ASSERT_GV_FETCHPV \ 1440 assert(nambeg) 1441 1442 PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type) 1443 __attribute__nonnull__(pTHX_1); 1444 #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ 1445 assert(name) 1446 1447 PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) 1448 __attribute__nonnull__(pTHX_1); 1449 #define PERL_ARGS_ASSERT_GV_FETCHSV \ 1450 assert(name) 1451 1452 PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv) 1453 __attribute__nonnull__(pTHX_1) 1454 __attribute__nonnull__(pTHX_2); 1455 #define PERL_ARGS_ASSERT_GV_FULLNAME \ 1456 assert(sv); assert(gv) 1457 1458 /* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) 1459 __attribute__nonnull__(pTHX_1) 1460 __attribute__nonnull__(pTHX_2); */ 1461 #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ 1462 assert(sv); assert(gv) 1463 1464 PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) 1465 __attribute__nonnull__(pTHX_1) 1466 __attribute__nonnull__(pTHX_2); 1467 #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ 1468 assert(sv); assert(gv) 1469 1470 PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) 1471 __attribute__warn_unused_result__; 1472 1473 /* PERL_CALLCONV void gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi) 1474 __attribute__nonnull__(pTHX_1) 1475 __attribute__nonnull__(pTHX_3); */ 1476 1477 PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV* gv, HV* stash, const char* name, U32 flags) 1478 __attribute__nonnull__(pTHX_1) 1479 __attribute__nonnull__(pTHX_3); 1480 #define PERL_ARGS_ASSERT_GV_INIT_PV \ 1481 assert(gv); assert(name) 1482 1483 PERL_CALLCONV void Perl_gv_init_pvn(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, U32 flags) 1484 __attribute__nonnull__(pTHX_1) 1485 __attribute__nonnull__(pTHX_3); 1486 #define PERL_ARGS_ASSERT_GV_INIT_PVN \ 1487 assert(gv); assert(name) 1488 1489 PERL_CALLCONV void Perl_gv_init_sv(pTHX_ GV* gv, HV* stash, SV* namesv, U32 flags) 1490 __attribute__nonnull__(pTHX_1) 1491 __attribute__nonnull__(pTHX_3); 1492 #define PERL_ARGS_ASSERT_GV_INIT_SV \ 1493 assert(gv); assert(namesv) 1494 1495 PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags) 1496 __attribute__nonnull__(pTHX_1) 1497 __attribute__nonnull__(pTHX_2); 1498 #define PERL_ARGS_ASSERT_GV_NAME_SET \ 1499 assert(gv); assert(name) 1500 1501 PERL_CALLCONV GV * Perl_gv_override(pTHX_ const char * const name, const STRLEN len) 1502 __attribute__nonnull__(pTHX_1); 1503 #define PERL_ARGS_ASSERT_GV_OVERRIDE \ 1504 assert(name) 1505 1506 PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags) 1507 __attribute__nonnull__(pTHX_1); 1508 #define PERL_ARGS_ASSERT_GV_STASHPV \ 1509 assert(name) 1510 1511 PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags) 1512 __attribute__nonnull__(pTHX_1); 1513 #define PERL_ARGS_ASSERT_GV_STASHPVN \ 1514 assert(name) 1515 1516 PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags) 1517 __attribute__nonnull__(pTHX_1); 1518 #define PERL_ARGS_ASSERT_GV_STASHSV \ 1519 assert(sv) 1520 1521 PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv) 1522 __attribute__nonnull__(pTHX_1); 1523 #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ 1524 assert(gv) 1525 1526 PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv) 1527 __attribute__nonnull__(pTHX_1); 1528 #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ 1529 assert(hv) 1530 1531 PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); 1532 PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv) 1533 __attribute__nonnull__(pTHX_1); 1534 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ 1535 assert(hv) 1536 1537 PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); 1538 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) 1539 __attribute__nonnull__(pTHX_2); 1540 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ 1541 assert(key) 1542 1543 PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv) 1544 __attribute__warn_unused_result__; 1545 1546 PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry) 1547 __attribute__nonnull__(pTHX_1); 1548 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ 1549 assert(hv) 1550 1551 /* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) 1552 __attribute__nonnull__(pTHX_2); */ 1553 #define PERL_ARGS_ASSERT_HV_DELETE \ 1554 assert(key) 1555 1556 /* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) 1557 __attribute__nonnull__(pTHX_2); */ 1558 #define PERL_ARGS_ASSERT_HV_DELETE_ENT \ 1559 assert(keysv) 1560 1561 PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv) 1562 __attribute__warn_unused_result__ 1563 __attribute__nonnull__(pTHX_1); 1564 #define PERL_ARGS_ASSERT_HV_EITER_P \ 1565 assert(hv) 1566 1567 PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) 1568 __attribute__nonnull__(pTHX_1); 1569 #define PERL_ARGS_ASSERT_HV_EITER_SET \ 1570 assert(hv) 1571 1572 PERL_CALLCONV void Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 1573 __attribute__nonnull__(pTHX_1) 1574 __attribute__nonnull__(pTHX_2); 1575 #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ 1576 assert(hv); assert(name) 1577 1578 PERL_CALLCONV void Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 1579 __attribute__nonnull__(pTHX_1) 1580 __attribute__nonnull__(pTHX_2); 1581 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ 1582 assert(hv); assert(name) 1583 1584 /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) 1585 __attribute__warn_unused_result__ 1586 __attribute__nonnull__(pTHX_2); */ 1587 #define PERL_ARGS_ASSERT_HV_EXISTS \ 1588 assert(key) 1589 1590 /* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) 1591 __attribute__warn_unused_result__ 1592 __attribute__nonnull__(pTHX_2); */ 1593 #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ 1594 assert(keysv) 1595 1596 /* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) 1597 __attribute__nonnull__(pTHX_2); */ 1598 #define PERL_ARGS_ASSERT_HV_FETCH \ 1599 assert(key) 1600 1601 /* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) 1602 __attribute__nonnull__(pTHX_2); */ 1603 #define PERL_ARGS_ASSERT_HV_FETCH_ENT \ 1604 assert(keysv) 1605 1606 PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV *const hv) 1607 __attribute__nonnull__(pTHX_1); 1608 #define PERL_ARGS_ASSERT_HV_FILL \ 1609 assert(hv) 1610 1611 PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entry) 1612 __attribute__nonnull__(pTHX_1); 1613 #define PERL_ARGS_ASSERT_HV_FREE_ENT \ 1614 assert(hv) 1615 1616 PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv) 1617 __attribute__nonnull__(pTHX_1); 1618 #define PERL_ARGS_ASSERT_HV_ITERINIT \ 1619 assert(hv) 1620 1621 PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen) 1622 __attribute__warn_unused_result__ 1623 __attribute__nonnull__(pTHX_1) 1624 __attribute__nonnull__(pTHX_2); 1625 #define PERL_ARGS_ASSERT_HV_ITERKEY \ 1626 assert(entry); assert(retlen) 1627 1628 PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry) 1629 __attribute__warn_unused_result__ 1630 __attribute__nonnull__(pTHX_1); 1631 #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ 1632 assert(entry) 1633 1634 /* PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv) 1635 __attribute__warn_unused_result__ 1636 __attribute__nonnull__(pTHX_1); */ 1637 #define PERL_ARGS_ASSERT_HV_ITERNEXT \ 1638 assert(hv) 1639 1640 PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) 1641 __attribute__warn_unused_result__ 1642 __attribute__nonnull__(pTHX_1); 1643 #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ 1644 assert(hv) 1645 1646 PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) 1647 __attribute__warn_unused_result__ 1648 __attribute__nonnull__(pTHX_1) 1649 __attribute__nonnull__(pTHX_2) 1650 __attribute__nonnull__(pTHX_3); 1651 #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ 1652 assert(hv); assert(key); assert(retlen) 1653 1654 PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV *hv, HE *entry) 1655 __attribute__warn_unused_result__ 1656 __attribute__nonnull__(pTHX_1) 1657 __attribute__nonnull__(pTHX_2); 1658 #define PERL_ARGS_ASSERT_HV_ITERVAL \ 1659 assert(hv); assert(entry) 1660 1661 PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) 1662 __attribute__nonnull__(pTHX_1); 1663 #define PERL_ARGS_ASSERT_HV_KSPLIT \ 1664 assert(hv) 1665 1666 /* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) 1667 __attribute__nonnull__(pTHX_1); */ 1668 #define PERL_ARGS_ASSERT_HV_MAGIC \ 1669 assert(hv) 1670 1671 PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 1672 __attribute__nonnull__(pTHX_1); 1673 #define PERL_ARGS_ASSERT_HV_NAME_SET \ 1674 assert(hv) 1675 1676 PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) 1677 __attribute__warn_unused_result__ 1678 __attribute__nonnull__(pTHX_1); 1679 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ 1680 assert(hv) 1681 1682 PERL_CALLCONV SSize_t* Perl_hv_placeholders_p(pTHX_ HV *hv) 1683 __attribute__warn_unused_result__ 1684 __attribute__nonnull__(pTHX_1); 1685 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ 1686 assert(hv) 1687 1688 PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) 1689 __attribute__nonnull__(pTHX_1); 1690 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ 1691 assert(hv) 1692 1693 PERL_CALLCONV void Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand) 1694 __attribute__nonnull__(pTHX_1); 1695 #define PERL_ARGS_ASSERT_HV_RAND_SET \ 1696 assert(hv) 1697 1698 PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv) 1699 __attribute__warn_unused_result__ 1700 __attribute__nonnull__(pTHX_1); 1701 #define PERL_ARGS_ASSERT_HV_RITER_P \ 1702 assert(hv) 1703 1704 PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter) 1705 __attribute__nonnull__(pTHX_1); 1706 #define PERL_ARGS_ASSERT_HV_RITER_SET \ 1707 assert(hv) 1708 1709 PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv) 1710 __attribute__warn_unused_result__ 1711 __attribute__nonnull__(pTHX_1); 1712 #define PERL_ARGS_ASSERT_HV_SCALAR \ 1713 assert(hv) 1714 1715 /* PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ 1716 /* PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ 1717 /* PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ 1718 /* PERL_CALLCONV void hv_undef(pTHX_ HV *hv); */ 1719 PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); 1720 /* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len) 1721 __attribute__nonnull__(pTHX_1) 1722 __attribute__nonnull__(pTHX_2); */ 1723 1724 /* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len) 1725 __attribute__nonnull__(pTHX_1) 1726 __attribute__nonnull__(pTHX_2); */ 1727 1728 /* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) 1729 __attribute__nonnull__(pTHX_1) 1730 __attribute__nonnull__(pTHX_5); */ 1731 1732 PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) 1733 __attribute__nonnull__(pTHX_2); 1734 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ 1735 assert(argv) 1736 1737 PERL_CALLCONV void Perl_init_constants(pTHX); 1738 PERL_CALLCONV void Perl_init_dbargs(pTHX); 1739 PERL_CALLCONV void Perl_init_debugger(pTHX); 1740 PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); 1741 PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn); 1742 PERL_CALLCONV void Perl_init_stacks(pTHX); 1743 PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm) 1744 __attribute__nonnull__(pTHX_1); 1745 #define PERL_ARGS_ASSERT_INIT_TM \ 1746 assert(ptm) 1747 1748 PERL_CALLCONV char* Perl_instr(const char* big, const char* little) 1749 __attribute__warn_unused_result__ 1750 __attribute__pure__ 1751 __attribute__nonnull__(1) 1752 __attribute__nonnull__(2); 1753 #define PERL_ARGS_ASSERT_INSTR \ 1754 assert(big); assert(little) 1755 1756 PERL_CALLCONV U32 Perl_intro_my(pTHX); 1757 PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) 1758 __attribute__warn_unused_result__; 1759 1760 PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit) 1761 __attribute__nonnull__(pTHX_1); 1762 #define PERL_ARGS_ASSERT_IO_CLOSE \ 1763 assert(io) 1764 1765 PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p) 1766 __attribute__deprecated__ 1767 __attribute__warn_unused_result__ 1768 __attribute__pure__ 1769 __attribute__nonnull__(pTHX_1); 1770 #define PERL_ARGS_ASSERT_ISALNUM_LAZY \ 1771 assert(p) 1772 1773 PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p) 1774 __attribute__deprecated__ 1775 __attribute__warn_unused_result__ 1776 __attribute__pure__ 1777 __attribute__nonnull__(pTHX_1); 1778 #define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \ 1779 assert(p) 1780 1781 PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len) 1782 __attribute__nonnull__(1); 1783 #define PERL_ARGS_ASSERT_IS_ASCII_STRING \ 1784 assert(s) 1785 1786 PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) 1787 __attribute__warn_unused_result__; 1788 1789 PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) 1790 __attribute__warn_unused_result__ 1791 __attribute__nonnull__(pTHX_1) 1792 __attribute__nonnull__(pTHX_3) 1793 __attribute__nonnull__(pTHX_4); 1794 #define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ 1795 assert(pv); assert(what); assert(op_name) 1796 1797 PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) 1798 __attribute__deprecated__ 1799 __attribute__warn_unused_result__ 1800 __attribute__pure__; 1801 1802 PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) 1803 __attribute__deprecated__ 1804 __attribute__warn_unused_result__ 1805 __attribute__pure__; 1806 1807 PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c) 1808 __attribute__deprecated__ 1809 __attribute__warn_unused_result__ 1810 __attribute__pure__; 1811 1812 PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c) 1813 __attribute__deprecated__ 1814 __attribute__warn_unused_result__ 1815 __attribute__pure__; 1816 1817 PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) 1818 __attribute__deprecated__ 1819 __attribute__warn_unused_result__ 1820 __attribute__pure__; 1821 1822 PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) 1823 __attribute__deprecated__ 1824 __attribute__warn_unused_result__ 1825 __attribute__pure__; 1826 1827 PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) 1828 __attribute__deprecated__ 1829 __attribute__warn_unused_result__ 1830 __attribute__pure__; 1831 1832 PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) 1833 __attribute__deprecated__ 1834 __attribute__warn_unused_result__ 1835 __attribute__pure__; 1836 1837 PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c) 1838 __attribute__deprecated__ 1839 __attribute__warn_unused_result__ 1840 __attribute__pure__; 1841 1842 PERL_CALLCONV bool Perl_is_uni_blank_lc(pTHX_ UV c) 1843 __attribute__deprecated__ 1844 __attribute__warn_unused_result__ 1845 __attribute__pure__; 1846 1847 PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) 1848 __attribute__deprecated__ 1849 __attribute__warn_unused_result__ 1850 __attribute__pure__; 1851 1852 PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) 1853 __attribute__deprecated__ 1854 __attribute__warn_unused_result__ 1855 __attribute__pure__; 1856 1857 PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) 1858 __attribute__deprecated__ 1859 __attribute__warn_unused_result__ 1860 __attribute__pure__; 1861 1862 PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) 1863 __attribute__deprecated__ 1864 __attribute__warn_unused_result__ 1865 __attribute__pure__; 1866 1867 PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) 1868 __attribute__deprecated__ 1869 __attribute__warn_unused_result__ 1870 __attribute__pure__; 1871 1872 PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) 1873 __attribute__deprecated__ 1874 __attribute__warn_unused_result__ 1875 __attribute__pure__; 1876 1877 PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) 1878 __attribute__deprecated__ 1879 __attribute__warn_unused_result__ 1880 __attribute__pure__; 1881 1882 PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) 1883 __attribute__deprecated__ 1884 __attribute__warn_unused_result__ 1885 __attribute__pure__; 1886 1887 PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) 1888 __attribute__deprecated__ 1889 __attribute__warn_unused_result__ 1890 __attribute__pure__; 1891 1892 PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) 1893 __attribute__deprecated__ 1894 __attribute__warn_unused_result__ 1895 __attribute__pure__; 1896 1897 PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) 1898 __attribute__deprecated__ 1899 __attribute__warn_unused_result__ 1900 __attribute__pure__; 1901 1902 PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) 1903 __attribute__deprecated__ 1904 __attribute__warn_unused_result__ 1905 __attribute__pure__; 1906 1907 PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) 1908 __attribute__deprecated__ 1909 __attribute__warn_unused_result__ 1910 __attribute__pure__; 1911 1912 PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) 1913 __attribute__deprecated__ 1914 __attribute__warn_unused_result__ 1915 __attribute__pure__; 1916 1917 PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) 1918 __attribute__deprecated__ 1919 __attribute__warn_unused_result__ 1920 __attribute__pure__; 1921 1922 PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) 1923 __attribute__deprecated__ 1924 __attribute__warn_unused_result__ 1925 __attribute__pure__; 1926 1927 PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) 1928 __attribute__deprecated__ 1929 __attribute__warn_unused_result__ 1930 __attribute__pure__; 1931 1932 PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) 1933 __attribute__deprecated__ 1934 __attribute__warn_unused_result__ 1935 __attribute__pure__; 1936 1937 PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) 1938 __attribute__deprecated__ 1939 __attribute__warn_unused_result__ 1940 __attribute__pure__; 1941 1942 PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) 1943 __attribute__deprecated__ 1944 __attribute__warn_unused_result__ 1945 __attribute__pure__; 1946 1947 PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) 1948 __attribute__deprecated__ 1949 __attribute__warn_unused_result__ 1950 __attribute__nonnull__(pTHX_1); 1951 #define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ 1952 assert(p) 1953 1954 PERL_CALLCONV bool Perl_is_utf8_alnumc(pTHX_ const U8 *p) 1955 __attribute__deprecated__ 1956 __attribute__warn_unused_result__ 1957 __attribute__nonnull__(pTHX_1); 1958 #define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC \ 1959 assert(p) 1960 1961 PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p) 1962 __attribute__deprecated__ 1963 __attribute__warn_unused_result__ 1964 __attribute__nonnull__(pTHX_1); 1965 #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \ 1966 assert(p) 1967 1968 PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p) 1969 __attribute__deprecated__ 1970 __attribute__warn_unused_result__ 1971 __attribute__nonnull__(pTHX_1); 1972 #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \ 1973 assert(p) 1974 1975 PERL_CALLCONV bool Perl_is_utf8_blank(pTHX_ const U8 *p) 1976 __attribute__deprecated__ 1977 __attribute__warn_unused_result__ 1978 __attribute__nonnull__(pTHX_1); 1979 #define PERL_ARGS_ASSERT_IS_UTF8_BLANK \ 1980 assert(p) 1981 1982 PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) 1983 __attribute__deprecated__ 1984 __attribute__nonnull__(1); 1985 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR \ 1986 assert(s) 1987 1988 PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end) 1989 __attribute__nonnull__(1) 1990 __attribute__nonnull__(2); 1991 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ 1992 assert(buf); assert(buf_end) 1993 1994 PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) 1995 __attribute__deprecated__ 1996 __attribute__warn_unused_result__ 1997 __attribute__nonnull__(pTHX_1); 1998 #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \ 1999 assert(p) 2000 2001 PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) 2002 __attribute__deprecated__ 2003 __attribute__warn_unused_result__ 2004 __attribute__nonnull__(pTHX_1); 2005 #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \ 2006 assert(p) 2007 2008 PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) 2009 __attribute__deprecated__ 2010 __attribute__warn_unused_result__ 2011 __attribute__nonnull__(pTHX_1); 2012 #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \ 2013 assert(p) 2014 2015 PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p) 2016 __attribute__deprecated__ 2017 __attribute__warn_unused_result__ 2018 __attribute__nonnull__(pTHX_1); 2019 #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \ 2020 assert(p) 2021 2022 PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) 2023 __attribute__deprecated__ 2024 __attribute__warn_unused_result__ 2025 __attribute__nonnull__(pTHX_1); 2026 #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ 2027 assert(p) 2028 2029 PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) 2030 __attribute__deprecated__ 2031 __attribute__warn_unused_result__ 2032 __attribute__nonnull__(pTHX_1); 2033 #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \ 2034 assert(p) 2035 2036 PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p) 2037 __attribute__deprecated__ 2038 __attribute__warn_unused_result__ 2039 __attribute__nonnull__(pTHX_1); 2040 #define PERL_ARGS_ASSERT_IS_UTF8_MARK \ 2041 assert(p) 2042 2043 PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p) 2044 __attribute__deprecated__ 2045 __attribute__warn_unused_result__ 2046 __attribute__nonnull__(pTHX_1); 2047 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \ 2048 assert(p) 2049 2050 PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p) 2051 __attribute__deprecated__ 2052 __attribute__warn_unused_result__ 2053 __attribute__nonnull__(pTHX_1); 2054 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \ 2055 assert(p) 2056 2057 PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p) 2058 __attribute__deprecated__ 2059 __attribute__warn_unused_result__ 2060 __attribute__nonnull__(pTHX_1); 2061 #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \ 2062 assert(p) 2063 2064 PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p) 2065 __attribute__deprecated__ 2066 __attribute__warn_unused_result__ 2067 __attribute__nonnull__(pTHX_1); 2068 #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \ 2069 assert(p) 2070 2071 PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p) 2072 __attribute__deprecated__ 2073 __attribute__warn_unused_result__ 2074 __attribute__nonnull__(pTHX_1); 2075 #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \ 2076 assert(p) 2077 2078 PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) 2079 __attribute__deprecated__ 2080 __attribute__warn_unused_result__ 2081 __attribute__nonnull__(pTHX_1); 2082 #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ 2083 assert(p) 2084 2085 PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) 2086 __attribute__nonnull__(1); 2087 #define PERL_ARGS_ASSERT_IS_UTF8_STRING \ 2088 assert(s) 2089 2090 /* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep) 2091 __attribute__nonnull__(1); */ 2092 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ 2093 assert(s) 2094 2095 PERL_CALLCONV bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) 2096 __attribute__nonnull__(1); 2097 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ 2098 assert(s) 2099 2100 PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) 2101 __attribute__deprecated__ 2102 __attribute__warn_unused_result__ 2103 __attribute__nonnull__(pTHX_1); 2104 #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \ 2105 assert(p) 2106 2107 PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) 2108 __attribute__deprecated__ 2109 __attribute__warn_unused_result__ 2110 __attribute__nonnull__(pTHX_1); 2111 #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \ 2112 assert(p) 2113 2114 PERL_CALLCONV bool Perl_is_utf8_xidcont(pTHX_ const U8 *p) 2115 __attribute__deprecated__ 2116 __attribute__warn_unused_result__ 2117 __attribute__nonnull__(pTHX_1); 2118 #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT \ 2119 assert(p) 2120 2121 PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) 2122 __attribute__deprecated__ 2123 __attribute__warn_unused_result__ 2124 __attribute__nonnull__(pTHX_1); 2125 #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \ 2126 assert(p) 2127 2128 PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o) 2129 __attribute__nonnull__(pTHX_1); 2130 #define PERL_ARGS_ASSERT_JMAYBE \ 2131 assert(o) 2132 2133 PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) 2134 __attribute__pure__ 2135 __attribute__nonnull__(pTHX_1); 2136 #define PERL_ARGS_ASSERT_KEYWORD \ 2137 assert(name) 2138 2139 PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr) 2140 __attribute__nonnull__(pTHX_1) 2141 __attribute__nonnull__(pTHX_3); 2142 #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ 2143 assert(keyword_ptr); assert(op_ptr) 2144 2145 PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); 2146 PERL_CALLCONV bool Perl_lex_bufutf8(pTHX); 2147 PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr) 2148 __attribute__nonnull__(pTHX_1); 2149 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ 2150 assert(ptr) 2151 2152 PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len); 2153 PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags); 2154 PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags); 2155 PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags); 2156 PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr) 2157 __attribute__nonnull__(pTHX_1); 2158 #define PERL_ARGS_ASSERT_LEX_READ_TO \ 2159 assert(ptr) 2160 2161 PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); 2162 PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, U32 flags); 2163 PERL_CALLCONV void Perl_lex_stuff_pv(pTHX_ const char* pv, U32 flags) 2164 __attribute__nonnull__(pTHX_1); 2165 #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ 2166 assert(pv) 2167 2168 PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ const char* pv, STRLEN len, U32 flags) 2169 __attribute__nonnull__(pTHX_1); 2170 #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ 2171 assert(pv) 2172 2173 PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags) 2174 __attribute__nonnull__(pTHX_1); 2175 #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ 2176 assert(sv) 2177 2178 PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr) 2179 __attribute__nonnull__(pTHX_1); 2180 #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ 2181 assert(ptr) 2182 2183 PERL_CALLCONV OP* Perl_list(pTHX_ OP* o); 2184 PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...) 2185 __attribute__nonnull__(pTHX_2); 2186 #define PERL_ARGS_ASSERT_LOAD_MODULE \ 2187 assert(name) 2188 2189 PERL_CALLCONV OP* Perl_localize(pTHX_ OP *o, I32 lex) 2190 __attribute__nonnull__(pTHX_1); 2191 #define PERL_ARGS_ASSERT_LOCALIZE \ 2192 assert(o) 2193 2194 PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV *const sv) 2195 __attribute__warn_unused_result__ 2196 __attribute__nonnull__(pTHX_1); 2197 #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ 2198 assert(sv) 2199 2200 PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg) 2201 __attribute__nonnull__(pTHX_1) 2202 __attribute__nonnull__(pTHX_2); 2203 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ 2204 assert(sv); assert(mg) 2205 2206 PERL_CALLCONV int Perl_magic_cleararylen_p(pTHX_ SV* sv, MAGIC* mg) 2207 __attribute__nonnull__(pTHX_1) 2208 __attribute__nonnull__(pTHX_2); 2209 #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ 2210 assert(sv); assert(mg) 2211 2212 PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg) 2213 __attribute__nonnull__(pTHX_1) 2214 __attribute__nonnull__(pTHX_2); 2215 #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ 2216 assert(sv); assert(mg) 2217 2218 PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg) 2219 __attribute__nonnull__(pTHX_1) 2220 __attribute__nonnull__(pTHX_2); 2221 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ 2222 assert(sv); assert(mg) 2223 2224 PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg) 2225 __attribute__nonnull__(pTHX_1) 2226 __attribute__nonnull__(pTHX_2); 2227 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ 2228 assert(sv); assert(mg) 2229 2230 PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg) 2231 __attribute__nonnull__(pTHX_2); 2232 #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ 2233 assert(mg) 2234 2235 PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg) 2236 __attribute__nonnull__(pTHX_1) 2237 __attribute__nonnull__(pTHX_2); 2238 #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ 2239 assert(sv); assert(mg) 2240 2241 PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg) 2242 __attribute__nonnull__(pTHX_1) 2243 __attribute__nonnull__(pTHX_2); 2244 #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ 2245 assert(sv); assert(mg) 2246 2247 PERL_CALLCONV int Perl_magic_copycallchecker(pTHX_ SV* sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) 2248 __attribute__nonnull__(pTHX_1) 2249 __attribute__nonnull__(pTHX_2) 2250 __attribute__nonnull__(pTHX_3); 2251 #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ 2252 assert(sv); assert(mg); assert(nsv) 2253 2254 PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); 2255 PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg) 2256 __attribute__nonnull__(pTHX_1) 2257 __attribute__nonnull__(pTHX_2); 2258 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ 2259 assert(sv); assert(mg) 2260 2261 PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg) 2262 __attribute__nonnull__(pTHX_1) 2263 __attribute__nonnull__(pTHX_2); 2264 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ 2265 assert(sv); assert(mg) 2266 2267 PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg) 2268 __attribute__nonnull__(pTHX_1) 2269 __attribute__nonnull__(pTHX_2); 2270 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ 2271 assert(sv); assert(mg) 2272 2273 PERL_CALLCONV int Perl_magic_get(pTHX_ SV* sv, MAGIC* mg) 2274 __attribute__nonnull__(pTHX_1) 2275 __attribute__nonnull__(pTHX_2); 2276 #define PERL_ARGS_ASSERT_MAGIC_GET \ 2277 assert(sv); assert(mg) 2278 2279 PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV* sv, const MAGIC* mg) 2280 __attribute__nonnull__(pTHX_1) 2281 __attribute__nonnull__(pTHX_2); 2282 #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ 2283 assert(sv); assert(mg) 2284 2285 PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg) 2286 __attribute__nonnull__(pTHX_1) 2287 __attribute__nonnull__(pTHX_2); 2288 #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ 2289 assert(sv); assert(mg) 2290 2291 PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV* sv, MAGIC* mg) 2292 __attribute__nonnull__(pTHX_1) 2293 __attribute__nonnull__(pTHX_2); 2294 #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ 2295 assert(sv); assert(mg) 2296 2297 PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV* sv, MAGIC* mg) 2298 __attribute__nonnull__(pTHX_1) 2299 __attribute__nonnull__(pTHX_2); 2300 #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ 2301 assert(sv); assert(mg) 2302 2303 PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV* sv, MAGIC* mg) 2304 __attribute__nonnull__(pTHX_1) 2305 __attribute__nonnull__(pTHX_2); 2306 #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ 2307 assert(sv); assert(mg) 2308 2309 PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV* sv, MAGIC* mg) 2310 __attribute__nonnull__(pTHX_1) 2311 __attribute__nonnull__(pTHX_2); 2312 #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ 2313 assert(sv); assert(mg) 2314 2315 PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV* sv, MAGIC* mg) 2316 __attribute__nonnull__(pTHX_1) 2317 __attribute__nonnull__(pTHX_2); 2318 #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ 2319 assert(sv); assert(mg) 2320 2321 PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV* sv, MAGIC* mg) 2322 __attribute__nonnull__(pTHX_1) 2323 __attribute__nonnull__(pTHX_2); 2324 #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ 2325 assert(sv); assert(mg) 2326 2327 PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV* sv, MAGIC* mg) 2328 __attribute__nonnull__(pTHX_1) 2329 __attribute__nonnull__(pTHX_2); 2330 #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ 2331 assert(sv); assert(mg) 2332 2333 PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV* sv, MAGIC* mg) 2334 __attribute__nonnull__(pTHX_1) 2335 __attribute__nonnull__(pTHX_2); 2336 #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ 2337 assert(sv); assert(mg) 2338 2339 PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) 2340 __attribute__nonnull__(pTHX_1) 2341 __attribute__nonnull__(pTHX_2); 2342 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ 2343 assert(sv); assert(mg) 2344 2345 PERL_CALLCONV SV* Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...) 2346 __attribute__nonnull__(pTHX_1) 2347 __attribute__nonnull__(pTHX_2) 2348 __attribute__nonnull__(pTHX_3); 2349 #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ 2350 assert(sv); assert(mg); assert(meth) 2351 2352 PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) 2353 __attribute__nonnull__(pTHX_1) 2354 __attribute__nonnull__(pTHX_2) 2355 __attribute__nonnull__(pTHX_3); 2356 #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ 2357 assert(sv); assert(mg); assert(key) 2358 2359 PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV* sv, MAGIC* mg) 2360 __attribute__nonnull__(pTHX_1) 2361 __attribute__nonnull__(pTHX_2); 2362 #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ 2363 assert(sv); assert(mg) 2364 2365 PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg) 2366 __attribute__nonnull__(pTHX_1) 2367 __attribute__nonnull__(pTHX_2); 2368 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ 2369 assert(sv); assert(mg) 2370 2371 PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) 2372 __attribute__nonnull__(pTHX_1) 2373 __attribute__nonnull__(pTHX_2); 2374 #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ 2375 assert(hv); assert(mg) 2376 2377 PERL_CALLCONV int Perl_magic_set(pTHX_ SV* sv, MAGIC* mg) 2378 __attribute__nonnull__(pTHX_1) 2379 __attribute__nonnull__(pTHX_2); 2380 #define PERL_ARGS_ASSERT_MAGIC_SET \ 2381 assert(sv); assert(mg) 2382 2383 PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg) 2384 __attribute__nonnull__(pTHX_1) 2385 __attribute__nonnull__(pTHX_2); 2386 #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ 2387 assert(sv); assert(mg) 2388 2389 PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg) 2390 __attribute__nonnull__(pTHX_1) 2391 __attribute__nonnull__(pTHX_2); 2392 #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ 2393 assert(sv); assert(mg) 2394 2395 PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV* sv, MAGIC* mg) 2396 __attribute__nonnull__(pTHX_1) 2397 __attribute__nonnull__(pTHX_2); 2398 #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ 2399 assert(sv); assert(mg) 2400 2401 PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg) 2402 __attribute__nonnull__(pTHX_1) 2403 __attribute__nonnull__(pTHX_2); 2404 #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ 2405 assert(sv); assert(mg) 2406 2407 PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV* sv, MAGIC* mg) 2408 __attribute__nonnull__(pTHX_1) 2409 __attribute__nonnull__(pTHX_2); 2410 #define PERL_ARGS_ASSERT_MAGIC_SETENV \ 2411 assert(sv); assert(mg) 2412 2413 PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV* sv, MAGIC* mg) 2414 __attribute__nonnull__(pTHX_1) 2415 __attribute__nonnull__(pTHX_2); 2416 #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ 2417 assert(sv); assert(mg) 2418 2419 PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV* sv, MAGIC* mg) 2420 __attribute__nonnull__(pTHX_1) 2421 __attribute__nonnull__(pTHX_2); 2422 #define PERL_ARGS_ASSERT_MAGIC_SETISA \ 2423 assert(sv); assert(mg) 2424 2425 PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg) 2426 __attribute__nonnull__(pTHX_1) 2427 __attribute__nonnull__(pTHX_2); 2428 #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ 2429 assert(sv); assert(mg) 2430 2431 PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg) 2432 __attribute__nonnull__(pTHX_1) 2433 __attribute__nonnull__(pTHX_2); 2434 #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ 2435 assert(sv); assert(mg) 2436 2437 PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg) 2438 __attribute__nonnull__(pTHX_1) 2439 __attribute__nonnull__(pTHX_2); 2440 #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ 2441 assert(sv); assert(mg) 2442 2443 PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV* sv, MAGIC* mg) 2444 __attribute__nonnull__(pTHX_1) 2445 __attribute__nonnull__(pTHX_2); 2446 #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ 2447 assert(sv); assert(mg) 2448 2449 PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg) 2450 __attribute__nonnull__(pTHX_1) 2451 __attribute__nonnull__(pTHX_2); 2452 #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ 2453 assert(sv); assert(mg) 2454 2455 PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg) 2456 __attribute__nonnull__(pTHX_2); 2457 #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ 2458 assert(mg) 2459 2460 PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg) 2461 __attribute__nonnull__(pTHX_1) 2462 __attribute__nonnull__(pTHX_2); 2463 #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ 2464 assert(sv); assert(mg) 2465 2466 PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV* sv, MAGIC* mg) 2467 __attribute__nonnull__(pTHX_1) 2468 __attribute__nonnull__(pTHX_2); 2469 #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ 2470 assert(sv); assert(mg) 2471 2472 PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV* sv, MAGIC* mg) 2473 __attribute__nonnull__(pTHX_1) 2474 __attribute__nonnull__(pTHX_2); 2475 #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ 2476 assert(sv); assert(mg) 2477 2478 PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV* sv, MAGIC* mg) 2479 __attribute__nonnull__(pTHX_1) 2480 __attribute__nonnull__(pTHX_2); 2481 #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ 2482 assert(sv); assert(mg) 2483 2484 PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg) 2485 __attribute__nonnull__(pTHX_1) 2486 __attribute__nonnull__(pTHX_2); 2487 #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ 2488 assert(sv); assert(mg) 2489 2490 PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg) 2491 __attribute__nonnull__(pTHX_1) 2492 __attribute__nonnull__(pTHX_2); 2493 #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ 2494 assert(sv); assert(mg) 2495 2496 PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg) 2497 __attribute__nonnull__(pTHX_1) 2498 __attribute__nonnull__(pTHX_2); 2499 #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ 2500 assert(sv); assert(mg) 2501 2502 PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) 2503 __attribute__malloc__ 2504 __attribute__warn_unused_result__; 2505 2506 PERL_CALLCONV void Perl_markstack_grow(pTHX); 2507 PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) 2508 __attribute__format__(__printf__,pTHX_1,pTHX_2) 2509 __attribute__nonnull__(pTHX_1); 2510 #define PERL_ARGS_ASSERT_MESS \ 2511 assert(pat) 2512 2513 PERL_CALLCONV SV* Perl_mess_sv(pTHX_ SV* basemsg, bool consume) 2514 __attribute__nonnull__(pTHX_1); 2515 #define PERL_ARGS_ASSERT_MESS_SV \ 2516 assert(basemsg) 2517 2518 PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); 2519 PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv) 2520 __attribute__nonnull__(pTHX_1); 2521 #define PERL_ARGS_ASSERT_MG_CLEAR \ 2522 assert(sv) 2523 2524 PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) 2525 __attribute__nonnull__(pTHX_1) 2526 __attribute__nonnull__(pTHX_2); 2527 #define PERL_ARGS_ASSERT_MG_COPY \ 2528 assert(sv); assert(nsv) 2529 2530 PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type) 2531 __attribute__warn_unused_result__; 2532 2533 PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) 2534 __attribute__warn_unused_result__ 2535 __attribute__nonnull__(pTHX_1); 2536 #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \ 2537 assert(sv) 2538 2539 PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl) 2540 __attribute__warn_unused_result__; 2541 2542 PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv) 2543 __attribute__nonnull__(pTHX_1); 2544 #define PERL_ARGS_ASSERT_MG_FREE \ 2545 assert(sv) 2546 2547 PERL_CALLCONV void Perl_mg_free_type(pTHX_ SV* sv, int how) 2548 __attribute__nonnull__(pTHX_1); 2549 #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ 2550 assert(sv) 2551 2552 PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv) 2553 __attribute__nonnull__(pTHX_1); 2554 #define PERL_ARGS_ASSERT_MG_GET \ 2555 assert(sv) 2556 2557 PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv) 2558 __attribute__deprecated__ 2559 __attribute__nonnull__(pTHX_1); 2560 #define PERL_ARGS_ASSERT_MG_LENGTH \ 2561 assert(sv) 2562 2563 PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic) 2564 __attribute__nonnull__(pTHX_1) 2565 __attribute__nonnull__(pTHX_2); 2566 #define PERL_ARGS_ASSERT_MG_LOCALIZE \ 2567 assert(sv); assert(nsv) 2568 2569 PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv) 2570 __attribute__nonnull__(pTHX_1); 2571 #define PERL_ARGS_ASSERT_MG_MAGICAL \ 2572 assert(sv) 2573 2574 PERL_CALLCONV int Perl_mg_set(pTHX_ SV* sv) 2575 __attribute__nonnull__(pTHX_1); 2576 #define PERL_ARGS_ASSERT_MG_SET \ 2577 assert(sv) 2578 2579 PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv) 2580 __attribute__nonnull__(pTHX_1); 2581 #define PERL_ARGS_ASSERT_MG_SIZE \ 2582 assert(sv) 2583 2584 PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm) 2585 __attribute__nonnull__(pTHX_1); 2586 #define PERL_ARGS_ASSERT_MINI_MKTIME \ 2587 assert(ptm) 2588 2589 PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len); 2590 PERL_CALLCONV void * Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size); 2591 PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s) 2592 __attribute__nonnull__(pTHX_1); 2593 #define PERL_ARGS_ASSERT_MORESWITCHES \ 2594 assert(s) 2595 2596 PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name) 2597 __attribute__nonnull__(pTHX_1); 2598 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ 2599 assert(name) 2600 2601 PERL_CALLCONV AV* Perl_mro_get_linear_isa(pTHX_ HV* stash) 2602 __attribute__nonnull__(pTHX_1); 2603 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ 2604 assert(stash) 2605 2606 PERL_CALLCONV SV* Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which) 2607 __attribute__nonnull__(pTHX_1) 2608 __attribute__nonnull__(pTHX_2); 2609 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ 2610 assert(smeta); assert(which) 2611 2612 PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV* stash) 2613 __attribute__nonnull__(pTHX_1); 2614 #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ 2615 assert(stash) 2616 2617 PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash) 2618 __attribute__nonnull__(pTHX_1); 2619 #define PERL_ARGS_ASSERT_MRO_META_INIT \ 2620 assert(stash) 2621 2622 PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV* stash) 2623 __attribute__nonnull__(pTHX_1); 2624 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ 2625 assert(stash) 2626 2627 PERL_CALLCONV void Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags) 2628 __attribute__nonnull__(pTHX_3); 2629 #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ 2630 assert(gv) 2631 2632 PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro) 2633 __attribute__nonnull__(pTHX_1); 2634 #define PERL_ARGS_ASSERT_MRO_REGISTER \ 2635 assert(mro) 2636 2637 PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name) 2638 __attribute__nonnull__(pTHX_1) 2639 __attribute__nonnull__(pTHX_2); 2640 #define PERL_ARGS_ASSERT_MRO_SET_MRO \ 2641 assert(meta); assert(name) 2642 2643 PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which, SV *const data) 2644 __attribute__nonnull__(pTHX_1) 2645 __attribute__nonnull__(pTHX_2) 2646 __attribute__nonnull__(pTHX_3); 2647 #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ 2648 assert(smeta); assert(which); assert(data) 2649 2650 PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s) 2651 __attribute__nonnull__(pTHX_1); 2652 #define PERL_ARGS_ASSERT_MY_ATOF \ 2653 assert(s) 2654 2655 PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *s, NV* value) 2656 __attribute__nonnull__(pTHX_1) 2657 __attribute__nonnull__(pTHX_2); 2658 #define PERL_ARGS_ASSERT_MY_ATOF2 \ 2659 assert(s); assert(value) 2660 2661 PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) 2662 __attribute__nonnull__(pTHX_1); 2663 #define PERL_ARGS_ASSERT_MY_ATTRS \ 2664 assert(o) 2665 2666 PERL_CALLCONV void Perl_my_clearenv(pTHX); 2667 PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir); 2668 PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) 2669 __attribute__noreturn__; 2670 2671 PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX) 2672 __attribute__noreturn__; 2673 2674 PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); 2675 PERL_CALLCONV Pid_t Perl_my_fork(void); 2676 /* PERL_CALLCONV I32 Perl_my_lstat(pTHX); */ 2677 PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); 2678 PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args) 2679 __attribute__nonnull__(pTHX_1) 2680 __attribute__nonnull__(pTHX_3); 2681 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ 2682 assert(mode); assert(args) 2683 2684 PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val); 2685 PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) 2686 __attribute__format__(__printf__,3,4) 2687 __attribute__nonnull__(1) 2688 __attribute__nonnull__(3); 2689 #define PERL_ARGS_ASSERT_MY_SNPRINTF \ 2690 assert(buffer); assert(format) 2691 2692 PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); 2693 /* PERL_CALLCONV I32 Perl_my_stat(pTHX); */ 2694 PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); 2695 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) 2696 __attribute__format__(__strftime__,pTHX_1,0) 2697 __attribute__nonnull__(pTHX_1); 2698 #define PERL_ARGS_ASSERT_MY_STRFTIME \ 2699 assert(fmt) 2700 2701 PERL_CALLCONV void Perl_my_unexec(pTHX); 2702 PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap) 2703 __attribute__nonnull__(1) 2704 __attribute__nonnull__(3); 2705 #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ 2706 assert(buffer); assert(format) 2707 2708 PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); 2709 PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o) 2710 __attribute__malloc__ 2711 __attribute__warn_unused_result__; 2712 2713 PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o) 2714 __attribute__malloc__ 2715 __attribute__warn_unused_result__; 2716 2717 PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block); 2718 PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right) 2719 __attribute__malloc__ 2720 __attribute__warn_unused_result__; 2721 2722 /* PERL_CALLCONV CV* newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ 2723 PERL_CALLCONV CV* Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); 2724 /* PERL_CALLCONV AV* Perl_newAV(pTHX) 2725 __attribute__warn_unused_result__; */ 2726 2727 PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) 2728 __attribute__malloc__ 2729 __attribute__warn_unused_result__ 2730 __attribute__nonnull__(pTHX_1); 2731 #define PERL_ARGS_ASSERT_NEWAVREF \ 2732 assert(o) 2733 2734 PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2735 __attribute__malloc__ 2736 __attribute__warn_unused_result__; 2737 2738 PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop) 2739 __attribute__malloc__ 2740 __attribute__warn_unused_result__ 2741 __attribute__nonnull__(pTHX_2); 2742 #define PERL_ARGS_ASSERT_NEWCONDOP \ 2743 assert(first) 2744 2745 PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv); 2746 PERL_CALLCONV CV* Perl_newCONSTSUB_flags(pTHX_ HV* stash, const char* name, STRLEN len, U32 flags, SV* sv); 2747 PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) 2748 __attribute__malloc__ 2749 __attribute__warn_unused_result__; 2750 2751 PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont) 2752 __attribute__malloc__ 2753 __attribute__warn_unused_result__ 2754 __attribute__nonnull__(pTHX_3); 2755 #define PERL_ARGS_ASSERT_NEWFOROP \ 2756 assert(expr) 2757 2758 PERL_CALLCONV OP* Perl_newGIVENOP(pTHX_ OP* cond, OP* block, PADOFFSET defsv_off) 2759 __attribute__malloc__ 2760 __attribute__warn_unused_result__ 2761 __attribute__nonnull__(pTHX_1) 2762 __attribute__nonnull__(pTHX_2); 2763 #define PERL_ARGS_ASSERT_NEWGIVENOP \ 2764 assert(cond); assert(block) 2765 2766 PERL_CALLCONV GP * Perl_newGP(pTHX_ GV *const gv) 2767 __attribute__nonnull__(pTHX_1); 2768 #define PERL_ARGS_ASSERT_NEWGP \ 2769 assert(gv) 2770 2771 PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv) 2772 __attribute__malloc__ 2773 __attribute__warn_unused_result__ 2774 __attribute__nonnull__(pTHX_3); 2775 #define PERL_ARGS_ASSERT_NEWGVOP \ 2776 assert(gv) 2777 2778 PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o) 2779 __attribute__malloc__ 2780 __attribute__warn_unused_result__; 2781 2782 /* PERL_CALLCONV GV* newGVgen(pTHX_ const char* pack) 2783 __attribute__nonnull__(pTHX_1); */ 2784 2785 PERL_CALLCONV GV* Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags) 2786 __attribute__malloc__ 2787 __attribute__warn_unused_result__ 2788 __attribute__nonnull__(pTHX_1); 2789 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ 2790 assert(pack) 2791 2792 /* PERL_CALLCONV HV* Perl_newHV(pTHX) 2793 __attribute__warn_unused_result__; */ 2794 2795 PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) 2796 __attribute__malloc__ 2797 __attribute__warn_unused_result__ 2798 __attribute__nonnull__(pTHX_1); 2799 #define PERL_ARGS_ASSERT_NEWHVREF \ 2800 assert(o) 2801 2802 PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv) 2803 __attribute__malloc__ 2804 __attribute__warn_unused_result__; 2805 2806 /* PERL_CALLCONV IO* Perl_newIO(pTHX) 2807 __attribute__malloc__ 2808 __attribute__warn_unused_result__; */ 2809 2810 PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2811 __attribute__malloc__ 2812 __attribute__warn_unused_result__; 2813 2814 PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) 2815 __attribute__malloc__ 2816 __attribute__warn_unused_result__ 2817 __attribute__nonnull__(pTHX_3) 2818 __attribute__nonnull__(pTHX_4); 2819 #define PERL_ARGS_ASSERT_NEWLOGOP \ 2820 assert(first); assert(other) 2821 2822 PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label) 2823 __attribute__malloc__ 2824 __attribute__warn_unused_result__ 2825 __attribute__nonnull__(pTHX_2); 2826 #define PERL_ARGS_ASSERT_NEWLOOPEX \ 2827 assert(label) 2828 2829 PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block) 2830 __attribute__malloc__ 2831 __attribute__warn_unused_result__; 2832 2833 PERL_CALLCONV CV * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) 2834 __attribute__nonnull__(pTHX_2); 2835 #define PERL_ARGS_ASSERT_NEWMYSUB \ 2836 assert(o) 2837 2838 PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) 2839 __attribute__malloc__ 2840 __attribute__warn_unused_result__; 2841 2842 PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags) 2843 __attribute__malloc__ 2844 __attribute__warn_unused_result__; 2845 2846 PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags) 2847 __attribute__malloc__ 2848 __attribute__warn_unused_result__; 2849 2850 PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o) 2851 __attribute__nonnull__(pTHX_1); 2852 #define PERL_ARGS_ASSERT_NEWPROG \ 2853 assert(o) 2854 2855 PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv) 2856 __attribute__malloc__ 2857 __attribute__warn_unused_result__; 2858 2859 PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right) 2860 __attribute__malloc__ 2861 __attribute__warn_unused_result__ 2862 __attribute__nonnull__(pTHX_2) 2863 __attribute__nonnull__(pTHX_3); 2864 #define PERL_ARGS_ASSERT_NEWRANGE \ 2865 assert(left); assert(right) 2866 2867 PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv) 2868 __attribute__malloc__ 2869 __attribute__warn_unused_result__ 2870 __attribute__nonnull__(pTHX_1); 2871 #define PERL_ARGS_ASSERT_NEWRV \ 2872 assert(sv) 2873 2874 PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv) 2875 __attribute__malloc__ 2876 __attribute__warn_unused_result__ 2877 __attribute__nonnull__(pTHX_1); 2878 #define PERL_ARGS_ASSERT_NEWRV_NOINC \ 2879 assert(sv) 2880 2881 PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop) 2882 __attribute__malloc__ 2883 __attribute__warn_unused_result__; 2884 2885 PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) 2886 __attribute__malloc__ 2887 __attribute__warn_unused_result__; 2888 2889 PERL_CALLCONV CV* Perl_newSTUB(pTHX_ GV *gv, bool fake) 2890 __attribute__nonnull__(pTHX_1); 2891 #define PERL_ARGS_ASSERT_NEWSTUB \ 2892 assert(gv) 2893 2894 /* PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */ 2895 PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) 2896 __attribute__malloc__ 2897 __attribute__warn_unused_result__; 2898 2899 PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv) 2900 __attribute__malloc__ 2901 __attribute__warn_unused_result__ 2902 __attribute__nonnull__(pTHX_3); 2903 #define PERL_ARGS_ASSERT_NEWSVOP \ 2904 assert(sv) 2905 2906 PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o) 2907 __attribute__malloc__ 2908 __attribute__warn_unused_result__ 2909 __attribute__nonnull__(pTHX_1); 2910 #define PERL_ARGS_ASSERT_NEWSVREF \ 2911 assert(o) 2912 2913 PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type) 2914 __attribute__malloc__ 2915 __attribute__warn_unused_result__; 2916 2917 PERL_CALLCONV SV* Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) 2918 __attribute__malloc__ 2919 __attribute__warn_unused_result__ 2920 __attribute__nonnull__(pTHX_1); 2921 #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \ 2922 assert(av) 2923 2924 PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek) 2925 __attribute__malloc__ 2926 __attribute__warn_unused_result__; 2927 2928 PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i) 2929 __attribute__malloc__ 2930 __attribute__warn_unused_result__; 2931 2932 PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n) 2933 __attribute__malloc__ 2934 __attribute__warn_unused_result__; 2935 2936 PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len) 2937 __attribute__malloc__ 2938 __attribute__warn_unused_result__; 2939 2940 PERL_CALLCONV SV* Perl_newSVpv_share(pTHX_ const char* s, U32 hash) 2941 __attribute__malloc__ 2942 __attribute__warn_unused_result__; 2943 2944 PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) 2945 __attribute__malloc__ 2946 __attribute__warn_unused_result__ 2947 __attribute__format__(__printf__,pTHX_1,pTHX_2) 2948 __attribute__nonnull__(pTHX_1); 2949 #define PERL_ARGS_ASSERT_NEWSVPVF \ 2950 assert(pat) 2951 2952 PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len) 2953 __attribute__malloc__ 2954 __attribute__warn_unused_result__; 2955 2956 PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) 2957 __attribute__malloc__ 2958 __attribute__warn_unused_result__; 2959 2960 PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) 2961 __attribute__malloc__ 2962 __attribute__warn_unused_result__; 2963 2964 PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname) 2965 __attribute__nonnull__(pTHX_1); 2966 #define PERL_ARGS_ASSERT_NEWSVRV \ 2967 assert(rv) 2968 2969 PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) 2970 __attribute__malloc__ 2971 __attribute__warn_unused_result__; 2972 2973 PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) 2974 __attribute__malloc__ 2975 __attribute__warn_unused_result__; 2976 2977 PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first) 2978 __attribute__malloc__ 2979 __attribute__warn_unused_result__; 2980 2981 PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) 2982 __attribute__malloc__ 2983 __attribute__warn_unused_result__ 2984 __attribute__nonnull__(pTHX_2); 2985 #define PERL_ARGS_ASSERT_NEWWHENOP \ 2986 assert(block) 2987 2988 PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, OP* expr, OP* block, OP* cont, I32 has_my) 2989 __attribute__malloc__ 2990 __attribute__warn_unused_result__; 2991 2992 PERL_CALLCONV CV* Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) 2993 __attribute__nonnull__(pTHX_2) 2994 __attribute__nonnull__(pTHX_3); 2995 #define PERL_ARGS_ASSERT_NEWXS \ 2996 assert(subaddr); assert(filename) 2997 2998 PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags) 2999 __attribute__nonnull__(pTHX_2) 3000 __attribute__nonnull__(pTHX_3); 3001 #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ 3002 assert(subaddr); assert(filename) 3003 3004 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) 3005 __attribute__nonnull__(pTHX_3) 3006 __attribute__nonnull__(pTHX_4); 3007 #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ 3008 assert(subaddr); assert(filename) 3009 3010 PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll); 3011 PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype) 3012 __attribute__nonnull__(pTHX_1); 3013 #define PERL_ARGS_ASSERT_NEW_CTYPE \ 3014 assert(newctype) 3015 3016 PERL_CALLCONV void Perl_new_numeric(pTHX_ const char* newcoll); 3017 PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) 3018 __attribute__malloc__ 3019 __attribute__warn_unused_result__; 3020 3021 PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver) 3022 __attribute__nonnull__(pTHX_1); 3023 #define PERL_ARGS_ASSERT_NEW_VERSION \ 3024 assert(ver) 3025 3026 PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits, STRLEN size) 3027 __attribute__malloc__ 3028 __attribute__warn_unused_result__ 3029 __attribute__nonnull__(pTHX_2); 3030 #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ 3031 assert(bits) 3032 3033 PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv) 3034 __attribute__nonnull__(pTHX_1); 3035 #define PERL_ARGS_ASSERT_NEXTARGV \ 3036 assert(gv) 3037 3038 PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) 3039 __attribute__pure__ 3040 __attribute__nonnull__(1) 3041 __attribute__nonnull__(2) 3042 __attribute__nonnull__(3) 3043 __attribute__nonnull__(4); 3044 #define PERL_ARGS_ASSERT_NINSTR \ 3045 assert(big); assert(bigend); assert(little); assert(lend) 3046 3047 PERL_CALLCONV int Perl_nothreadhook(pTHX); 3048 PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) 3049 __attribute__warn_unused_result__ 3050 __attribute__nonnull__(pTHX_1); 3051 #define PERL_ARGS_ASSERT_OOPSAV \ 3052 assert(o) 3053 3054 PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) 3055 __attribute__warn_unused_result__ 3056 __attribute__nonnull__(pTHX_1); 3057 #define PERL_ARGS_ASSERT_OOPSHV \ 3058 assert(o) 3059 3060 PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last); 3061 PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last); 3062 PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o) 3063 __attribute__nonnull__(pTHX_1); 3064 #define PERL_ARGS_ASSERT_OP_CLEAR \ 3065 assert(o) 3066 3067 PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv) 3068 __attribute__warn_unused_result__; 3069 3070 PERL_CALLCONV OP* Perl_op_contextualize(pTHX_ OP* o, I32 context) 3071 __attribute__nonnull__(pTHX_1); 3072 #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ 3073 assert(o) 3074 3075 PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o) 3076 __attribute__nonnull__(pTHX_1); 3077 #define PERL_ARGS_ASSERT_OP_DUMP \ 3078 assert(o) 3079 3080 PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg); 3081 PERL_CALLCONV OP* Perl_op_linklist(pTHX_ OP *o) 3082 __attribute__nonnull__(pTHX_1); 3083 #define PERL_ARGS_ASSERT_OP_LINKLIST \ 3084 assert(o) 3085 3086 /* PERL_CALLCONV OP* op_lvalue(pTHX_ OP* o, I32 type); */ 3087 PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags); 3088 PERL_CALLCONV void Perl_op_null(pTHX_ OP* o) 3089 __attribute__nonnull__(pTHX_1); 3090 #define PERL_ARGS_ASSERT_OP_NULL \ 3091 assert(o) 3092 3093 PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); 3094 PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); 3095 PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); 3096 PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); 3097 PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); 3098 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) 3099 __attribute__nonnull__(pTHX_1) 3100 __attribute__nonnull__(pTHX_2) 3101 __attribute__nonnull__(pTHX_3) 3102 __attribute__nonnull__(pTHX_4) 3103 __attribute__nonnull__(pTHX_5) 3104 __attribute__nonnull__(pTHX_6); 3105 #define PERL_ARGS_ASSERT_PACK_CAT \ 3106 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) 3107 3108 PERL_CALLCONV void Perl_package_version(pTHX_ OP* v) 3109 __attribute__nonnull__(pTHX_1); 3110 #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ 3111 assert(v) 3112 3113 PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist) 3114 __attribute__nonnull__(pTHX_1) 3115 __attribute__nonnull__(pTHX_2) 3116 __attribute__nonnull__(pTHX_3) 3117 __attribute__nonnull__(pTHX_4) 3118 __attribute__nonnull__(pTHX_5); 3119 #define PERL_ARGS_ASSERT_PACKLIST \ 3120 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist) 3121 3122 PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ CV* func, I32 optype) 3123 __attribute__nonnull__(pTHX_1); 3124 #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ 3125 assert(func) 3126 3127 PERL_CALLCONV PADOFFSET Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash) 3128 __attribute__nonnull__(pTHX_1); 3129 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ 3130 assert(name) 3131 3132 PERL_CALLCONV PADOFFSET Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash) 3133 __attribute__nonnull__(pTHX_1); 3134 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ 3135 assert(namepv) 3136 3137 PERL_CALLCONV PADOFFSET Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash) 3138 __attribute__nonnull__(pTHX_1); 3139 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ 3140 assert(name) 3141 3142 PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); 3143 PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full); 3144 PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po) 3145 __attribute__warn_unused_result__; 3146 3147 PERL_CALLCONV PADOFFSET Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags) 3148 __attribute__nonnull__(pTHX_1); 3149 #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ 3150 assert(name) 3151 3152 PERL_CALLCONV PADOFFSET Perl_pad_findmy_pvn(pTHX_ const char* namepv, STRLEN namelen, U32 flags) 3153 __attribute__nonnull__(pTHX_1); 3154 #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ 3155 assert(namepv) 3156 3157 PERL_CALLCONV PADOFFSET Perl_pad_findmy_sv(pTHX_ SV* name, U32 flags) 3158 __attribute__nonnull__(pTHX_1); 3159 #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ 3160 assert(name) 3161 3162 PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) 3163 __attribute__nonnull__(pTHX_1) 3164 __attribute__nonnull__(pTHX_2) 3165 __attribute__nonnull__(pTHX_3); 3166 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ 3167 assert(padlist); assert(old_cv); assert(new_cv) 3168 3169 PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); 3170 PERL_CALLCONV OP * Perl_pad_leavemy(pTHX); 3171 PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) 3172 __attribute__malloc__ 3173 __attribute__warn_unused_result__; 3174 3175 PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) 3176 __attribute__nonnull__(pTHX_1); 3177 #define PERL_ARGS_ASSERT_PAD_PUSH \ 3178 assert(padlist) 3179 3180 PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); 3181 PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); 3182 PERL_CALLCONV PAD ** Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) 3183 __attribute__nonnull__(pTHX_1); 3184 #define PERL_ARGS_ASSERT_PADLIST_STORE \ 3185 assert(padlist) 3186 3187 PERL_CALLCONV OP* Perl_parse_arithexpr(pTHX_ U32 flags); 3188 PERL_CALLCONV OP* Perl_parse_barestmt(pTHX_ U32 flags); 3189 PERL_CALLCONV OP* Perl_parse_block(pTHX_ U32 flags); 3190 PERL_CALLCONV OP* Perl_parse_fullexpr(pTHX_ U32 flags); 3191 PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags); 3192 PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags); 3193 PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags); 3194 PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags); 3195 PERL_CALLCONV OP * Perl_parse_subsignature(pTHX) 3196 __attribute__warn_unused_result__; 3197 3198 PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags); 3199 PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) 3200 __attribute__nonnull__(pTHX_1); 3201 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ 3202 assert(popt) 3203 3204 PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) 3205 __attribute__nonnull__(pTHX_1); 3206 #define PERL_ARGS_ASSERT_PARSER_FREE \ 3207 assert(parser) 3208 3209 PERL_CALLCONV void Perl_peep(pTHX_ OP* o); 3210 PERL_CALLCONV PerlInterpreter* perl_alloc(void); 3211 PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl) 3212 __attribute__nonnull__(1); 3213 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ 3214 assert(my_perl) 3215 3216 PERL_CALLCONV int perl_destruct(PerlInterpreter *my_perl) 3217 __attribute__nonnull__(1); 3218 #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ 3219 assert(my_perl) 3220 3221 PERL_CALLCONV void perl_free(PerlInterpreter *my_perl) 3222 __attribute__nonnull__(1); 3223 #define PERL_ARGS_ASSERT_PERL_FREE \ 3224 assert(my_perl) 3225 3226 PERL_CALLCONV int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env) 3227 __attribute__nonnull__(1); 3228 #define PERL_ARGS_ASSERT_PERL_PARSE \ 3229 assert(my_perl) 3230 3231 PERL_CALLCONV int perl_run(PerlInterpreter *my_perl) 3232 __attribute__nonnull__(1); 3233 #define PERL_ARGS_ASSERT_PERL_RUN \ 3234 assert(my_perl) 3235 3236 PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); 3237 PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg, I32 floor) 3238 __attribute__nonnull__(pTHX_1) 3239 __attribute__nonnull__(pTHX_2); 3240 #define PERL_ARGS_ASSERT_PMRUNTIME \ 3241 assert(o); assert(expr) 3242 3243 PERL_CALLCONV void Perl_pop_scope(pTHX); 3244 PERL_CALLCONV void Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) 3245 __attribute__nonnull__(pTHX_1); 3246 #define PERL_ARGS_ASSERT_POPULATE_ISA \ 3247 assert(name) 3248 3249 PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags) 3250 __attribute__nonnull__(pTHX_1); 3251 #define PERL_ARGS_ASSERT_PREGCOMP \ 3252 assert(pattern) 3253 3254 PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave) 3255 __attribute__nonnull__(pTHX_1) 3256 __attribute__nonnull__(pTHX_2) 3257 __attribute__nonnull__(pTHX_3) 3258 __attribute__nonnull__(pTHX_4) 3259 __attribute__nonnull__(pTHX_6); 3260 #define PERL_ARGS_ASSERT_PREGEXEC \ 3261 assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) 3262 3263 PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r); 3264 PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx) 3265 __attribute__nonnull__(pTHX_1); 3266 #define PERL_ARGS_ASSERT_PREGFREE2 \ 3267 assert(rx) 3268 3269 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) 3270 __attribute__nonnull__(pTHX_1); 3271 #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ 3272 assert(s) 3273 3274 PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl) 3275 __attribute__deprecated__; 3276 3277 PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv) 3278 __attribute__warn_unused_result__ 3279 __attribute__nonnull__(pTHX_1); 3280 #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ 3281 assert(tbl) 3282 3283 PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl); 3284 PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX) 3285 __attribute__malloc__ 3286 __attribute__warn_unused_result__; 3287 3288 PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl) 3289 __attribute__nonnull__(pTHX_1); 3290 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ 3291 assert(tbl) 3292 3293 PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv) 3294 __attribute__nonnull__(pTHX_1) 3295 __attribute__nonnull__(pTHX_3); 3296 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ 3297 assert(tbl); assert(newsv) 3298 3299 PERL_CALLCONV void Perl_push_scope(pTHX); 3300 PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) 3301 __attribute__nonnull__(pTHX_1) 3302 __attribute__nonnull__(pTHX_2); 3303 #define PERL_ARGS_ASSERT_PV_DISPLAY \ 3304 assert(dsv); assert(pv) 3305 3306 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) 3307 __attribute__nonnull__(pTHX_1) 3308 __attribute__nonnull__(pTHX_2); 3309 #define PERL_ARGS_ASSERT_PV_ESCAPE \ 3310 assert(dsv); assert(str) 3311 3312 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) 3313 __attribute__nonnull__(pTHX_1) 3314 __attribute__nonnull__(pTHX_2); 3315 #define PERL_ARGS_ASSERT_PV_PRETTY \ 3316 assert(dsv); assert(str) 3317 3318 PERL_CALLCONV char* Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags) 3319 __attribute__nonnull__(pTHX_1) 3320 __attribute__nonnull__(pTHX_2); 3321 #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ 3322 assert(dsv); assert(spv) 3323 3324 PERL_CALLCONV void Perl_qerror(pTHX_ SV* err) 3325 __attribute__nonnull__(pTHX_1); 3326 #define PERL_ARGS_ASSERT_QERROR \ 3327 assert(err) 3328 3329 PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags) 3330 __attribute__nonnull__(pTHX_1); 3331 #define PERL_ARGS_ASSERT_RE_COMPILE \ 3332 assert(pattern) 3333 3334 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) 3335 __attribute__nonnull__(pTHX_1) 3336 __attribute__nonnull__(pTHX_3) 3337 __attribute__nonnull__(pTHX_4) 3338 __attribute__nonnull__(pTHX_5); 3339 #define PERL_ARGS_ASSERT_RE_INTUIT_START \ 3340 assert(rx); assert(strbeg); assert(strpos); assert(strend) 3341 3342 PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r) 3343 __attribute__nonnull__(pTHX_1); 3344 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ 3345 assert(r) 3346 3347 PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, U32 rx_flags, U32 pm_flags) 3348 __attribute__nonnull__(pTHX_4); 3349 #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ 3350 assert(eng) 3351 3352 PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) 3353 __attribute__malloc__ 3354 __attribute__warn_unused_result__; 3355 3356 PERL_CALLCONV void Perl_reentrant_free(pTHX); 3357 PERL_CALLCONV void Perl_reentrant_init(pTHX); 3358 PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...) 3359 __attribute__nonnull__(1); 3360 #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ 3361 assert(f) 3362 3363 PERL_CALLCONV void Perl_reentrant_size(pTHX); 3364 /* PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); */ 3365 PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); 3366 PERL_CALLCONV SV * Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags) 3367 __attribute__nonnull__(pTHX_2); 3368 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ 3369 assert(key) 3370 3371 PERL_CALLCONV SV * Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags) 3372 __attribute__nonnull__(pTHX_2); 3373 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ 3374 assert(keypv) 3375 3376 PERL_CALLCONV SV * Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags) 3377 __attribute__nonnull__(pTHX_2); 3378 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ 3379 assert(key) 3380 3381 PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); 3382 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); 3383 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags) 3384 __attribute__nonnull__(pTHX_2); 3385 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ 3386 assert(key) 3387 3388 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) 3389 __attribute__nonnull__(pTHX_2); 3390 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ 3391 assert(keypv) 3392 3393 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags) 3394 __attribute__nonnull__(pTHX_2); 3395 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ 3396 assert(key) 3397 3398 PERL_CALLCONV SV* Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags) 3399 __attribute__nonnull__(pTHX_1); 3400 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ 3401 assert(rx) 3402 3403 PERL_CALLCONV SV* Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags) 3404 __attribute__nonnull__(pTHX_1); 3405 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ 3406 assert(rx) 3407 3408 PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags) 3409 __attribute__nonnull__(pTHX_1) 3410 __attribute__nonnull__(pTHX_2); 3411 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ 3412 assert(rx); assert(key) 3413 3414 PERL_CALLCONV SV* Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags) 3415 __attribute__nonnull__(pTHX_1) 3416 __attribute__nonnull__(pTHX_2); 3417 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ 3418 assert(rx); assert(namesv) 3419 3420 PERL_CALLCONV SV* Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) 3421 __attribute__nonnull__(pTHX_1); 3422 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ 3423 assert(rx) 3424 3425 PERL_CALLCONV SV* Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags) 3426 __attribute__nonnull__(pTHX_1); 3427 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ 3428 assert(rx) 3429 3430 PERL_CALLCONV SV* Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags) 3431 __attribute__nonnull__(pTHX_1); 3432 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ 3433 assert(rx) 3434 3435 PERL_CALLCONV SV* Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) 3436 __attribute__nonnull__(pTHX_1); 3437 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ 3438 assert(rx) 3439 3440 PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren, SV * const sv) 3441 __attribute__nonnull__(pTHX_1); 3442 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ 3443 assert(rx) 3444 3445 PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren) 3446 __attribute__nonnull__(pTHX_1) 3447 __attribute__nonnull__(pTHX_2); 3448 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ 3449 assert(rx); assert(sv) 3450 3451 PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value) 3452 __attribute__nonnull__(pTHX_1); 3453 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ 3454 assert(rx) 3455 3456 PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx) 3457 __attribute__nonnull__(pTHX_1); 3458 #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ 3459 assert(rx) 3460 3461 PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* ret_x, REGEXP* rx) 3462 __attribute__nonnull__(pTHX_2); 3463 #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ 3464 assert(rx) 3465 3466 PERL_CALLCONV SV* Perl_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp) 3467 __attribute__nonnull__(pTHX_2); 3468 #define PERL_ARGS_ASSERT_REGCLASS_SWASH \ 3469 assert(node) 3470 3471 PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) 3472 __attribute__nonnull__(pTHX_1); 3473 #define PERL_ARGS_ASSERT_REGDUMP \ 3474 assert(r) 3475 3476 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) 3477 __attribute__nonnull__(pTHX_1) 3478 __attribute__nonnull__(pTHX_2) 3479 __attribute__nonnull__(pTHX_3) 3480 __attribute__nonnull__(pTHX_4) 3481 __attribute__nonnull__(pTHX_6); 3482 #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ 3483 assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv) 3484 3485 PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx) 3486 __attribute__nonnull__(pTHX_1); 3487 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ 3488 assert(rx) 3489 3490 PERL_CALLCONV void Perl_reginitcolors(pTHX); 3491 PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) 3492 __attribute__warn_unused_result__; 3493 3494 PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo) 3495 __attribute__nonnull__(pTHX_2) 3496 __attribute__nonnull__(pTHX_3); 3497 #define PERL_ARGS_ASSERT_REGPROP \ 3498 assert(sv); assert(o) 3499 3500 PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, IV count) 3501 __attribute__nonnull__(1) 3502 __attribute__nonnull__(2); 3503 #define PERL_ARGS_ASSERT_REPEATCPY \ 3504 assert(to); assert(from) 3505 3506 PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv); 3507 PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); 3508 PERL_CALLCONV void Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have); 3509 PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv) 3510 __attribute__nonnull__(pTHX_1); 3511 #define PERL_ARGS_ASSERT_REQUIRE_PV \ 3512 assert(pv) 3513 3514 PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend) 3515 __attribute__pure__ 3516 __attribute__nonnull__(1) 3517 __attribute__nonnull__(2) 3518 __attribute__nonnull__(3) 3519 __attribute__nonnull__(4); 3520 #define PERL_ARGS_ASSERT_RNINSTR \ 3521 assert(big); assert(bigend); assert(little); assert(lend) 3522 3523 PERL_CALLCONV void Perl_rpeep(pTHX_ OP* o); 3524 PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t); 3525 PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t); 3526 PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save) 3527 __attribute__nonnull__(pTHX_3); 3528 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ 3529 assert(save) 3530 3531 PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); 3532 PERL_CALLCONV int Perl_runops_debug(pTHX); 3533 PERL_CALLCONV int Perl_runops_standard(pTHX); 3534 PERL_CALLCONV CV* Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags) 3535 __attribute__nonnull__(pTHX_1); 3536 #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ 3537 assert(cvop) 3538 3539 PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) 3540 __attribute__nonnull__(pTHX_1) 3541 __attribute__nonnull__(pTHX_2); 3542 #define PERL_ARGS_ASSERT_RXRES_SAVE \ 3543 assert(rsp); assert(rx) 3544 3545 PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) 3546 __attribute__malloc__ 3547 __attribute__warn_unused_result__; 3548 3549 PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where); 3550 PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes) 3551 __attribute__malloc__ 3552 __attribute__warn_unused_result__; 3553 3554 PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) 3555 __attribute__malloc__ 3556 __attribute__warn_unused_result__; 3557 3558 PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp) 3559 __attribute__nonnull__(pTHX_1); 3560 #define PERL_ARGS_ASSERT_SAVE_I16 \ 3561 assert(intp) 3562 3563 PERL_CALLCONV void Perl_save_I32(pTHX_ I32* intp) 3564 __attribute__nonnull__(pTHX_1); 3565 #define PERL_ARGS_ASSERT_SAVE_I32 \ 3566 assert(intp) 3567 3568 PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep) 3569 __attribute__nonnull__(pTHX_1); 3570 #define PERL_ARGS_ASSERT_SAVE_I8 \ 3571 assert(bytep) 3572 3573 PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, SSize_t key) 3574 __attribute__nonnull__(pTHX_1); 3575 #define PERL_ARGS_ASSERT_SAVE_ADELETE \ 3576 assert(av) 3577 3578 /* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, SSize_t idx, SV **sptr) 3579 __attribute__nonnull__(pTHX_1) 3580 __attribute__nonnull__(pTHX_3); */ 3581 3582 PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, SSize_t idx, SV **sptr, const U32 flags) 3583 __attribute__nonnull__(pTHX_1) 3584 __attribute__nonnull__(pTHX_3); 3585 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ 3586 assert(av); assert(sptr) 3587 3588 PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad); 3589 PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr) 3590 __attribute__nonnull__(pTHX_1); 3591 #define PERL_ARGS_ASSERT_SAVE_APTR \ 3592 assert(aptr) 3593 3594 PERL_CALLCONV AV* Perl_save_ary(pTHX_ GV* gv) 3595 __attribute__nonnull__(pTHX_1); 3596 #define PERL_ARGS_ASSERT_SAVE_ARY \ 3597 assert(gv) 3598 3599 PERL_CALLCONV void Perl_save_bool(pTHX_ bool* boolp) 3600 __attribute__nonnull__(pTHX_1); 3601 #define PERL_ARGS_ASSERT_SAVE_BOOL \ 3602 assert(boolp) 3603 3604 PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV** svp) 3605 __attribute__nonnull__(pTHX_1); 3606 #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ 3607 assert(svp) 3608 3609 PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) 3610 __attribute__nonnull__(pTHX_1) 3611 __attribute__nonnull__(pTHX_2); 3612 #define PERL_ARGS_ASSERT_SAVE_DELETE \ 3613 assert(hv); assert(key) 3614 3615 PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) 3616 __attribute__nonnull__(pTHX_2); 3617 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ 3618 assert(p) 3619 3620 PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p); 3621 /* PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); */ 3622 /* PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); */ 3623 /* PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); */ 3624 PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str) 3625 __attribute__nonnull__(pTHX_1); 3626 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ 3627 assert(str) 3628 3629 PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV** sptr) 3630 __attribute__nonnull__(pTHX_1); 3631 #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ 3632 assert(sptr) 3633 3634 PERL_CALLCONV void Perl_save_gp(pTHX_ GV* gv, I32 empty) 3635 __attribute__nonnull__(pTHX_1); 3636 #define PERL_ARGS_ASSERT_SAVE_GP \ 3637 assert(gv) 3638 3639 PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv) 3640 __attribute__nonnull__(pTHX_1); 3641 #define PERL_ARGS_ASSERT_SAVE_HASH \ 3642 assert(gv) 3643 3644 PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) 3645 __attribute__nonnull__(pTHX_1) 3646 __attribute__nonnull__(pTHX_2); 3647 #define PERL_ARGS_ASSERT_SAVE_HDELETE \ 3648 assert(hv); assert(keysv) 3649 3650 /* PERL_CALLCONV void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) 3651 __attribute__nonnull__(pTHX_1) 3652 __attribute__nonnull__(pTHX_2) 3653 __attribute__nonnull__(pTHX_3); */ 3654 3655 PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) 3656 __attribute__nonnull__(pTHX_1) 3657 __attribute__nonnull__(pTHX_2) 3658 __attribute__nonnull__(pTHX_3); 3659 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ 3660 assert(hv); assert(key); assert(sptr) 3661 3662 PERL_CALLCONV void Perl_save_hints(pTHX); 3663 PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr) 3664 __attribute__nonnull__(pTHX_1); 3665 #define PERL_ARGS_ASSERT_SAVE_HPTR \ 3666 assert(hptr) 3667 3668 PERL_CALLCONV void Perl_save_int(pTHX_ int* intp) 3669 __attribute__nonnull__(pTHX_1); 3670 #define PERL_ARGS_ASSERT_SAVE_INT \ 3671 assert(intp) 3672 3673 PERL_CALLCONV void Perl_save_item(pTHX_ SV* item) 3674 __attribute__nonnull__(pTHX_1); 3675 #define PERL_ARGS_ASSERT_SAVE_ITEM \ 3676 assert(item) 3677 3678 PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp) 3679 __attribute__nonnull__(pTHX_1); 3680 #define PERL_ARGS_ASSERT_SAVE_IV \ 3681 assert(ivp) 3682 3683 PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg) 3684 __attribute__nonnull__(pTHX_1); 3685 #define PERL_ARGS_ASSERT_SAVE_LIST \ 3686 assert(sarg) 3687 3688 PERL_CALLCONV void Perl_save_long(pTHX_ long* longp) 3689 __attribute__nonnull__(pTHX_1); 3690 #define PERL_ARGS_ASSERT_SAVE_LONG \ 3691 assert(longp) 3692 3693 /* PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv) 3694 __attribute__nonnull__(pTHX_1); */ 3695 #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ 3696 assert(sv) 3697 3698 PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv) 3699 __attribute__nonnull__(pTHX_1); 3700 #define PERL_ARGS_ASSERT_SAVE_NOGV \ 3701 assert(gv) 3702 3703 /* PERL_CALLCONV void Perl_save_op(pTHX); */ 3704 PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); 3705 PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr) 3706 __attribute__nonnull__(pTHX_1); 3707 #define PERL_ARGS_ASSERT_SAVE_PPTR \ 3708 assert(pptr) 3709 3710 PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type); 3711 PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type); 3712 PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type); 3713 PERL_CALLCONV void Perl_save_re_context(pTHX); 3714 PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv) 3715 __attribute__nonnull__(pTHX_1); 3716 #define PERL_ARGS_ASSERT_SAVE_SCALAR \ 3717 assert(gv) 3718 3719 PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val) 3720 __attribute__nonnull__(pTHX_1); 3721 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ 3722 assert(sv) 3723 3724 PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char** str) 3725 __attribute__nonnull__(pTHX_1); 3726 #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ 3727 assert(str) 3728 3729 PERL_CALLCONV void Perl_save_sptr(pTHX_ SV** sptr) 3730 __attribute__nonnull__(pTHX_1); 3731 #define PERL_ARGS_ASSERT_SAVE_SPTR \ 3732 assert(sptr) 3733 3734 PERL_CALLCONV void Perl_save_strlen(pTHX_ STRLEN* ptr) 3735 __attribute__nonnull__(pTHX_1); 3736 #define PERL_ARGS_ASSERT_SAVE_STRLEN \ 3737 assert(ptr) 3738 3739 PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr) 3740 __attribute__nonnull__(pTHX_1); 3741 #define PERL_ARGS_ASSERT_SAVE_SVREF \ 3742 assert(sptr) 3743 3744 PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr) 3745 __attribute__nonnull__(pTHX_1); 3746 #define PERL_ARGS_ASSERT_SAVE_VPTR \ 3747 assert(ptr) 3748 3749 PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv) 3750 __attribute__malloc__ 3751 __attribute__warn_unused_result__; 3752 3753 PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, I32 len) 3754 __attribute__malloc__ 3755 __attribute__warn_unused_result__; 3756 3757 PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv) 3758 __attribute__malloc__ 3759 __attribute__warn_unused_result__; 3760 3761 PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len) 3762 __attribute__malloc__ 3763 __attribute__warn_unused_result__; 3764 3765 PERL_CALLCONV char* Perl_savesharedsvpv(pTHX_ SV *sv) 3766 __attribute__malloc__ 3767 __attribute__warn_unused_result__ 3768 __attribute__nonnull__(pTHX_1); 3769 #define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ 3770 assert(sv) 3771 3772 PERL_CALLCONV void Perl_savestack_grow(pTHX); 3773 PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need); 3774 PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) 3775 __attribute__malloc__ 3776 __attribute__warn_unused_result__ 3777 __attribute__nonnull__(pTHX_1); 3778 #define PERL_ARGS_ASSERT_SAVESVPV \ 3779 assert(sv) 3780 3781 PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o); 3782 PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o); 3783 PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o) 3784 __attribute__nonnull__(pTHX_1); 3785 #define PERL_ARGS_ASSERT_SCALARVOID \ 3786 assert(o) 3787 3788 PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3789 __attribute__nonnull__(pTHX_1) 3790 __attribute__nonnull__(pTHX_3); 3791 #define PERL_ARGS_ASSERT_SCAN_BIN \ 3792 assert(start); assert(retlen) 3793 3794 PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3795 __attribute__nonnull__(pTHX_1) 3796 __attribute__nonnull__(pTHX_3); 3797 #define PERL_ARGS_ASSERT_SCAN_HEX \ 3798 assert(start); assert(retlen) 3799 3800 PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp) 3801 __attribute__nonnull__(pTHX_1) 3802 __attribute__nonnull__(pTHX_2); 3803 #define PERL_ARGS_ASSERT_SCAN_NUM \ 3804 assert(s); assert(lvalp) 3805 3806 PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3807 __attribute__nonnull__(pTHX_1) 3808 __attribute__nonnull__(pTHX_3); 3809 #define PERL_ARGS_ASSERT_SCAN_OCT \ 3810 assert(start); assert(retlen) 3811 3812 PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) 3813 __attribute__nonnull__(pTHX_1) 3814 __attribute__nonnull__(pTHX_2); 3815 #define PERL_ARGS_ASSERT_SCAN_VERSION \ 3816 assert(s); assert(rv) 3817 3818 PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, SV *sv) 3819 __attribute__nonnull__(pTHX_1) 3820 __attribute__nonnull__(pTHX_2) 3821 __attribute__nonnull__(pTHX_3); 3822 #define PERL_ARGS_ASSERT_SCAN_VSTRING \ 3823 assert(s); assert(e); assert(sv) 3824 3825 PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) 3826 __attribute__nonnull__(pTHX_1) 3827 __attribute__nonnull__(pTHX_2) 3828 __attribute__nonnull__(pTHX_5); 3829 #define PERL_ARGS_ASSERT_SCREAMINSTR \ 3830 assert(bigstr); assert(littlestr); assert(old_posp) 3831 3832 PERL_CALLCONV U32 Perl_seed(pTHX); 3833 PERL_CALLCONV void Perl_set_caret_X(pTHX); 3834 PERL_CALLCONV void Perl_set_context(void *t) 3835 __attribute__nonnull__(1); 3836 #define PERL_ARGS_ASSERT_SET_CONTEXT \ 3837 assert(t) 3838 3839 PERL_CALLCONV void Perl_set_numeric_local(pTHX); 3840 PERL_CALLCONV void Perl_set_numeric_radix(pTHX); 3841 PERL_CALLCONV void Perl_set_numeric_standard(pTHX); 3842 PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv) 3843 __attribute__nonnull__(pTHX_1); 3844 #define PERL_ARGS_ASSERT_SETDEFOUT \ 3845 assert(gv) 3846 3847 PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash) 3848 __attribute__nonnull__(pTHX_1); 3849 #define PERL_ARGS_ASSERT_SHARE_HEK \ 3850 assert(str) 3851 3852 PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp) 3853 __attribute__nonnull__(pTHX_3); 3854 #define PERL_ARGS_ASSERT_SORTSV \ 3855 assert(cmp) 3856 3857 PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) 3858 __attribute__nonnull__(pTHX_3); 3859 #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ 3860 assert(cmp) 3861 3862 PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, SSize_t n) 3863 __attribute__nonnull__(pTHX_1) 3864 __attribute__nonnull__(pTHX_2); 3865 #define PERL_ARGS_ASSERT_STACK_GROW \ 3866 assert(sp); assert(p) 3867 3868 PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io) 3869 __attribute__nonnull__(pTHX_1) 3870 __attribute__nonnull__(pTHX_2); 3871 #define PERL_ARGS_ASSERT_START_GLOB \ 3872 assert(tmpglob); assert(io) 3873 3874 PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); 3875 PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) 3876 __attribute__warn_unused_result__ 3877 __attribute__nonnull__(pTHX_1); 3878 #define PERL_ARGS_ASSERT_STR_TO_VERSION \ 3879 assert(sv) 3880 3881 PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv) 3882 __attribute__nonnull__(pTHX_1); 3883 #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ 3884 assert(cv) 3885 3886 /* PERL_CALLCONV bool sv_2bool(pTHX_ SV *const sv) 3887 __attribute__nonnull__(pTHX_1); */ 3888 3889 PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags) 3890 __attribute__nonnull__(pTHX_1); 3891 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ 3892 assert(sv) 3893 3894 PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const I32 lref) 3895 __attribute__nonnull__(pTHX_2) 3896 __attribute__nonnull__(pTHX_3); 3897 #define PERL_ARGS_ASSERT_SV_2CV \ 3898 assert(st); assert(gvp) 3899 3900 PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv) 3901 __attribute__nonnull__(pTHX_1); 3902 #define PERL_ARGS_ASSERT_SV_2IO \ 3903 assert(sv) 3904 3905 /* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv) 3906 __attribute__nonnull__(pTHX_1); */ 3907 #define PERL_ARGS_ASSERT_SV_2IV \ 3908 assert(sv) 3909 3910 PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags) 3911 __attribute__nonnull__(pTHX_1); 3912 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ 3913 assert(sv) 3914 3915 PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv); 3916 PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv) 3917 __attribute__nonnull__(pTHX_1); 3918 #define PERL_ARGS_ASSERT_SV_2NUM \ 3919 assert(sv) 3920 3921 PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags) 3922 __attribute__nonnull__(pTHX_1); 3923 #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ 3924 assert(sv) 3925 3926 /* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp) 3927 __attribute__nonnull__(pTHX_1); */ 3928 #define PERL_ARGS_ASSERT_SV_2PV \ 3929 assert(sv) 3930 3931 PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags) 3932 __attribute__nonnull__(pTHX_1); 3933 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ 3934 assert(sv) 3935 3936 /* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv) 3937 __attribute__warn_unused_result__ 3938 __attribute__nonnull__(pTHX_1); */ 3939 #define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ 3940 assert(sv) 3941 3942 PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp) 3943 __attribute__nonnull__(pTHX_1); 3944 #define PERL_ARGS_ASSERT_SV_2PVBYTE \ 3945 assert(sv) 3946 3947 /* PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) 3948 __attribute__warn_unused_result__ 3949 __attribute__nonnull__(pTHX_1); */ 3950 #define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ 3951 assert(sv) 3952 3953 PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp) 3954 __attribute__nonnull__(pTHX_1); 3955 #define PERL_ARGS_ASSERT_SV_2PVUTF8 \ 3956 assert(sv) 3957 3958 /* PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv) 3959 __attribute__warn_unused_result__ 3960 __attribute__nonnull__(pTHX_1); */ 3961 #define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ 3962 assert(sv) 3963 3964 /* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv) 3965 __attribute__nonnull__(pTHX_1); */ 3966 #define PERL_ARGS_ASSERT_SV_2UV \ 3967 assert(sv) 3968 3969 PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags) 3970 __attribute__nonnull__(pTHX_1); 3971 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ 3972 assert(sv) 3973 3974 PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv) 3975 __attribute__nonnull__(pTHX_1); 3976 #define PERL_ARGS_ASSERT_SV_BACKOFF \ 3977 assert(sv) 3978 3979 PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV *const sv, HV *const stash) 3980 __attribute__nonnull__(pTHX_1) 3981 __attribute__nonnull__(pTHX_2); 3982 #define PERL_ARGS_ASSERT_SV_BLESS \ 3983 assert(sv); assert(stash) 3984 3985 PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen) 3986 __attribute__nonnull__(pTHX_1) 3987 __attribute__nonnull__(pTHX_2) 3988 __attribute__nonnull__(pTHX_3) 3989 __attribute__nonnull__(pTHX_4) 3990 __attribute__nonnull__(pTHX_5); 3991 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ 3992 assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) 3993 3994 PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr) 3995 __attribute__nonnull__(pTHX_1); 3996 #define PERL_ARGS_ASSERT_SV_CATPV \ 3997 assert(sv) 3998 3999 PERL_CALLCONV void Perl_sv_catpv_flags(pTHX_ SV *dstr, const char *sstr, const I32 flags) 4000 __attribute__nonnull__(pTHX_1) 4001 __attribute__nonnull__(pTHX_2); 4002 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ 4003 assert(dstr); assert(sstr) 4004 4005 PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr) 4006 __attribute__nonnull__(pTHX_1); 4007 #define PERL_ARGS_ASSERT_SV_CATPV_MG \ 4008 assert(sv) 4009 4010 PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...) 4011 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4012 __attribute__nonnull__(pTHX_1) 4013 __attribute__nonnull__(pTHX_2); 4014 #define PERL_ARGS_ASSERT_SV_CATPVF \ 4015 assert(sv); assert(pat) 4016 4017 PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 4018 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4019 __attribute__nonnull__(pTHX_1) 4020 __attribute__nonnull__(pTHX_2); 4021 #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ 4022 assert(sv); assert(pat) 4023 4024 /* PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len) 4025 __attribute__nonnull__(pTHX_1) 4026 __attribute__nonnull__(pTHX_2); */ 4027 #define PERL_ARGS_ASSERT_SV_CATPVN \ 4028 assert(dsv); assert(sstr) 4029 4030 PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV *const dstr, const char *sstr, const STRLEN len, const I32 flags) 4031 __attribute__nonnull__(pTHX_1) 4032 __attribute__nonnull__(pTHX_2); 4033 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ 4034 assert(dstr); assert(sstr) 4035 4036 /* PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len) 4037 __attribute__nonnull__(pTHX_1) 4038 __attribute__nonnull__(pTHX_2); */ 4039 #define PERL_ARGS_ASSERT_SV_CATPVN_MG \ 4040 assert(sv); assert(ptr) 4041 4042 /* PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr) 4043 __attribute__nonnull__(pTHX_1); */ 4044 #define PERL_ARGS_ASSERT_SV_CATSV \ 4045 assert(dstr) 4046 4047 PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags) 4048 __attribute__nonnull__(pTHX_1); 4049 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ 4050 assert(dsv) 4051 4052 /* PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv) 4053 __attribute__nonnull__(pTHX_1); */ 4054 #define PERL_ARGS_ASSERT_SV_CATSV_MG \ 4055 assert(dsv) 4056 4057 PERL_CALLCONV void Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr) 4058 __attribute__nonnull__(pTHX_1); 4059 #define PERL_ARGS_ASSERT_SV_CHOP \ 4060 assert(sv) 4061 4062 PERL_CALLCONV I32 Perl_sv_clean_all(pTHX); 4063 PERL_CALLCONV void Perl_sv_clean_objs(pTHX); 4064 PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const orig_sv) 4065 __attribute__nonnull__(pTHX_1); 4066 #define PERL_ARGS_ASSERT_SV_CLEAR \ 4067 assert(orig_sv) 4068 4069 PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); 4070 PERL_CALLCONV I32 Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); 4071 PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); 4072 PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags); 4073 /* PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) 4074 __attribute__nonnull__(pTHX_1) 4075 __attribute__nonnull__(pTHX_2); */ 4076 #define PERL_ARGS_ASSERT_SV_COPYPV \ 4077 assert(dsv); assert(ssv) 4078 4079 PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags) 4080 __attribute__nonnull__(pTHX_1) 4081 __attribute__nonnull__(pTHX_2); 4082 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ 4083 assert(dsv); assert(ssv) 4084 4085 /* PERL_CALLCONV void Perl_sv_copypv_nomg(pTHX_ SV *const dsv, SV *const ssv) 4086 __attribute__nonnull__(pTHX_1) 4087 __attribute__nonnull__(pTHX_2); */ 4088 4089 PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); 4090 PERL_CALLCONV void Perl_sv_dec_nomg(pTHX_ SV *const sv); 4091 PERL_CALLCONV void Perl_sv_del_backref(pTHX_ SV *const tsv, SV *const sv) 4092 __attribute__nonnull__(pTHX_1) 4093 __attribute__nonnull__(pTHX_2); 4094 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ 4095 assert(tsv); assert(sv) 4096 4097 PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV* sv, const char *const name) 4098 __attribute__warn_unused_result__ 4099 __attribute__nonnull__(pTHX_1) 4100 __attribute__nonnull__(pTHX_2); 4101 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ 4102 assert(sv); assert(name) 4103 4104 PERL_CALLCONV bool Perl_sv_derived_from_pv(pTHX_ SV* sv, const char *const name, U32 flags) 4105 __attribute__warn_unused_result__ 4106 __attribute__nonnull__(pTHX_1) 4107 __attribute__nonnull__(pTHX_2); 4108 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ 4109 assert(sv); assert(name) 4110 4111 PERL_CALLCONV bool Perl_sv_derived_from_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) 4112 __attribute__warn_unused_result__ 4113 __attribute__nonnull__(pTHX_1) 4114 __attribute__nonnull__(pTHX_2); 4115 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ 4116 assert(sv); assert(name) 4117 4118 PERL_CALLCONV bool Perl_sv_derived_from_sv(pTHX_ SV* sv, SV *namesv, U32 flags) 4119 __attribute__warn_unused_result__ 4120 __attribute__nonnull__(pTHX_1) 4121 __attribute__nonnull__(pTHX_2); 4122 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ 4123 assert(sv); assert(namesv) 4124 4125 PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); 4126 PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name) 4127 __attribute__warn_unused_result__ 4128 __attribute__nonnull__(pTHX_1) 4129 __attribute__nonnull__(pTHX_2); 4130 #define PERL_ARGS_ASSERT_SV_DOES \ 4131 assert(sv); assert(name) 4132 4133 PERL_CALLCONV bool Perl_sv_does_pv(pTHX_ SV* sv, const char *const name, U32 flags) 4134 __attribute__warn_unused_result__ 4135 __attribute__nonnull__(pTHX_1) 4136 __attribute__nonnull__(pTHX_2); 4137 #define PERL_ARGS_ASSERT_SV_DOES_PV \ 4138 assert(sv); assert(name) 4139 4140 PERL_CALLCONV bool Perl_sv_does_pvn(pTHX_ SV* sv, const char *const name, const STRLEN len, U32 flags) 4141 __attribute__warn_unused_result__ 4142 __attribute__nonnull__(pTHX_1) 4143 __attribute__nonnull__(pTHX_2); 4144 #define PERL_ARGS_ASSERT_SV_DOES_PVN \ 4145 assert(sv); assert(name) 4146 4147 PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags) 4148 __attribute__warn_unused_result__ 4149 __attribute__nonnull__(pTHX_1) 4150 __attribute__nonnull__(pTHX_2); 4151 #define PERL_ARGS_ASSERT_SV_DOES_SV \ 4152 assert(sv); assert(namesv) 4153 4154 PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv) 4155 __attribute__nonnull__(pTHX_1); 4156 #define PERL_ARGS_ASSERT_SV_DUMP \ 4157 assert(sv) 4158 4159 /* PERL_CALLCONV I32 sv_eq(pTHX_ SV* sv1, SV* sv2); */ 4160 PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); 4161 /* PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv) 4162 __attribute__nonnull__(pTHX_1); */ 4163 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ 4164 assert(sv) 4165 4166 PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags) 4167 __attribute__nonnull__(pTHX_1); 4168 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ 4169 assert(sv) 4170 4171 PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); 4172 PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt) 4173 __attribute__nonnull__(pTHX_1); 4174 #define PERL_ARGS_ASSERT_SV_FREE2 \ 4175 assert(sv) 4176 4177 PERL_CALLCONV void Perl_sv_free_arenas(pTHX); 4178 PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append) 4179 __attribute__nonnull__(pTHX_1) 4180 __attribute__nonnull__(pTHX_2); 4181 #define PERL_ARGS_ASSERT_SV_GETS \ 4182 assert(sv); assert(fp) 4183 4184 PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen) 4185 __attribute__nonnull__(pTHX_1); 4186 #define PERL_ARGS_ASSERT_SV_GROW \ 4187 assert(sv) 4188 4189 PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv); 4190 PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV *const sv); 4191 /* PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen) 4192 __attribute__nonnull__(pTHX_1) 4193 __attribute__nonnull__(pTHX_4); */ 4194 #define PERL_ARGS_ASSERT_SV_INSERT \ 4195 assert(bigstr); assert(little) 4196 4197 PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags) 4198 __attribute__nonnull__(pTHX_1) 4199 __attribute__nonnull__(pTHX_4); 4200 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ 4201 assert(bigstr); assert(little) 4202 4203 PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name) 4204 __attribute__nonnull__(pTHX_2); 4205 #define PERL_ARGS_ASSERT_SV_ISA \ 4206 assert(name) 4207 4208 PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); 4209 PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) 4210 __attribute__nonnull__(pTHX_1); 4211 #define PERL_ARGS_ASSERT_SV_IV \ 4212 assert(sv) 4213 4214 PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); 4215 PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); 4216 PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv) 4217 __attribute__nonnull__(pTHX_1); 4218 #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ 4219 assert(sv) 4220 4221 PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen) 4222 __attribute__nonnull__(pTHX_1); 4223 #define PERL_ARGS_ASSERT_SV_MAGIC \ 4224 assert(sv) 4225 4226 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) 4227 __attribute__nonnull__(pTHX_1); 4228 #define PERL_ARGS_ASSERT_SV_MAGICEXT \ 4229 assert(sv) 4230 4231 PERL_CALLCONV MAGIC * Perl_sv_magicext_mglob(pTHX_ SV *sv) 4232 __attribute__nonnull__(pTHX_1); 4233 #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ 4234 assert(sv) 4235 4236 /* PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) 4237 __attribute__malloc__ 4238 __attribute__warn_unused_result__; */ 4239 4240 PERL_CALLCONV SV* Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags) 4241 __attribute__malloc__ 4242 __attribute__warn_unused_result__; 4243 4244 PERL_CALLCONV SV* Perl_sv_newmortal(pTHX) 4245 __attribute__warn_unused_result__; 4246 4247 PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv); 4248 /* PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv); */ 4249 PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); 4250 PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv) 4251 __attribute__nonnull__(pTHX_1); 4252 #define PERL_ARGS_ASSERT_SV_NV \ 4253 assert(sv) 4254 4255 PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); 4256 PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp) 4257 __attribute__nonnull__(pTHX_2); 4258 #define PERL_ARGS_ASSERT_SV_POS_B2U \ 4259 assert(offsetp) 4260 4261 PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags) 4262 __attribute__nonnull__(pTHX_1); 4263 #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ 4264 assert(sv) 4265 4266 PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp) 4267 __attribute__nonnull__(pTHX_2); 4268 #define PERL_ARGS_ASSERT_SV_POS_U2B \ 4269 assert(offsetp) 4270 4271 PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags) 4272 __attribute__nonnull__(pTHX_1); 4273 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ 4274 assert(sv) 4275 4276 /* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv) 4277 __attribute__warn_unused_result__ 4278 __attribute__nonnull__(pTHX_1); */ 4279 #define PERL_ARGS_ASSERT_SV_PV \ 4280 assert(sv) 4281 4282 /* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) 4283 __attribute__warn_unused_result__ 4284 __attribute__nonnull__(pTHX_1); */ 4285 #define PERL_ARGS_ASSERT_SV_PVBYTE \ 4286 assert(sv) 4287 4288 PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp) 4289 __attribute__nonnull__(pTHX_1) 4290 __attribute__nonnull__(pTHX_2); 4291 #define PERL_ARGS_ASSERT_SV_PVBYTEN \ 4292 assert(sv); assert(lp) 4293 4294 PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp) 4295 __attribute__nonnull__(pTHX_1); 4296 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ 4297 assert(sv) 4298 4299 PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp) 4300 __attribute__nonnull__(pTHX_1) 4301 __attribute__nonnull__(pTHX_2); 4302 #define PERL_ARGS_ASSERT_SV_PVN \ 4303 assert(sv); assert(lp) 4304 4305 /* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp) 4306 __attribute__nonnull__(pTHX_1); */ 4307 #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ 4308 assert(sv) 4309 4310 PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags) 4311 __attribute__nonnull__(pTHX_1); 4312 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ 4313 assert(sv) 4314 4315 PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp) 4316 __attribute__nonnull__(pTHX_1); 4317 #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ 4318 assert(sv) 4319 4320 /* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) 4321 __attribute__warn_unused_result__ 4322 __attribute__nonnull__(pTHX_1); */ 4323 #define PERL_ARGS_ASSERT_SV_PVUTF8 \ 4324 assert(sv) 4325 4326 PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp) 4327 __attribute__nonnull__(pTHX_1) 4328 __attribute__nonnull__(pTHX_2); 4329 #define PERL_ARGS_ASSERT_SV_PVUTF8N \ 4330 assert(sv); assert(lp) 4331 4332 PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp) 4333 __attribute__nonnull__(pTHX_1); 4334 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ 4335 assert(sv) 4336 4337 PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding) 4338 __attribute__nonnull__(pTHX_1) 4339 __attribute__nonnull__(pTHX_2); 4340 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ 4341 assert(sv); assert(encoding) 4342 4343 PERL_CALLCONV SV* Perl_sv_ref(pTHX_ SV *dst, const SV *const sv, const int ob) 4344 __attribute__nonnull__(pTHX_2); 4345 #define PERL_ARGS_ASSERT_SV_REF \ 4346 assert(sv) 4347 4348 PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob) 4349 __attribute__warn_unused_result__ 4350 __attribute__nonnull__(pTHX_1); 4351 #define PERL_ARGS_ASSERT_SV_REFTYPE \ 4352 assert(sv) 4353 4354 PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv) 4355 __attribute__nonnull__(pTHX_1) 4356 __attribute__nonnull__(pTHX_2); 4357 #define PERL_ARGS_ASSERT_SV_REPLACE \ 4358 assert(sv); assert(nsv) 4359 4360 PERL_CALLCONV void Perl_sv_report_used(pTHX); 4361 PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash) 4362 __attribute__nonnull__(pTHX_1); 4363 #define PERL_ARGS_ASSERT_SV_RESET \ 4364 assert(s) 4365 4366 PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash); 4367 PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv) 4368 __attribute__nonnull__(pTHX_1); 4369 #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ 4370 assert(sv) 4371 4372 PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek) 4373 __attribute__nonnull__(pTHX_1); 4374 #define PERL_ARGS_ASSERT_SV_SETHEK \ 4375 assert(sv) 4376 4377 PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num) 4378 __attribute__nonnull__(pTHX_1); 4379 #define PERL_ARGS_ASSERT_SV_SETIV \ 4380 assert(sv) 4381 4382 PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i) 4383 __attribute__nonnull__(pTHX_1); 4384 #define PERL_ARGS_ASSERT_SV_SETIV_MG \ 4385 assert(sv) 4386 4387 PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num) 4388 __attribute__nonnull__(pTHX_1); 4389 #define PERL_ARGS_ASSERT_SV_SETNV \ 4390 assert(sv) 4391 4392 PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num) 4393 __attribute__nonnull__(pTHX_1); 4394 #define PERL_ARGS_ASSERT_SV_SETNV_MG \ 4395 assert(sv) 4396 4397 PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr) 4398 __attribute__nonnull__(pTHX_1); 4399 #define PERL_ARGS_ASSERT_SV_SETPV \ 4400 assert(sv) 4401 4402 PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr) 4403 __attribute__nonnull__(pTHX_1); 4404 #define PERL_ARGS_ASSERT_SV_SETPV_MG \ 4405 assert(sv) 4406 4407 PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...) 4408 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4409 __attribute__nonnull__(pTHX_1) 4410 __attribute__nonnull__(pTHX_2); 4411 #define PERL_ARGS_ASSERT_SV_SETPVF \ 4412 assert(sv); assert(pat) 4413 4414 PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 4415 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4416 __attribute__nonnull__(pTHX_1) 4417 __attribute__nonnull__(pTHX_2); 4418 #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ 4419 assert(sv); assert(pat) 4420 4421 PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num) 4422 __attribute__nonnull__(pTHX_1); 4423 #define PERL_ARGS_ASSERT_SV_SETPVIV \ 4424 assert(sv) 4425 4426 PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv) 4427 __attribute__nonnull__(pTHX_1); 4428 #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \ 4429 assert(sv) 4430 4431 PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 4432 __attribute__nonnull__(pTHX_1); 4433 #define PERL_ARGS_ASSERT_SV_SETPVN \ 4434 assert(sv) 4435 4436 PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 4437 __attribute__nonnull__(pTHX_1) 4438 __attribute__nonnull__(pTHX_2); 4439 #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ 4440 assert(sv); assert(ptr) 4441 4442 PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv) 4443 __attribute__nonnull__(pTHX_1); 4444 #define PERL_ARGS_ASSERT_SV_SETREF_IV \ 4445 assert(rv) 4446 4447 PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv) 4448 __attribute__nonnull__(pTHX_1); 4449 #define PERL_ARGS_ASSERT_SV_SETREF_NV \ 4450 assert(rv) 4451 4452 PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv) 4453 __attribute__nonnull__(pTHX_1); 4454 #define PERL_ARGS_ASSERT_SV_SETREF_PV \ 4455 assert(rv) 4456 4457 PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n) 4458 __attribute__nonnull__(pTHX_1) 4459 __attribute__nonnull__(pTHX_3); 4460 #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ 4461 assert(rv); assert(pv) 4462 4463 PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv) 4464 __attribute__nonnull__(pTHX_1); 4465 #define PERL_ARGS_ASSERT_SV_SETREF_UV \ 4466 assert(rv) 4467 4468 /* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr) 4469 __attribute__nonnull__(pTHX_1); */ 4470 #define PERL_ARGS_ASSERT_SV_SETSV \ 4471 assert(dstr) 4472 4473 PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags) 4474 __attribute__nonnull__(pTHX_1); 4475 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ 4476 assert(dstr) 4477 4478 PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr) 4479 __attribute__nonnull__(pTHX_1); 4480 #define PERL_ARGS_ASSERT_SV_SETSV_MG \ 4481 assert(dstr) 4482 4483 PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num) 4484 __attribute__nonnull__(pTHX_1); 4485 #define PERL_ARGS_ASSERT_SV_SETUV \ 4486 assert(sv) 4487 4488 PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u) 4489 __attribute__nonnull__(pTHX_1); 4490 #define PERL_ARGS_ASSERT_SV_SETUV_MG \ 4491 assert(sv) 4492 4493 /* PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv) 4494 __attribute__nonnull__(pTHX_1); */ 4495 #define PERL_ARGS_ASSERT_SV_TAINT \ 4496 assert(sv) 4497 4498 PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) 4499 __attribute__warn_unused_result__ 4500 __attribute__nonnull__(pTHX_1); 4501 #define PERL_ARGS_ASSERT_SV_TAINTED \ 4502 assert(sv) 4503 4504 PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); 4505 PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) 4506 __attribute__warn_unused_result__ 4507 __attribute__nonnull__(pTHX_1) 4508 __attribute__nonnull__(pTHX_2); 4509 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ 4510 assert(dsv); assert(ssv) 4511 4512 PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type) 4513 __attribute__nonnull__(pTHX_1); 4514 #define PERL_ARGS_ASSERT_SV_UNMAGIC \ 4515 assert(sv) 4516 4517 PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) 4518 __attribute__nonnull__(pTHX_1); 4519 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ 4520 assert(sv) 4521 4522 /* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv) 4523 __attribute__nonnull__(pTHX_1); */ 4524 #define PERL_ARGS_ASSERT_SV_UNREF \ 4525 assert(sv) 4526 4527 PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags) 4528 __attribute__nonnull__(pTHX_1); 4529 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ 4530 assert(ref) 4531 4532 PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv) 4533 __attribute__nonnull__(pTHX_1); 4534 #define PERL_ARGS_ASSERT_SV_UNTAINT \ 4535 assert(sv) 4536 4537 PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type) 4538 __attribute__nonnull__(pTHX_1); 4539 #define PERL_ARGS_ASSERT_SV_UPGRADE \ 4540 assert(sv) 4541 4542 /* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len) 4543 __attribute__nonnull__(pTHX_1); */ 4544 #define PERL_ARGS_ASSERT_SV_USEPVN \ 4545 assert(sv) 4546 4547 PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags) 4548 __attribute__nonnull__(pTHX_1); 4549 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ 4550 assert(sv) 4551 4552 /* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) 4553 __attribute__nonnull__(pTHX_1); */ 4554 #define PERL_ARGS_ASSERT_SV_USEPVN_MG \ 4555 assert(sv) 4556 4557 PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv) 4558 __attribute__nonnull__(pTHX_1); 4559 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ 4560 assert(sv) 4561 4562 PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok) 4563 __attribute__nonnull__(pTHX_1); 4564 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ 4565 assert(sv) 4566 4567 PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv) 4568 __attribute__nonnull__(pTHX_1); 4569 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ 4570 assert(sv) 4571 4572 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv) 4573 __attribute__nonnull__(pTHX_1); */ 4574 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ 4575 assert(sv) 4576 4577 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags) 4578 __attribute__nonnull__(pTHX_1); */ 4579 4580 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra) 4581 __attribute__nonnull__(pTHX_1); 4582 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ 4583 assert(sv) 4584 4585 /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv) 4586 __attribute__nonnull__(pTHX_1); */ 4587 4588 PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) 4589 __attribute__nonnull__(pTHX_1); 4590 #define PERL_ARGS_ASSERT_SV_UV \ 4591 assert(sv) 4592 4593 PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4594 __attribute__nonnull__(pTHX_1) 4595 __attribute__nonnull__(pTHX_2); 4596 #define PERL_ARGS_ASSERT_SV_VCATPVF \ 4597 assert(sv); assert(pat) 4598 4599 PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4600 __attribute__nonnull__(pTHX_1) 4601 __attribute__nonnull__(pTHX_2); 4602 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ 4603 assert(sv); assert(pat) 4604 4605 PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) 4606 __attribute__nonnull__(pTHX_1) 4607 __attribute__nonnull__(pTHX_2); 4608 #define PERL_ARGS_ASSERT_SV_VCATPVFN \ 4609 assert(sv); assert(pat) 4610 4611 PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags) 4612 __attribute__nonnull__(pTHX_1) 4613 __attribute__nonnull__(pTHX_2); 4614 #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ 4615 assert(sv); assert(pat) 4616 4617 PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4618 __attribute__nonnull__(pTHX_1) 4619 __attribute__nonnull__(pTHX_2); 4620 #define PERL_ARGS_ASSERT_SV_VSETPVF \ 4621 assert(sv); assert(pat) 4622 4623 PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4624 __attribute__nonnull__(pTHX_1) 4625 __attribute__nonnull__(pTHX_2); 4626 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ 4627 assert(sv); assert(pat) 4628 4629 PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) 4630 __attribute__nonnull__(pTHX_1) 4631 __attribute__nonnull__(pTHX_2); 4632 #define PERL_ARGS_ASSERT_SV_VSETPVFN \ 4633 assert(sv); assert(pat) 4634 4635 PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8) 4636 __attribute__nonnull__(pTHX_1) 4637 __attribute__nonnull__(pTHX_2); 4638 #define PERL_ARGS_ASSERT_SWASH_FETCH \ 4639 assert(swash); assert(ptr) 4640 4641 PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none) 4642 __attribute__warn_unused_result__ 4643 __attribute__nonnull__(pTHX_1) 4644 __attribute__nonnull__(pTHX_2) 4645 __attribute__nonnull__(pTHX_3); 4646 #define PERL_ARGS_ASSERT_SWASH_INIT \ 4647 assert(pkg); assert(name); assert(listsv) 4648 4649 /* PERL_CALLCONV void sync_locale(void); */ 4650 PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv) 4651 __attribute__nonnull__(1) 4652 __attribute__nonnull__(2); 4653 #define PERL_ARGS_ASSERT_SYS_INIT \ 4654 assert(argc); assert(argv) 4655 4656 PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env) 4657 __attribute__nonnull__(1) 4658 __attribute__nonnull__(2) 4659 __attribute__nonnull__(3); 4660 #define PERL_ARGS_ASSERT_SYS_INIT3 \ 4661 assert(argc); assert(argv); assert(env) 4662 4663 PERL_CALLCONV void Perl_sys_term(void); 4664 PERL_CALLCONV void Perl_taint_env(pTHX); 4665 PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s) 4666 __attribute__nonnull__(pTHX_2); 4667 #define PERL_ARGS_ASSERT_TAINT_PROPER \ 4668 assert(s) 4669 4670 PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...) 4671 __attribute__nonnull__(pTHX_1) 4672 __attribute__nonnull__(pTHX_2) 4673 __attribute__nonnull__(pTHX_3) 4674 __attribute__nonnull__(pTHX_4); 4675 #define PERL_ARGS_ASSERT_TIED_METHOD \ 4676 assert(methname); assert(sp); assert(sv); assert(mg) 4677 4678 PERL_CALLCONV void Perl_tmps_grow(pTHX_ SSize_t n); 4679 /* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) 4680 __attribute__nonnull__(pTHX_2) 4681 __attribute__nonnull__(pTHX_3); */ 4682 4683 PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) 4684 __attribute__nonnull__(pTHX_2) 4685 __attribute__nonnull__(pTHX_3); 4686 #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ 4687 assert(p); assert(lenp) 4688 4689 PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) 4690 __attribute__deprecated__ 4691 __attribute__warn_unused_result__ 4692 __attribute__pure__; 4693 4694 PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) 4695 __attribute__nonnull__(pTHX_2) 4696 __attribute__nonnull__(pTHX_3); 4697 #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ 4698 assert(p); assert(lenp) 4699 4700 PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) 4701 __attribute__deprecated__ 4702 __attribute__warn_unused_result__ 4703 __attribute__pure__; 4704 4705 PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) 4706 __attribute__nonnull__(pTHX_2) 4707 __attribute__nonnull__(pTHX_3); 4708 #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ 4709 assert(p); assert(lenp) 4710 4711 PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) 4712 __attribute__deprecated__ 4713 __attribute__warn_unused_result__ 4714 __attribute__pure__; 4715 4716 PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special) 4717 __attribute__nonnull__(pTHX_1) 4718 __attribute__nonnull__(pTHX_2) 4719 __attribute__nonnull__(pTHX_4) 4720 __attribute__nonnull__(pTHX_5); 4721 #define PERL_ARGS_ASSERT_TO_UTF8_CASE \ 4722 assert(p); assert(ustrp); assert(swashp); assert(normal) 4723 4724 /* PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4725 __attribute__nonnull__(pTHX_1) 4726 __attribute__nonnull__(pTHX_2); */ 4727 #define PERL_ARGS_ASSERT_TO_UTF8_FOLD \ 4728 assert(p); assert(ustrp) 4729 4730 /* PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4731 __attribute__nonnull__(pTHX_1) 4732 __attribute__nonnull__(pTHX_2); */ 4733 #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \ 4734 assert(p); assert(ustrp) 4735 4736 /* PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4737 __attribute__nonnull__(pTHX_1) 4738 __attribute__nonnull__(pTHX_2); */ 4739 #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \ 4740 assert(p); assert(ustrp) 4741 4742 /* PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4743 __attribute__nonnull__(pTHX_1) 4744 __attribute__nonnull__(pTHX_2); */ 4745 #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \ 4746 assert(p); assert(ustrp) 4747 4748 PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); 4749 PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); 4750 PERL_CALLCONV I32 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) 4751 __attribute__nonnull__(pTHX_1) 4752 __attribute__nonnull__(pTHX_2) 4753 __attribute__nonnull__(pTHX_3) 4754 __attribute__nonnull__(pTHX_5); 4755 #define PERL_ARGS_ASSERT_UNPACK_STR \ 4756 assert(pat); assert(patend); assert(s); assert(strend) 4757 4758 PERL_CALLCONV I32 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) 4759 __attribute__nonnull__(pTHX_1) 4760 __attribute__nonnull__(pTHX_2) 4761 __attribute__nonnull__(pTHX_3) 4762 __attribute__nonnull__(pTHX_4); 4763 #define PERL_ARGS_ASSERT_UNPACKSTRING \ 4764 assert(pat); assert(patend); assert(s); assert(strend) 4765 4766 PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); 4767 PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); 4768 PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv) 4769 __attribute__nonnull__(pTHX_1); 4770 #define PERL_ARGS_ASSERT_UPG_VERSION \ 4771 assert(ver) 4772 4773 PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 4774 __attribute__nonnull__(pTHX_1) 4775 __attribute__nonnull__(pTHX_2) 4776 __attribute__nonnull__(pTHX_4); 4777 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ 4778 assert(p); assert(d); assert(newlen) 4779 4780 PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 4781 __attribute__nonnull__(pTHX_1) 4782 __attribute__nonnull__(pTHX_2) 4783 __attribute__nonnull__(pTHX_4); 4784 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ 4785 assert(p); assert(d); assert(newlen) 4786 4787 PERL_CALLCONV IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) 4788 __attribute__warn_unused_result__ 4789 __attribute__pure__ 4790 __attribute__nonnull__(pTHX_1) 4791 __attribute__nonnull__(pTHX_2); 4792 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ 4793 assert(a); assert(b) 4794 4795 PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off) 4796 __attribute__warn_unused_result__ 4797 __attribute__pure__ 4798 __attribute__nonnull__(pTHX_1); 4799 #define PERL_ARGS_ASSERT_UTF8_HOP \ 4800 assert(s) 4801 4802 PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) 4803 __attribute__warn_unused_result__ 4804 __attribute__pure__ 4805 __attribute__nonnull__(pTHX_1) 4806 __attribute__nonnull__(pTHX_2); 4807 #define PERL_ARGS_ASSERT_UTF8_LENGTH \ 4808 assert(s); assert(e) 4809 4810 PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *len) 4811 __attribute__nonnull__(pTHX_1) 4812 __attribute__nonnull__(pTHX_2); 4813 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ 4814 assert(s); assert(len) 4815 4816 PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 4817 __attribute__deprecated__ 4818 __attribute__nonnull__(pTHX_1); 4819 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ 4820 assert(s) 4821 4822 /* PERL_CALLCONV UV utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) 4823 __attribute__nonnull__(pTHX_1) 4824 __attribute__nonnull__(pTHX_2); */ 4825 4826 PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4827 __attribute__deprecated__ 4828 __attribute__nonnull__(pTHX_1); 4829 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ 4830 assert(s) 4831 4832 PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) 4833 __attribute__deprecated__ 4834 __attribute__nonnull__(pTHX_1) 4835 __attribute__nonnull__(pTHX_2); 4836 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \ 4837 assert(s); assert(send) 4838 4839 PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 4840 __attribute__nonnull__(pTHX_1); 4841 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 4842 assert(s) 4843 4844 PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 4845 __attribute__nonnull__(pTHX_1); 4846 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ 4847 assert(s) 4848 4849 /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv) 4850 __attribute__nonnull__(pTHX_1); */ 4851 4852 /* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4853 __attribute__nonnull__(pTHX_1); */ 4854 4855 PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4856 __attribute__nonnull__(pTHX_1); 4857 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ 4858 assert(d) 4859 4860 PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) 4861 __attribute__nonnull__(pTHX_1); 4862 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ 4863 assert(d) 4864 4865 PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4866 __attribute__nonnull__(pTHX_1); 4867 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ 4868 assert(d) 4869 4870 PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 4871 __attribute__nonnull__(pTHX_1); 4872 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ 4873 assert(s) 4874 4875 PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4876 __attribute__deprecated__ 4877 __attribute__nonnull__(pTHX_1); 4878 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ 4879 assert(s) 4880 4881 PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn) 4882 __attribute__nonnull__(pTHX_1); 4883 #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ 4884 assert(name) 4885 4886 PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) 4887 __attribute__nonnull__(pTHX_1) 4888 __attribute__nonnull__(pTHX_2); 4889 #define PERL_ARGS_ASSERT_VCMP \ 4890 assert(lhv); assert(rhv) 4891 4892 PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args) 4893 __attribute__noreturn__; 4894 4895 PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args) 4896 __attribute__nonnull__(pTHX_1); 4897 #define PERL_ARGS_ASSERT_VDEB \ 4898 assert(pat) 4899 4900 PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args) 4901 __attribute__nonnull__(pTHX_1); 4902 #define PERL_ARGS_ASSERT_VFORM \ 4903 assert(pat) 4904 4905 PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv) 4906 __attribute__nonnull__(pTHX_1); 4907 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ 4908 assert(sv) 4909 4910 PERL_CALLCONV SV* Perl_vivify_ref(pTHX_ SV* sv, U32 to_what) 4911 __attribute__warn_unused_result__ 4912 __attribute__nonnull__(pTHX_1); 4913 #define PERL_ARGS_ASSERT_VIVIFY_REF \ 4914 assert(sv) 4915 4916 PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args) 4917 __attribute__nonnull__(pTHX_2); 4918 #define PERL_ARGS_ASSERT_VLOAD_MODULE \ 4919 assert(name) 4920 4921 PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args) 4922 __attribute__nonnull__(pTHX_1); 4923 #define PERL_ARGS_ASSERT_VMESS \ 4924 assert(pat) 4925 4926 PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args) 4927 __attribute__malloc__ 4928 __attribute__warn_unused_result__ 4929 __attribute__nonnull__(pTHX_1); 4930 #define PERL_ARGS_ASSERT_VNEWSVPVF \ 4931 assert(pat) 4932 4933 PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs) 4934 __attribute__nonnull__(pTHX_1); 4935 #define PERL_ARGS_ASSERT_VNORMAL \ 4936 assert(vs) 4937 4938 PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs) 4939 __attribute__nonnull__(pTHX_1); 4940 #define PERL_ARGS_ASSERT_VNUMIFY \ 4941 assert(vs) 4942 4943 PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs) 4944 __attribute__nonnull__(pTHX_1); 4945 #define PERL_ARGS_ASSERT_VSTRINGIFY \ 4946 assert(vs) 4947 4948 PERL_CALLCONV SV* Perl_vverify(pTHX_ SV *vs) 4949 __attribute__nonnull__(pTHX_1); 4950 #define PERL_ARGS_ASSERT_VVERIFY \ 4951 assert(vs) 4952 4953 PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args) 4954 __attribute__nonnull__(pTHX_1); 4955 #define PERL_ARGS_ASSERT_VWARN \ 4956 assert(pat) 4957 4958 PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args) 4959 __attribute__nonnull__(pTHX_2); 4960 #define PERL_ARGS_ASSERT_VWARNER \ 4961 assert(pat) 4962 4963 PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags) 4964 __attribute__nonnull__(pTHX_2); 4965 #define PERL_ARGS_ASSERT_WAIT4PID \ 4966 assert(statusp) 4967 4968 PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...) 4969 __attribute__format__(__printf__,pTHX_1,pTHX_2) 4970 __attribute__nonnull__(pTHX_1); 4971 #define PERL_ARGS_ASSERT_WARN \ 4972 assert(pat) 4973 4974 PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex) 4975 __attribute__nonnull__(pTHX_1); 4976 #define PERL_ARGS_ASSERT_WARN_SV \ 4977 assert(baseex) 4978 4979 PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) 4980 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4981 __attribute__nonnull__(pTHX_2); 4982 #define PERL_ARGS_ASSERT_WARNER \ 4983 assert(pat) 4984 4985 PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) 4986 __attribute__warn_unused_result__; 4987 4988 PERL_CALLCONV void Perl_watch(pTHX_ char** addr) 4989 __attribute__nonnull__(pTHX_1); 4990 #define PERL_ARGS_ASSERT_WATCH \ 4991 assert(addr) 4992 4993 /* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig) 4994 __attribute__nonnull__(pTHX_1); */ 4995 4996 PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig) 4997 __attribute__nonnull__(pTHX_1); 4998 #define PERL_ARGS_ASSERT_WHICHSIG_PV \ 4999 assert(sig) 5000 5001 PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char* sig, STRLEN len) 5002 __attribute__nonnull__(pTHX_1); 5003 #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ 5004 assert(sig) 5005 5006 PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV* sigsv) 5007 __attribute__nonnull__(pTHX_1); 5008 #define PERL_ARGS_ASSERT_WHICHSIG_SV \ 5009 assert(sigsv) 5010 5011 PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p) 5012 __attribute__nonnull__(pTHX_2) 5013 __attribute__nonnull__(pTHX_3); 5014 #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ 5015 assert(new_checker); assert(old_checker_p) 5016 5017 PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv) 5018 __attribute__nonnull__(pTHX_1); 5019 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ 5020 assert(msv) 5021 5022 PERL_CALLCONV void Perl_xs_apiversion_bootcheck(pTHX_ SV *module, const char *api_p, STRLEN api_len) 5023 __attribute__nonnull__(pTHX_1) 5024 __attribute__nonnull__(pTHX_2); 5025 #define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK \ 5026 assert(module); assert(api_p) 5027 5028 PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len) 5029 __attribute__nonnull__(pTHX_3); 5030 #define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ 5031 assert(xs_p) 5032 5033 PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s) 5034 __attribute__nonnull__(pTHX_1); 5035 #define PERL_ARGS_ASSERT_YYERROR \ 5036 assert(s) 5037 5038 PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags) 5039 __attribute__nonnull__(pTHX_1); 5040 #define PERL_ARGS_ASSERT_YYERROR_PV \ 5041 assert(s) 5042 5043 PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags) 5044 __attribute__nonnull__(pTHX_1); 5045 #define PERL_ARGS_ASSERT_YYERROR_PVN \ 5046 assert(s) 5047 5048 PERL_CALLCONV int Perl_yylex(pTHX); 5049 PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); 5050 PERL_CALLCONV void Perl_yyunlex(pTHX); 5051 #if !(defined(DEBUGGING)) 5052 # if !defined(NV_PRESERVES_UV) 5053 # if defined(PERL_IN_SV_C) 5054 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv) 5055 __attribute__nonnull__(pTHX_1); 5056 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5057 assert(sv) 5058 5059 # endif 5060 # endif 5061 #endif 5062 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) 5063 PERL_CALLCONV Signal_t Perl_csighandler(int sig); 5064 PERL_CALLCONV Signal_t Perl_sighandler(int sig); 5065 #endif 5066 #if !(defined(NO_MATHOMS)) 5067 PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); 5068 #endif 5069 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) 5070 PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 5071 __attribute__nonnull__(pTHX_1); 5072 #define PERL_ARGS_ASSERT_DO_EXEC \ 5073 assert(cmd) 5074 5075 #endif 5076 #if !(defined(PERL_GLOBAL_STRUCT_PRIVATE)) 5077 # if defined(PERL_IMPLICIT_CONTEXT) 5078 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) 5079 __attribute__nonnull__(pTHX_1); 5080 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 5081 assert(index) 5082 5083 # endif 5084 #endif 5085 #if !(defined(PERL_MAD)) 5086 PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 5087 PERL_CALLCONV void Perl_package(pTHX_ OP* o) 5088 __attribute__nonnull__(pTHX_1); 5089 #define PERL_ARGS_ASSERT_PACKAGE \ 5090 assert(o) 5091 5092 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 5093 __attribute__nonnull__(pTHX_4); 5094 #define PERL_ARGS_ASSERT_UTILIZE \ 5095 assert(idop) 5096 5097 #endif 5098 #if !(defined(WIN32)) 5099 /* PERL_CALLCONV char* my_setlocale(pTHX_ int category, const char* locale) 5100 __attribute__pure__; */ 5101 5102 #endif 5103 #if !(defined(_MSC_VER)) 5104 PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 5105 __attribute__noreturn__ 5106 __attribute__nonnull__(pTHX_1) 5107 __attribute__nonnull__(pTHX_2); 5108 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 5109 assert(sv); assert(mg) 5110 5111 #endif 5112 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) 5113 PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) 5114 __attribute__nonnull__(1); 5115 #define PERL_ARGS_ASSERT_MY_BZERO \ 5116 assert(loc) 5117 5118 #endif 5119 #if !defined(HAS_GETENV_LEN) 5120 PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) 5121 __attribute__nonnull__(pTHX_1) 5122 __attribute__nonnull__(pTHX_2); 5123 #define PERL_ARGS_ASSERT_GETENV_LEN \ 5124 assert(env_elem); assert(len) 5125 5126 #endif 5127 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) 5128 PERL_CALLCONV I32 Perl_my_memcmp(const char* s1, const char* s2, I32 len) 5129 __attribute__pure__ 5130 __attribute__nonnull__(1) 5131 __attribute__nonnull__(2); 5132 #define PERL_ARGS_ASSERT_MY_MEMCMP \ 5133 assert(s1); assert(s2) 5134 5135 #endif 5136 #if !defined(HAS_MEMSET) 5137 PERL_CALLCONV void* Perl_my_memset(char* loc, I32 ch, I32 len) 5138 __attribute__nonnull__(1); 5139 #define PERL_ARGS_ASSERT_MY_MEMSET \ 5140 assert(loc) 5141 5142 #endif 5143 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) 5144 # if defined(PERL_IN_PP_SYS_C) 5145 STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) 5146 __attribute__warn_unused_result__ 5147 __attribute__nonnull__(pTHX_1) 5148 __attribute__nonnull__(pTHX_2); 5149 #define PERL_ARGS_ASSERT_DOONELINER \ 5150 assert(cmd); assert(filename) 5151 5152 # endif 5153 #endif 5154 #if !defined(HAS_RENAME) 5155 PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b) 5156 __attribute__nonnull__(pTHX_1) 5157 __attribute__nonnull__(pTHX_2); 5158 #define PERL_ARGS_ASSERT_SAME_DIRENT \ 5159 assert(a); assert(b) 5160 5161 #endif 5162 #if !defined(HAS_SIGNBIT) 5163 PERL_CALLCONV int Perl_signbit(NV f) 5164 __attribute__pure__; 5165 5166 #endif 5167 #if !defined(HAS_STRLCAT) 5168 PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); 5169 #endif 5170 #if !defined(HAS_STRLCPY) 5171 PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); 5172 #endif 5173 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) 5174 PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) 5175 __attribute__warn_unused_result__; 5176 5177 #endif 5178 #if !defined(NV_PRESERVES_UV) 5179 # if defined(DEBUGGING) 5180 # if defined(PERL_IN_SV_C) 5181 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype) 5182 __attribute__nonnull__(pTHX_1); 5183 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5184 assert(sv) 5185 5186 # endif 5187 # endif 5188 #endif 5189 #if !defined(PERL_DISABLE_PMC) 5190 # if defined(PERL_IN_PP_CTL_C) 5191 STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) 5192 __attribute__warn_unused_result__ 5193 __attribute__nonnull__(pTHX_1); 5194 #define PERL_ARGS_ASSERT_DOOPEN_PM \ 5195 assert(name) 5196 5197 # endif 5198 #endif 5199 #if !defined(PERL_IMPLICIT_SYS) 5200 PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); 5201 PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode) 5202 __attribute__nonnull__(pTHX_1) 5203 __attribute__nonnull__(pTHX_2); 5204 #define PERL_ARGS_ASSERT_MY_POPEN \ 5205 assert(cmd); assert(mode) 5206 5207 #endif 5208 #if !defined(PERL_IS_MINIPERL) 5209 # if defined(PERL_IN_PERL_C) 5210 STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem) 5211 __attribute__nonnull__(pTHX_1) 5212 __attribute__nonnull__(pTHX_2) 5213 __attribute__nonnull__(pTHX_3); 5214 #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ 5215 assert(av); assert(dir); assert(stem) 5216 5217 # endif 5218 #endif 5219 #if !defined(PERL_NO_UTF16_FILTER) 5220 # if defined(PERL_IN_TOKE_C) 5221 STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed) 5222 __attribute__nonnull__(pTHX_1); 5223 #define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ 5224 assert(s) 5225 5226 STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) 5227 __attribute__nonnull__(pTHX_2); 5228 #define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ 5229 assert(sv) 5230 5231 # endif 5232 #endif 5233 #if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) 5234 # if defined(PERL_IN_PERL_C) 5235 STATIC void S_validate_suid(pTHX_ PerlIO *rsfp) 5236 __attribute__nonnull__(pTHX_1); 5237 #define PERL_ARGS_ASSERT_VALIDATE_SUID \ 5238 assert(rsfp) 5239 5240 # endif 5241 #endif 5242 #if !defined(SPRINTF_RETURNS_STRLEN) 5243 PERL_CALLCONV int Perl_my_sprintf(char *buffer, const char *pat, ...) 5244 __attribute__nonnull__(1) 5245 __attribute__nonnull__(2); 5246 #define PERL_ARGS_ASSERT_MY_SPRINTF \ 5247 assert(buffer); assert(pat) 5248 5249 #endif 5250 #if !defined(WIN32) 5251 PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) 5252 __attribute__nonnull__(pTHX_1); 5253 #define PERL_ARGS_ASSERT_DO_EXEC3 \ 5254 assert(incmd) 5255 5256 #endif 5257 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY)) 5258 PERL_CALLCONV char* Perl_my_bcopy(const char* from, char* to, I32 len) 5259 __attribute__nonnull__(1) 5260 __attribute__nonnull__(2); 5261 #define PERL_ARGS_ASSERT_MY_BCOPY \ 5262 assert(from); assert(to) 5263 5264 #endif 5265 #if defined(DEBUGGING) 5266 PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) 5267 __attribute__warn_unused_result__ 5268 __attribute__nonnull__(pTHX_1); 5269 #define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ 5270 assert(s) 5271 5272 PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv) 5273 __attribute__nonnull__(pTHX_1); 5274 #define PERL_ARGS_ASSERT_HV_ASSERT \ 5275 assert(hv) 5276 5277 PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv) 5278 __attribute__nonnull__(pTHX_2); 5279 #define PERL_ARGS_ASSERT_PAD_SETSV \ 5280 assert(sv) 5281 5282 PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); 5283 # if defined(PERL_IN_PAD_C) 5284 STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) 5285 __attribute__nonnull__(pTHX_1) 5286 __attribute__nonnull__(pTHX_2); 5287 #define PERL_ARGS_ASSERT_CV_DUMP \ 5288 assert(cv); assert(title) 5289 5290 # endif 5291 # if defined(PERL_IN_REGCOMP_C) 5292 STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth) 5293 __attribute__nonnull__(pTHX_1) 5294 __attribute__nonnull__(pTHX_3); 5295 #define PERL_ARGS_ASSERT_DUMP_TRIE \ 5296 assert(trie); assert(revcharmap) 5297 5298 STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5299 __attribute__nonnull__(pTHX_1) 5300 __attribute__nonnull__(pTHX_3); 5301 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ 5302 assert(trie); assert(revcharmap) 5303 5304 STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5305 __attribute__nonnull__(pTHX_1) 5306 __attribute__nonnull__(pTHX_3); 5307 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ 5308 assert(trie); assert(revcharmap) 5309 5310 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) 5311 __attribute__nonnull__(pTHX_1) 5312 __attribute__nonnull__(pTHX_2) 5313 __attribute__nonnull__(pTHX_3) 5314 __attribute__nonnull__(pTHX_6); 5315 #define PERL_ARGS_ASSERT_DUMPUNTIL \ 5316 assert(r); assert(start); assert(node); assert(sv) 5317 5318 STATIC void S_put_byte(pTHX_ SV* sv, int c) 5319 __attribute__nonnull__(pTHX_1); 5320 #define PERL_ARGS_ASSERT_PUT_BYTE \ 5321 assert(sv) 5322 5323 STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap) 5324 __attribute__nonnull__(pTHX_1) 5325 __attribute__nonnull__(pTHX_2); 5326 #define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \ 5327 assert(sv); assert(bitmap) 5328 5329 STATIC void S_put_range(pTHX_ SV* sv, UV start, UV end) 5330 __attribute__nonnull__(pTHX_1); 5331 #define PERL_ARGS_ASSERT_PUT_RANGE \ 5332 assert(sv) 5333 5334 STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); 5335 STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags); 5336 STATIC U8 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 5337 __attribute__nonnull__(pTHX_1) 5338 __attribute__nonnull__(pTHX_2) 5339 __attribute__nonnull__(pTHX_3); 5340 #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ 5341 assert(pRExC_state); assert(p); assert(val) 5342 5343 # endif 5344 # if defined(PERL_IN_REGEXEC_C) 5345 STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) 5346 __attribute__nonnull__(pTHX_1) 5347 __attribute__nonnull__(pTHX_3) 5348 __attribute__nonnull__(pTHX_4) 5349 __attribute__nonnull__(pTHX_5); 5350 #define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ 5351 assert(prog); assert(start); assert(end); assert(blurb) 5352 5353 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) 5354 __attribute__nonnull__(pTHX_1) 5355 __attribute__nonnull__(pTHX_2) 5356 __attribute__nonnull__(pTHX_3) 5357 __attribute__nonnull__(pTHX_4) 5358 __attribute__nonnull__(pTHX_5); 5359 #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ 5360 assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry) 5361 5362 # endif 5363 # if defined(PERL_IN_SV_C) 5364 STATIC void S_del_sv(pTHX_ SV *p) 5365 __attribute__nonnull__(pTHX_1); 5366 #define PERL_ARGS_ASSERT_DEL_SV \ 5367 assert(p) 5368 5369 # endif 5370 # if defined(PERL_IN_TOKE_C) 5371 STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s) 5372 __attribute__format__(__printf__,pTHX_1,0) 5373 __attribute__nonnull__(pTHX_1) 5374 __attribute__nonnull__(pTHX_2); 5375 #define PERL_ARGS_ASSERT_PRINTBUF \ 5376 assert(fmt); assert(s) 5377 5378 STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp) 5379 __attribute__nonnull__(pTHX_2); 5380 #define PERL_ARGS_ASSERT_TOKEREPORT \ 5381 assert(lvalp) 5382 5383 # endif 5384 #endif 5385 #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) 5386 PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) 5387 __attribute__nonnull__(pTHX_1); 5388 #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ 5389 assert(sv) 5390 5391 #endif 5392 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) 5393 PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp) 5394 __attribute__nonnull__(pTHX_2) 5395 __attribute__nonnull__(pTHX_3); 5396 #define PERL_ARGS_ASSERT_DO_IPCCTL \ 5397 assert(mark); assert(sp) 5398 5399 PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV** mark, SV** sp) 5400 __attribute__nonnull__(pTHX_2) 5401 __attribute__nonnull__(pTHX_3); 5402 #define PERL_ARGS_ASSERT_DO_IPCGET \ 5403 assert(mark); assert(sp) 5404 5405 PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV** mark, SV** sp) 5406 __attribute__nonnull__(pTHX_1) 5407 __attribute__nonnull__(pTHX_2); 5408 #define PERL_ARGS_ASSERT_DO_MSGRCV \ 5409 assert(mark); assert(sp) 5410 5411 PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV** mark, SV** sp) 5412 __attribute__nonnull__(pTHX_1) 5413 __attribute__nonnull__(pTHX_2); 5414 #define PERL_ARGS_ASSERT_DO_MSGSND \ 5415 assert(mark); assert(sp) 5416 5417 PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV** mark, SV** sp) 5418 __attribute__nonnull__(pTHX_1) 5419 __attribute__nonnull__(pTHX_2); 5420 #define PERL_ARGS_ASSERT_DO_SEMOP \ 5421 assert(mark); assert(sp) 5422 5423 PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp) 5424 __attribute__nonnull__(pTHX_2) 5425 __attribute__nonnull__(pTHX_3); 5426 #define PERL_ARGS_ASSERT_DO_SHMIO \ 5427 assert(mark); assert(sp) 5428 5429 #endif 5430 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) 5431 PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap); 5432 PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap); 5433 #endif 5434 #if defined(HAVE_INTERP_INTERN) 5435 PERL_CALLCONV void Perl_sys_intern_clear(pTHX); 5436 PERL_CALLCONV void Perl_sys_intern_init(pTHX); 5437 # if defined(USE_ITHREADS) 5438 PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst) 5439 __attribute__nonnull__(pTHX_1) 5440 __attribute__nonnull__(pTHX_2); 5441 #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ 5442 assert(src); assert(dst) 5443 5444 # endif 5445 #endif 5446 #if defined(MYMALLOC) 5447 PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s) 5448 __attribute__nonnull__(pTHX_1); 5449 #define PERL_ARGS_ASSERT_DUMP_MSTATS \ 5450 assert(s) 5451 5452 PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) 5453 __attribute__nonnull__(pTHX_1); 5454 #define PERL_ARGS_ASSERT_GET_MSTATS \ 5455 assert(buf) 5456 5457 PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) 5458 __attribute__warn_unused_result__; 5459 5460 PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) 5461 __attribute__warn_unused_result__ 5462 __attribute__nonnull__(1); 5463 #define PERL_ARGS_ASSERT_MALLOCED_SIZE \ 5464 assert(p) 5465 5466 #endif 5467 #if defined(NO_MATHOMS) 5468 /* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */ 5469 #endif 5470 #if defined(PERL_ANY_COW) 5471 PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) 5472 __attribute__nonnull__(pTHX_2); 5473 #define PERL_ARGS_ASSERT_SV_SETSV_COW \ 5474 assert(sstr) 5475 5476 #endif 5477 #if defined(PERL_CORE) 5478 PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) 5479 __attribute__nonnull__(pTHX_1); 5480 #define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ 5481 assert(slab) 5482 5483 PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) 5484 __attribute__nonnull__(pTHX_1); 5485 #define PERL_ARGS_ASSERT_OPSLAB_FREE \ 5486 assert(slab) 5487 5488 PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) 5489 __attribute__nonnull__(pTHX_1); 5490 #define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ 5491 assert(slab) 5492 5493 PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) 5494 __attribute__nonnull__(pTHX_1) 5495 __attribute__nonnull__(pTHX_2); 5496 #define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ 5497 assert(parser); assert(slab) 5498 5499 # if defined(PERL_DEBUG_READONLY_OPS) 5500 PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab) 5501 __attribute__nonnull__(pTHX_1); 5502 #define PERL_ARGS_ASSERT_SLAB_TO_RO \ 5503 assert(slab) 5504 5505 PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab) 5506 __attribute__nonnull__(pTHX_1); 5507 #define PERL_ARGS_ASSERT_SLAB_TO_RW \ 5508 assert(slab) 5509 5510 # endif 5511 #endif 5512 #if defined(PERL_CORE) || defined (PERL_EXT) 5513 PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) 5514 __attribute__nonnull__(pTHX_1) 5515 __attribute__nonnull__(pTHX_2); 5516 #define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ 5517 assert(sv); assert(pv) 5518 5519 #endif 5520 #if defined(PERL_CR_FILTER) 5521 # if defined(PERL_IN_TOKE_C) 5522 STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); 5523 STATIC void S_strip_return(pTHX_ SV *sv) 5524 __attribute__nonnull__(pTHX_1); 5525 #define PERL_ARGS_ASSERT_STRIP_RETURN \ 5526 assert(sv) 5527 5528 # endif 5529 #endif 5530 #if defined(PERL_DEBUG_READONLY_COW) 5531 PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv) 5532 __attribute__nonnull__(pTHX_1); 5533 #define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ 5534 assert(sv) 5535 5536 # if defined(PERL_IN_SV_C) 5537 STATIC void S_sv_buf_to_rw(pTHX_ SV *sv) 5538 __attribute__nonnull__(pTHX_1); 5539 #define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ 5540 assert(sv) 5541 5542 # endif 5543 #endif 5544 #if defined(PERL_DEBUG_READONLY_OPS) 5545 PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) 5546 __attribute__nonnull__(pTHX_1); 5547 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ 5548 assert(o) 5549 5550 PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); 5551 #endif 5552 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) 5553 /* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 5554 __attribute__nonnull__(pTHX_1); */ 5555 5556 #endif 5557 #if defined(PERL_DONT_CREATE_GVSV) 5558 /* PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); */ 5559 #endif 5560 #if defined(PERL_GLOBAL_STRUCT) 5561 PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX); 5562 PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp) 5563 __attribute__nonnull__(pTHX_1); 5564 #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \ 5565 assert(plvarsp) 5566 5567 PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX); 5568 #endif 5569 #if defined(PERL_GLOBAL_STRUCT_PRIVATE) 5570 # if defined(PERL_IMPLICIT_CONTEXT) 5571 PERL_CALLCONV int Perl_my_cxt_index(pTHX_ const char *my_cxt_key) 5572 __attribute__nonnull__(pTHX_1); 5573 #define PERL_ARGS_ASSERT_MY_CXT_INDEX \ 5574 assert(my_cxt_key) 5575 5576 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size) 5577 __attribute__nonnull__(pTHX_1); 5578 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 5579 assert(my_cxt_key) 5580 5581 # endif 5582 #endif 5583 #if defined(PERL_IMPLICIT_CONTEXT) 5584 PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...) 5585 __attribute__noreturn__ 5586 __attribute__format__null_ok__(__printf__,1,2); 5587 5588 PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) 5589 __attribute__format__(__printf__,1,2) 5590 __attribute__nonnull__(1); 5591 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ 5592 assert(pat) 5593 5594 PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) 5595 __attribute__format__null_ok__(__printf__,1,2); 5596 5597 PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) 5598 __attribute__format__(__printf__,1,2) 5599 __attribute__nonnull__(1); 5600 #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ 5601 assert(pat) 5602 5603 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) 5604 __attribute__format__(__printf__,2,3) 5605 __attribute__nonnull__(1) 5606 __attribute__nonnull__(2); 5607 #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ 5608 assert(stream); assert(format) 5609 5610 PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...) 5611 __attribute__nonnull__(2); 5612 #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ 5613 assert(name) 5614 5615 PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...) 5616 __attribute__format__(__printf__,1,2) 5617 __attribute__nonnull__(1); 5618 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ 5619 assert(pat) 5620 5621 PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) 5622 __attribute__format__(__printf__,1,2) 5623 __attribute__nonnull__(1); 5624 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ 5625 assert(pat) 5626 5627 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) 5628 __attribute__format__(__printf__,1,2) 5629 __attribute__nonnull__(1); 5630 #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ 5631 assert(format) 5632 5633 PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 5634 __attribute__format__(__printf__,2,3) 5635 __attribute__nonnull__(1) 5636 __attribute__nonnull__(2); 5637 #define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ 5638 assert(sv); assert(pat) 5639 5640 PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...) 5641 __attribute__format__(__printf__,2,3) 5642 __attribute__nonnull__(1) 5643 __attribute__nonnull__(2); 5644 #define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ 5645 assert(sv); assert(pat) 5646 5647 PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 5648 __attribute__format__(__printf__,2,3) 5649 __attribute__nonnull__(1) 5650 __attribute__nonnull__(2); 5651 #define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ 5652 assert(sv); assert(pat) 5653 5654 PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...) 5655 __attribute__format__(__printf__,2,3) 5656 __attribute__nonnull__(1) 5657 __attribute__nonnull__(2); 5658 #define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ 5659 assert(sv); assert(pat) 5660 5661 PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...) 5662 __attribute__format__(__printf__,1,2) 5663 __attribute__nonnull__(1); 5664 #define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ 5665 assert(pat) 5666 5667 PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) 5668 __attribute__format__(__printf__,2,3) 5669 __attribute__nonnull__(2); 5670 #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ 5671 assert(pat) 5672 5673 #endif 5674 #if defined(PERL_IMPLICIT_SYS) 5675 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) 5676 __attribute__nonnull__(1) 5677 __attribute__nonnull__(2) 5678 __attribute__nonnull__(3) 5679 __attribute__nonnull__(4) 5680 __attribute__nonnull__(5) 5681 __attribute__nonnull__(6) 5682 __attribute__nonnull__(7) 5683 __attribute__nonnull__(8) 5684 __attribute__nonnull__(9); 5685 #define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ 5686 assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5687 5688 # if defined(USE_ITHREADS) 5689 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) 5690 __attribute__nonnull__(1) 5691 __attribute__nonnull__(3) 5692 __attribute__nonnull__(4) 5693 __attribute__nonnull__(5) 5694 __attribute__nonnull__(6) 5695 __attribute__nonnull__(7) 5696 __attribute__nonnull__(8) 5697 __attribute__nonnull__(9) 5698 __attribute__nonnull__(10) 5699 __attribute__nonnull__(11); 5700 #define PERL_ARGS_ASSERT_PERL_CLONE_USING \ 5701 assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5702 5703 # endif 5704 #endif 5705 #if defined(PERL_IN_AV_C) 5706 STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av) 5707 __attribute__nonnull__(pTHX_1); 5708 #define PERL_ARGS_ASSERT_GET_AUX_MG \ 5709 assert(av) 5710 5711 #endif 5712 #if defined(PERL_IN_DEB_C) 5713 STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max) 5714 __attribute__nonnull__(pTHX_1); 5715 #define PERL_ARGS_ASSERT_DEB_STACK_N \ 5716 assert(stack_base) 5717 5718 #endif 5719 #if defined(PERL_IN_DOIO_C) 5720 STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) 5721 __attribute__nonnull__(pTHX_1); 5722 #define PERL_ARGS_ASSERT_EXEC_FAILED \ 5723 assert(cmd) 5724 5725 STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) 5726 __attribute__warn_unused_result__; 5727 5728 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) 5729 __attribute__nonnull__(pTHX_1) 5730 __attribute__nonnull__(pTHX_2) 5731 __attribute__nonnull__(pTHX_4) 5732 __attribute__nonnull__(pTHX_5); 5733 #define PERL_ARGS_ASSERT_OPENN_CLEANUP \ 5734 assert(gv); assert(io); assert(mode); assert(oname) 5735 5736 STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype) 5737 __attribute__nonnull__(pTHX_1) 5738 __attribute__nonnull__(pTHX_2) 5739 __attribute__nonnull__(pTHX_3) 5740 __attribute__nonnull__(pTHX_4) 5741 __attribute__nonnull__(pTHX_5) 5742 __attribute__nonnull__(pTHX_6); 5743 #define PERL_ARGS_ASSERT_OPENN_SETUP \ 5744 assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype) 5745 5746 #endif 5747 #if defined(PERL_IN_DOOP_C) 5748 STATIC I32 S_do_trans_complex(pTHX_ SV * const sv) 5749 __attribute__warn_unused_result__ 5750 __attribute__nonnull__(pTHX_1); 5751 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ 5752 assert(sv) 5753 5754 STATIC I32 S_do_trans_complex_utf8(pTHX_ SV * const sv) 5755 __attribute__warn_unused_result__ 5756 __attribute__nonnull__(pTHX_1); 5757 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \ 5758 assert(sv) 5759 5760 STATIC I32 S_do_trans_count(pTHX_ SV * const sv) 5761 __attribute__warn_unused_result__ 5762 __attribute__nonnull__(pTHX_1); 5763 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ 5764 assert(sv) 5765 5766 STATIC I32 S_do_trans_count_utf8(pTHX_ SV * const sv) 5767 __attribute__warn_unused_result__ 5768 __attribute__nonnull__(pTHX_1); 5769 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8 \ 5770 assert(sv) 5771 5772 STATIC I32 S_do_trans_simple(pTHX_ SV * const sv) 5773 __attribute__warn_unused_result__ 5774 __attribute__nonnull__(pTHX_1); 5775 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ 5776 assert(sv) 5777 5778 STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv) 5779 __attribute__warn_unused_result__ 5780 __attribute__nonnull__(pTHX_1); 5781 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8 \ 5782 assert(sv) 5783 5784 #endif 5785 #if defined(PERL_IN_DUMP_C) 5786 STATIC CV* S_deb_curcv(pTHX_ const I32 ix); 5787 STATIC void S_debprof(pTHX_ const OP *o) 5788 __attribute__nonnull__(pTHX_1); 5789 #define PERL_ARGS_ASSERT_DEBPROF \ 5790 assert(o) 5791 5792 STATIC SV* S_pm_description(pTHX_ const PMOP *pm) 5793 __attribute__nonnull__(pTHX_1); 5794 #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ 5795 assert(pm) 5796 5797 STATIC UV S_sequence_num(pTHX_ const OP *o); 5798 # if defined(PERL_MAD) 5799 STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 5800 __attribute__format__(__printf__,pTHX_3,pTHX_4) 5801 __attribute__nonnull__(pTHX_2) 5802 __attribute__nonnull__(pTHX_3); 5803 #define PERL_ARGS_ASSERT_XMLDUMP_ATTR \ 5804 assert(file); assert(pat) 5805 5806 # endif 5807 #endif 5808 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) 5809 PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) 5810 __attribute__nonnull__(pTHX_1); 5811 #define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ 5812 assert(hv) 5813 5814 #endif 5815 #if defined(PERL_IN_GV_C) 5816 STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, svtype sv_type) 5817 __attribute__nonnull__(pTHX_1) 5818 __attribute__nonnull__(pTHX_2); 5819 #define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ 5820 assert(stash); assert(name) 5821 5822 STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) 5823 __attribute__nonnull__(pTHX_1); 5824 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ 5825 assert(gv) 5826 5827 STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8) 5828 __attribute__nonnull__(pTHX_1); 5829 #define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ 5830 assert(name) 5831 5832 STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, bool addmg, svtype sv_type) 5833 __attribute__nonnull__(pTHX_1) 5834 __attribute__nonnull__(pTHX_2) 5835 __attribute__nonnull__(pTHX_3); 5836 #define PERL_ARGS_ASSERT_GV_MAGICALIZE \ 5837 assert(gv); assert(stash); assert(name) 5838 5839 STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) 5840 __attribute__nonnull__(pTHX_1); 5841 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ 5842 assert(gv) 5843 5844 STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) 5845 __attribute__nonnull__(pTHX_1) 5846 __attribute__nonnull__(pTHX_2); 5847 #define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ 5848 assert(gv); assert(name) 5849 5850 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) 5851 __attribute__nonnull__(pTHX_1) 5852 __attribute__nonnull__(pTHX_2) 5853 __attribute__nonnull__(pTHX_3) 5854 __attribute__nonnull__(pTHX_4) 5855 __attribute__nonnull__(pTHX_5); 5856 #define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ 5857 assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) 5858 5859 STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags) 5860 __attribute__nonnull__(pTHX_1) 5861 __attribute__nonnull__(pTHX_2) 5862 __attribute__nonnull__(pTHX_3) 5863 __attribute__nonnull__(pTHX_4); 5864 #define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ 5865 assert(gv); assert(varpv); assert(namesv); assert(methpv) 5866 5867 #endif 5868 #if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) 5869 PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv) 5870 __attribute__nonnull__(pTHX_1) 5871 __attribute__nonnull__(pTHX_2); 5872 #define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ 5873 assert(tsv); assert(sv) 5874 5875 #endif 5876 #if defined(PERL_IN_HV_C) 5877 STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items) 5878 __attribute__nonnull__(pTHX_1); 5879 #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ 5880 assert(hv) 5881 5882 STATIC void S_hfreeentries(pTHX_ HV *hv) 5883 __attribute__nonnull__(pTHX_1); 5884 #define PERL_ARGS_ASSERT_HFREEENTRIES \ 5885 assert(hv) 5886 5887 STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize) 5888 __attribute__nonnull__(pTHX_1); 5889 #define PERL_ARGS_ASSERT_HSPLIT \ 5890 assert(hv) 5891 5892 STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv) 5893 __attribute__nonnull__(pTHX_1); 5894 #define PERL_ARGS_ASSERT_HV_AUXINIT \ 5895 assert(hv) 5896 5897 STATIC struct xpvhv_aux* S_hv_auxinit_internal(struct xpvhv_aux *iter) 5898 __attribute__nonnull__(1); 5899 #define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL \ 5900 assert(iter) 5901 5902 STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); 5903 STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry) 5904 __attribute__nonnull__(pTHX_1) 5905 __attribute__nonnull__(pTHX_2); 5906 #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ 5907 assert(hv); assert(entry) 5908 5909 STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) 5910 __attribute__nonnull__(1) 5911 __attribute__nonnull__(2) 5912 __attribute__nonnull__(3); 5913 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ 5914 assert(hv); assert(needs_copy); assert(needs_store) 5915 5916 PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) 5917 __attribute__noreturn__ 5918 __attribute__nonnull__(pTHX_2) 5919 __attribute__nonnull__(pTHX_4); 5920 #define PERL_ARGS_ASSERT_HV_NOTALLOWED \ 5921 assert(key); assert(msg) 5922 5923 STATIC HE* S_new_he(pTHX) 5924 __attribute__malloc__ 5925 __attribute__warn_unused_result__; 5926 5927 PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); 5928 STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) 5929 __attribute__nonnull__(pTHX_1); 5930 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ 5931 assert(he) 5932 5933 STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) 5934 __attribute__malloc__ 5935 __attribute__warn_unused_result__ 5936 __attribute__nonnull__(1); 5937 #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ 5938 assert(str) 5939 5940 STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags) 5941 __attribute__warn_unused_result__ 5942 __attribute__nonnull__(pTHX_1); 5943 #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ 5944 assert(str) 5945 5946 STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); 5947 #endif 5948 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) 5949 PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av) 5950 __attribute__nonnull__(pTHX_1); 5951 #define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ 5952 assert(sv) 5953 5954 #endif 5955 #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) 5956 PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) 5957 __attribute__nonnull__(pTHX_1) 5958 __attribute__nonnull__(pTHX_2); 5959 #define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ 5960 assert(hv); assert(indexp) 5961 5962 #endif 5963 #if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE) 5964 STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category); 5965 STATIC char* S_stdize_locale(pTHX_ char* locs) 5966 __attribute__nonnull__(pTHX_1); 5967 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ 5968 assert(locs) 5969 5970 #endif 5971 #if defined(PERL_IN_MALLOC_C) 5972 STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p) 5973 __attribute__nonnull__(1); 5974 #define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ 5975 assert(nbytes_p) 5976 5977 #endif 5978 #if defined(PERL_IN_MG_C) 5979 STATIC void S_fixup_errno_string(pTHX_ SV* sv) 5980 __attribute__nonnull__(pTHX_1); 5981 #define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ 5982 assert(sv) 5983 5984 STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val) 5985 __attribute__nonnull__(pTHX_1) 5986 __attribute__nonnull__(pTHX_2) 5987 __attribute__nonnull__(pTHX_3); 5988 #define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ 5989 assert(sv); assert(mg); assert(meth) 5990 5991 STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth) 5992 __attribute__nonnull__(pTHX_1) 5993 __attribute__nonnull__(pTHX_2) 5994 __attribute__nonnull__(pTHX_3); 5995 #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ 5996 assert(sv); assert(mg); assert(meth) 5997 5998 STATIC void S_restore_magic(pTHX_ const void *p); 5999 STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags) 6000 __attribute__nonnull__(pTHX_2); 6001 #define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ 6002 assert(sv) 6003 6004 STATIC void S_unwind_handler_stack(pTHX_ const void *p); 6005 #endif 6006 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) 6007 PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) 6008 __attribute__nonnull__(pTHX_6) 6009 __attribute__nonnull__(pTHX_7); 6010 #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ 6011 assert(posp); assert(lenp) 6012 6013 #endif 6014 #if defined(PERL_IN_MRO_C) 6015 STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags) 6016 __attribute__nonnull__(pTHX_1) 6017 __attribute__nonnull__(pTHX_2); 6018 #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ 6019 assert(isa); assert(name) 6020 6021 STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) 6022 __attribute__nonnull__(pTHX_1) 6023 __attribute__nonnull__(pTHX_2) 6024 __attribute__nonnull__(pTHX_5); 6025 #define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ 6026 assert(stashes); assert(seen_stashes); assert(namesv) 6027 6028 STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level) 6029 __attribute__nonnull__(pTHX_1); 6030 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ 6031 assert(stash) 6032 6033 #endif 6034 #if defined(PERL_IN_NUMERIC_C) 6035 STATIC NV S_mulexp10(NV value, I32 exponent); 6036 #endif 6037 #if defined(PERL_IN_OP_C) 6038 PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o); 6039 STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) 6040 __attribute__nonnull__(pTHX_1) 6041 __attribute__nonnull__(pTHX_2); 6042 #define PERL_ARGS_ASSERT_APPLY_ATTRS \ 6043 assert(stash); assert(target) 6044 6045 STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) 6046 __attribute__nonnull__(pTHX_1) 6047 __attribute__nonnull__(pTHX_2) 6048 __attribute__nonnull__(pTHX_4); 6049 #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ 6050 assert(stash); assert(target); assert(imopsp) 6051 6052 STATIC void S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid) 6053 __attribute__nonnull__(pTHX_2) 6054 __attribute__nonnull__(pTHX_3) 6055 __attribute__nonnull__(pTHX_5); 6056 #define PERL_ARGS_ASSERT_BAD_TYPE_GV \ 6057 assert(t); assert(gv); assert(kid) 6058 6059 STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid) 6060 __attribute__nonnull__(pTHX_2) 6061 __attribute__nonnull__(pTHX_3) 6062 __attribute__nonnull__(pTHX_5); 6063 #define PERL_ARGS_ASSERT_BAD_TYPE_PV \ 6064 assert(t); assert(name); assert(kid) 6065 6066 STATIC void S_cop_free(pTHX_ COP *cop) 6067 __attribute__nonnull__(pTHX_1); 6068 #define PERL_ARGS_ASSERT_COP_FREE \ 6069 assert(cop) 6070 6071 STATIC OP * S_dup_attrlist(pTHX_ OP *o) 6072 __attribute__nonnull__(pTHX_1); 6073 #define PERL_ARGS_ASSERT_DUP_ATTRLIST \ 6074 assert(o) 6075 6076 STATIC void S_finalize_op(pTHX_ OP* o) 6077 __attribute__nonnull__(pTHX_1); 6078 #define PERL_ARGS_ASSERT_FINALIZE_OP \ 6079 assert(o) 6080 6081 STATIC void S_find_and_forget_pmops(pTHX_ OP *o) 6082 __attribute__nonnull__(pTHX_1); 6083 #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ 6084 assert(o) 6085 6086 STATIC OP* S_fold_constants(pTHX_ OP *o) 6087 __attribute__nonnull__(pTHX_1); 6088 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ 6089 assert(o) 6090 6091 STATIC OP* S_force_list(pTHX_ OP* arg); 6092 STATIC void S_forget_pmop(pTHX_ PMOP *const o) 6093 __attribute__nonnull__(pTHX_1); 6094 #define PERL_ARGS_ASSERT_FORGET_PMOP \ 6095 assert(o) 6096 6097 STATIC OP* S_gen_constant_list(pTHX_ OP* o); 6098 STATIC SV* S_gv_ename(pTHX_ GV *gv) 6099 __attribute__nonnull__(pTHX_1); 6100 #define PERL_ARGS_ASSERT_GV_ENAME \ 6101 assert(gv) 6102 6103 STATIC void S_inplace_aassign(pTHX_ OP* o) 6104 __attribute__nonnull__(pTHX_1); 6105 #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ 6106 assert(o) 6107 6108 STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) 6109 __attribute__warn_unused_result__ 6110 __attribute__nonnull__(1); 6111 #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ 6112 assert(o) 6113 6114 STATIC I32 S_is_list_assignment(pTHX_ const OP *o) 6115 __attribute__warn_unused_result__; 6116 6117 STATIC OP* S_listkids(pTHX_ OP* o); 6118 STATIC bool S_looks_like_bool(pTHX_ const OP* o) 6119 __attribute__nonnull__(pTHX_1); 6120 #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ 6121 assert(o) 6122 6123 STATIC OP* S_modkids(pTHX_ OP *o, I32 type); 6124 STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name) 6125 __attribute__nonnull__(pTHX_1) 6126 __attribute__nonnull__(pTHX_2) 6127 __attribute__nonnull__(pTHX_3); 6128 #define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ 6129 assert(proto); assert(attrs); assert(name) 6130 6131 STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) 6132 __attribute__nonnull__(pTHX_3); 6133 #define PERL_ARGS_ASSERT_MY_KID \ 6134 assert(imopsp) 6135 6136 STATIC OP* S_newDEFSVOP(pTHX) 6137 __attribute__warn_unused_result__; 6138 6139 STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) 6140 __attribute__nonnull__(pTHX_2); 6141 #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ 6142 assert(block) 6143 6144 STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) 6145 __attribute__warn_unused_result__ 6146 __attribute__nonnull__(pTHX_3) 6147 __attribute__nonnull__(pTHX_4); 6148 #define PERL_ARGS_ASSERT_NEW_LOGOP \ 6149 assert(firstp); assert(otherp) 6150 6151 STATIC void S_no_bareword_allowed(pTHX_ OP *o) 6152 __attribute__nonnull__(pTHX_1); 6153 #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ 6154 assert(o) 6155 6156 STATIC OP* S_no_fh_allowed(pTHX_ OP *o) 6157 __attribute__warn_unused_result__ 6158 __attribute__nonnull__(pTHX_1); 6159 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ 6160 assert(o) 6161 6162 STATIC void S_null_listop_in_list_context(pTHX_ OP* o) 6163 __attribute__nonnull__(pTHX_1); 6164 #define PERL_ARGS_ASSERT_NULL_LISTOP_IN_LIST_CONTEXT \ 6165 assert(o) 6166 6167 PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o) 6168 __attribute__nonnull__(pTHX_1); 6169 #define PERL_ARGS_ASSERT_OP_INTEGERIZE \ 6170 assert(o) 6171 6172 PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o) 6173 __attribute__nonnull__(pTHX_1); 6174 #define PERL_ARGS_ASSERT_OP_STD_INIT \ 6175 assert(o) 6176 6177 STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) 6178 __attribute__nonnull__(pTHX_1) 6179 __attribute__nonnull__(pTHX_2) 6180 __attribute__nonnull__(pTHX_3); 6181 #define PERL_ARGS_ASSERT_PMTRANS \ 6182 assert(o); assert(expr); assert(repl) 6183 6184 STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv) 6185 __attribute__nonnull__(pTHX_2) 6186 __attribute__nonnull__(pTHX_3) 6187 __attribute__nonnull__(pTHX_4); 6188 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ 6189 assert(fullname); assert(gv); assert(cv) 6190 6191 STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); 6192 STATIC OP* S_refkids(pTHX_ OP* o, I32 type); 6193 STATIC bool S_scalar_mod_type(const OP *o, I32 type) 6194 __attribute__warn_unused_result__; 6195 6196 STATIC OP* S_scalarboolean(pTHX_ OP *o) 6197 __attribute__nonnull__(pTHX_1); 6198 #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ 6199 assert(o) 6200 6201 STATIC OP* S_scalarkids(pTHX_ OP* o); 6202 STATIC OP* S_scalarseq(pTHX_ OP* o); 6203 STATIC OP* S_search_const(pTHX_ OP *o) 6204 __attribute__warn_unused_result__ 6205 __attribute__nonnull__(pTHX_1); 6206 #define PERL_ARGS_ASSERT_SEARCH_CONST \ 6207 assert(o) 6208 6209 STATIC void S_simplify_sort(pTHX_ OP *o) 6210 __attribute__nonnull__(pTHX_1); 6211 #define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ 6212 assert(o) 6213 6214 STATIC OP* S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 6215 __attribute__warn_unused_result__ 6216 __attribute__nonnull__(pTHX_1) 6217 __attribute__nonnull__(pTHX_2); 6218 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ 6219 assert(o); assert(name) 6220 6221 STATIC OP* S_too_few_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) 6222 __attribute__warn_unused_result__ 6223 __attribute__nonnull__(pTHX_1) 6224 __attribute__nonnull__(pTHX_2); 6225 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV \ 6226 assert(o); assert(namesv) 6227 6228 STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 6229 __attribute__nonnull__(pTHX_1) 6230 __attribute__nonnull__(pTHX_2); 6231 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ 6232 assert(o); assert(name) 6233 6234 STATIC OP* S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) 6235 __attribute__warn_unused_result__ 6236 __attribute__nonnull__(pTHX_1) 6237 __attribute__nonnull__(pTHX_2); 6238 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \ 6239 assert(o); assert(namesv) 6240 6241 #endif 6242 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) 6243 PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) 6244 __attribute__nonnull__(pTHX_1) 6245 __attribute__nonnull__(pTHX_2); 6246 #define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ 6247 assert(name); assert(old_cv) 6248 6249 #endif 6250 #if defined(PERL_IN_PAD_C) 6251 STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash) 6252 __attribute__nonnull__(pTHX_1); 6253 #define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ 6254 assert(namesv) 6255 6256 STATIC void S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash) 6257 __attribute__nonnull__(pTHX_1); 6258 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ 6259 assert(name) 6260 6261 STATIC PADOFFSET S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags) 6262 __attribute__nonnull__(pTHX_1) 6263 __attribute__nonnull__(pTHX_4) 6264 __attribute__nonnull__(pTHX_8) 6265 __attribute__nonnull__(pTHX_9); 6266 #define PERL_ARGS_ASSERT_PAD_FINDLEX \ 6267 assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags) 6268 6269 STATIC void S_pad_reset(pTHX); 6270 #endif 6271 #if defined(PERL_IN_PERL_C) 6272 STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp) 6273 __attribute__nonnull__(pTHX_1) 6274 __attribute__nonnull__(pTHX_2); 6275 #define PERL_ARGS_ASSERT_FIND_BEGINNING \ 6276 assert(linestr_sv); assert(rsfp) 6277 6278 STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); 6279 STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags) 6280 __attribute__nonnull__(pTHX_1); 6281 #define PERL_ARGS_ASSERT_INCPUSH \ 6282 assert(dir) 6283 6284 STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) 6285 __attribute__nonnull__(pTHX_1); 6286 #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ 6287 assert(p) 6288 6289 STATIC void S_init_ids(pTHX); 6290 STATIC void S_init_interp(pTHX); 6291 STATIC void S_init_main_stash(pTHX); 6292 STATIC void S_init_perllib(pTHX); 6293 STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) 6294 __attribute__nonnull__(pTHX_2); 6295 #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ 6296 assert(argv) 6297 6298 STATIC void S_init_predump_symbols(pTHX); 6299 STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags) 6300 __attribute__nonnull__(pTHX_1); 6301 #define PERL_ARGS_ASSERT_MAYBERELOCATE \ 6302 assert(dir) 6303 6304 PERL_STATIC_NO_RET void S_minus_v(pTHX) 6305 __attribute__noreturn__; 6306 6307 PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) 6308 __attribute__noreturn__; 6309 6310 STATIC void S_nuke_stacks(pTHX); 6311 STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript) 6312 __attribute__nonnull__(pTHX_1) 6313 __attribute__nonnull__(pTHX_3); 6314 #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ 6315 assert(scriptname); assert(suidscript) 6316 6317 STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); 6318 PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) 6319 __attribute__noreturn__; 6320 6321 PERL_STATIC_NO_RET void S_usage(pTHX) 6322 __attribute__noreturn__; 6323 6324 #endif 6325 #if defined(PERL_IN_PP_C) 6326 STATIC void S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping) 6327 __attribute__nonnull__(pTHX_1) 6328 __attribute__nonnull__(pTHX_2); 6329 #define PERL_ARGS_ASSERT_DO_CHOMP \ 6330 assert(retval); assert(sv) 6331 6332 STATIC OP* S_do_delete_local(pTHX); 6333 STATIC SV* S_refto(pTHX_ SV* sv) 6334 __attribute__warn_unused_result__ 6335 __attribute__nonnull__(pTHX_1); 6336 #define PERL_ARGS_ASSERT_REFTO \ 6337 assert(sv) 6338 6339 #endif 6340 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) 6341 PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) 6342 __attribute__warn_unused_result__ 6343 __attribute__nonnull__(pTHX_1) 6344 __attribute__nonnull__(pTHX_2) 6345 __attribute__nonnull__(pTHX_4); 6346 #define PERL_ARGS_ASSERT_SOFTREF2XV \ 6347 assert(sv); assert(what); assert(spp) 6348 6349 #endif 6350 #if defined(PERL_IN_PP_CTL_C) 6351 STATIC SV ** S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags, bool lvalue) 6352 __attribute__nonnull__(pTHX_1) 6353 __attribute__nonnull__(pTHX_2) 6354 __attribute__nonnull__(pTHX_3); 6355 #define PERL_ARGS_ASSERT_ADJUST_STACK_ON_LEAVE \ 6356 assert(newsp); assert(sp); assert(mark) 6357 6358 STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) 6359 __attribute__warn_unused_result__ 6360 __attribute__nonnull__(pTHX_1); 6361 #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ 6362 assert(name) 6363 6364 STATIC void S_destroy_matcher(pTHX_ PMOP* matcher) 6365 __attribute__nonnull__(pTHX_1); 6366 #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ 6367 assert(matcher) 6368 6369 STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); 6370 STATIC OP* S_docatch(pTHX_ OP *o) 6371 __attribute__warn_unused_result__; 6372 6373 STATIC bool S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh); 6374 STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) 6375 __attribute__warn_unused_result__ 6376 __attribute__nonnull__(pTHX_1) 6377 __attribute__nonnull__(pTHX_2) 6378 __attribute__nonnull__(pTHX_5) 6379 __attribute__nonnull__(pTHX_6); 6380 #define PERL_ARGS_ASSERT_DOFINDLABEL \ 6381 assert(o); assert(label); assert(opstack); assert(oplimit) 6382 6383 STATIC MAGIC * S_doparseform(pTHX_ SV *sv) 6384 __attribute__nonnull__(pTHX_1); 6385 #define PERL_ARGS_ASSERT_DOPARSEFORM \ 6386 assert(sv) 6387 6388 STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) 6389 __attribute__warn_unused_result__; 6390 6391 STATIC I32 S_dopoptogiven(pTHX_ I32 startingblock) 6392 __attribute__warn_unused_result__; 6393 6394 STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) 6395 __attribute__warn_unused_result__ 6396 __attribute__nonnull__(pTHX_1); 6397 #define PERL_ARGS_ASSERT_DOPOPTOLABEL \ 6398 assert(label) 6399 6400 STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) 6401 __attribute__warn_unused_result__; 6402 6403 STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) 6404 __attribute__warn_unused_result__ 6405 __attribute__nonnull__(pTHX_1); 6406 #define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ 6407 assert(cxstk) 6408 6409 STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) 6410 __attribute__warn_unused_result__; 6411 6412 STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) 6413 __attribute__warn_unused_result__ 6414 __attribute__nonnull__(pTHX_1); 6415 #define PERL_ARGS_ASSERT_MAKE_MATCHER \ 6416 assert(re) 6417 6418 STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) 6419 __attribute__warn_unused_result__ 6420 __attribute__nonnull__(pTHX_1) 6421 __attribute__nonnull__(pTHX_2); 6422 #define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ 6423 assert(matcher); assert(sv) 6424 6425 STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) 6426 __attribute__warn_unused_result__; 6427 6428 PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) 6429 __attribute__warn_unused_result__ 6430 __attribute__nonnull__(1); 6431 #define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ 6432 assert(name) 6433 6434 STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) 6435 __attribute__warn_unused_result__ 6436 __attribute__nonnull__(pTHX_2); 6437 #define PERL_ARGS_ASSERT_RUN_USER_FILTER \ 6438 assert(buf_sv) 6439 6440 STATIC void S_rxres_free(pTHX_ void** rsp) 6441 __attribute__nonnull__(pTHX_1); 6442 #define PERL_ARGS_ASSERT_RXRES_FREE \ 6443 assert(rsp) 6444 6445 STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) 6446 __attribute__nonnull__(pTHX_1) 6447 __attribute__nonnull__(pTHX_2); 6448 #define PERL_ARGS_ASSERT_RXRES_RESTORE \ 6449 assert(rsp); assert(rx) 6450 6451 STATIC void S_save_lines(pTHX_ AV *array, SV *sv) 6452 __attribute__nonnull__(pTHX_2); 6453 #define PERL_ARGS_ASSERT_SAVE_LINES \ 6454 assert(sv) 6455 6456 #endif 6457 #if defined(PERL_IN_PP_HOT_C) 6458 STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) 6459 __attribute__nonnull__(pTHX_1) 6460 __attribute__nonnull__(pTHX_2); 6461 #define PERL_ARGS_ASSERT_DO_ODDBALL \ 6462 assert(oddkey); assert(firstkey) 6463 6464 STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp) 6465 __attribute__warn_unused_result__ 6466 __attribute__nonnull__(pTHX_1); 6467 #define PERL_ARGS_ASSERT_METHOD_COMMON \ 6468 assert(meth) 6469 6470 #endif 6471 #if defined(PERL_IN_PP_PACK_C) 6472 STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest, const bool needs_swap) 6473 __attribute__warn_unused_result__ 6474 __attribute__nonnull__(1) 6475 __attribute__nonnull__(3); 6476 #define PERL_ARGS_ASSERT_BYTES_TO_UNI \ 6477 assert(start); assert(dest) 6478 6479 STATIC int S_div128(pTHX_ SV *pnum, bool *done) 6480 __attribute__nonnull__(pTHX_1) 6481 __attribute__nonnull__(pTHX_2); 6482 #define PERL_ARGS_ASSERT_DIV128 \ 6483 assert(pnum); assert(done) 6484 6485 STATIC char S_first_symbol(const char *pat, const char *patend) 6486 __attribute__nonnull__(1) 6487 __attribute__nonnull__(2); 6488 #define PERL_ARGS_ASSERT_FIRST_SYMBOL \ 6489 assert(pat); assert(patend) 6490 6491 STATIC const char * S_get_num(pTHX_ const char *patptr, I32 *lenptr) 6492 __attribute__warn_unused_result__ 6493 __attribute__nonnull__(pTHX_1) 6494 __attribute__nonnull__(pTHX_2); 6495 #define PERL_ARGS_ASSERT_GET_NUM \ 6496 assert(patptr); assert(lenptr) 6497 6498 STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender) 6499 __attribute__nonnull__(pTHX_1) 6500 __attribute__nonnull__(pTHX_2); 6501 #define PERL_ARGS_ASSERT_GROUP_END \ 6502 assert(patptr); assert(patend) 6503 6504 STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l) 6505 __attribute__warn_unused_result__ 6506 __attribute__nonnull__(pTHX_1); 6507 #define PERL_ARGS_ASSERT_IS_AN_INT \ 6508 assert(s) 6509 6510 STATIC I32 S_measure_struct(pTHX_ struct tempsym* symptr) 6511 __attribute__nonnull__(pTHX_1); 6512 #define PERL_ARGS_ASSERT_MEASURE_STRUCT \ 6513 assert(symptr) 6514 6515 STATIC SV* S_mul128(pTHX_ SV *sv, U8 m) 6516 __attribute__nonnull__(pTHX_1); 6517 #define PERL_ARGS_ASSERT_MUL128 \ 6518 assert(sv) 6519 6520 STATIC bool S_need_utf8(const char *pat, const char *patend) 6521 __attribute__nonnull__(1) 6522 __attribute__nonnull__(2); 6523 #define PERL_ARGS_ASSERT_NEED_UTF8 \ 6524 assert(pat); assert(patend) 6525 6526 STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr) 6527 __attribute__nonnull__(pTHX_1); 6528 #define PERL_ARGS_ASSERT_NEXT_SYMBOL \ 6529 assert(symptr) 6530 6531 STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym* symptr, SV **beglist, SV **endlist) 6532 __attribute__nonnull__(pTHX_1) 6533 __attribute__nonnull__(pTHX_2) 6534 __attribute__nonnull__(pTHX_3) 6535 __attribute__nonnull__(pTHX_4); 6536 #define PERL_ARGS_ASSERT_PACK_REC \ 6537 assert(cat); assert(symptr); assert(beglist); assert(endlist) 6538 6539 STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) 6540 __attribute__warn_unused_result__ 6541 __attribute__nonnull__(pTHX_1); 6542 #define PERL_ARGS_ASSERT_SV_EXP_GROW \ 6543 assert(sv) 6544 6545 STATIC I32 S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) 6546 __attribute__nonnull__(pTHX_1) 6547 __attribute__nonnull__(pTHX_2) 6548 __attribute__nonnull__(pTHX_3) 6549 __attribute__nonnull__(pTHX_4); 6550 #define PERL_ARGS_ASSERT_UNPACK_REC \ 6551 assert(symptr); assert(s); assert(strbeg); assert(strend) 6552 6553 #endif 6554 #if defined(PERL_IN_PP_SORT_C) 6555 STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) 6556 __attribute__nonnull__(pTHX_1) 6557 __attribute__nonnull__(pTHX_2); 6558 #define PERL_ARGS_ASSERT_AMAGIC_CMP \ 6559 assert(str1); assert(str2) 6560 6561 STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) 6562 __attribute__nonnull__(pTHX_1) 6563 __attribute__nonnull__(pTHX_2); 6564 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ 6565 assert(str1); assert(str2) 6566 6567 STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) 6568 __attribute__nonnull__(pTHX_1) 6569 __attribute__nonnull__(pTHX_2); 6570 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ 6571 assert(a); assert(b) 6572 6573 STATIC I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b) 6574 __attribute__nonnull__(pTHX_1) 6575 __attribute__nonnull__(pTHX_2); 6576 #define PERL_ARGS_ASSERT_AMAGIC_NCMP \ 6577 assert(a); assert(b) 6578 6579 STATIC void S_qsortsvu(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t compare) 6580 __attribute__nonnull__(pTHX_3); 6581 #define PERL_ARGS_ASSERT_QSORTSVU \ 6582 assert(compare) 6583 6584 STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b) 6585 __attribute__nonnull__(pTHX_1) 6586 __attribute__nonnull__(pTHX_2); 6587 #define PERL_ARGS_ASSERT_SORTCV \ 6588 assert(a); assert(b) 6589 6590 STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b) 6591 __attribute__nonnull__(pTHX_1) 6592 __attribute__nonnull__(pTHX_2); 6593 #define PERL_ARGS_ASSERT_SORTCV_STACKED \ 6594 assert(a); assert(b) 6595 6596 STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b) 6597 __attribute__nonnull__(pTHX_1) 6598 __attribute__nonnull__(pTHX_2); 6599 #define PERL_ARGS_ASSERT_SORTCV_XSUB \ 6600 assert(a); assert(b) 6601 6602 STATIC I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b) 6603 __attribute__nonnull__(pTHX_1) 6604 __attribute__nonnull__(pTHX_2); 6605 #define PERL_ARGS_ASSERT_SV_I_NCMP \ 6606 assert(a); assert(b) 6607 6608 STATIC I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) 6609 __attribute__nonnull__(pTHX_1) 6610 __attribute__nonnull__(pTHX_2); 6611 #define PERL_ARGS_ASSERT_SV_NCMP \ 6612 assert(a); assert(b) 6613 6614 #endif 6615 #if defined(PERL_IN_PP_SYS_C) 6616 STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop) 6617 __attribute__nonnull__(pTHX_1) 6618 __attribute__nonnull__(pTHX_2); 6619 #define PERL_ARGS_ASSERT_DOFORM \ 6620 assert(cv); assert(gv) 6621 6622 STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array) 6623 __attribute__nonnull__(pTHX_1); 6624 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL \ 6625 assert(array) 6626 6627 #endif 6628 #if defined(PERL_IN_REGCOMP_C) 6629 STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end) 6630 __attribute__nonnull__(pTHX_1); 6631 #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ 6632 assert(invlist) 6633 6634 PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0) 6635 __attribute__warn_unused_result__ 6636 __attribute__nonnull__(pTHX_1); 6637 #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ 6638 assert(invlist) 6639 6640 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) 6641 __attribute__warn_unused_result__; 6642 6643 STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n) 6644 __attribute__warn_unused_result__ 6645 __attribute__nonnull__(1) 6646 __attribute__nonnull__(2); 6647 #define PERL_ARGS_ASSERT_ADD_DATA \ 6648 assert(pRExC_state); assert(s) 6649 6650 PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point, bool downgradable) 6651 __attribute__nonnull__(pTHX_1) 6652 __attribute__nonnull__(pTHX_2) 6653 __attribute__nonnull__(pTHX_3); 6654 #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \ 6655 assert(pRExC_state); assert(node); assert(flagp) 6656 6657 PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state) 6658 __attribute__nonnull__(pTHX_1); 6659 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ 6660 assert(pRExC_state) 6661 6662 STATIC bool S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state) 6663 __attribute__nonnull__(pTHX_1); 6664 #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \ 6665 assert(pRExC_state) 6666 6667 STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node) 6668 __attribute__nonnull__(pTHX_1) 6669 __attribute__nonnull__(pTHX_2); 6670 #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ 6671 assert(pRExC_state); assert(node) 6672 6673 PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(pTHX_ SV* invlist) 6674 __attribute__warn_unused_result__ 6675 __attribute__nonnull__(pTHX_1); 6676 #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ 6677 assert(invlist) 6678 6679 PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist) 6680 __attribute__warn_unused_result__ 6681 __attribute__nonnull__(pTHX_1); 6682 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ 6683 assert(invlist) 6684 6685 STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict) 6686 __attribute__nonnull__(pTHX_1) 6687 __attribute__nonnull__(pTHX_4); 6688 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \ 6689 assert(pRExC_state); assert(flagp) 6690 6691 STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse) 6692 __attribute__nonnull__(pTHX_1) 6693 __attribute__nonnull__(pTHX_3) 6694 __attribute__nonnull__(pTHX_5); 6695 #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ 6696 assert(pRExC_state); assert(flagp); assert(oregcomp_parse) 6697 6698 PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist) 6699 __attribute__warn_unused_result__ 6700 __attribute__nonnull__(pTHX_1); 6701 #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ 6702 assert(invlist) 6703 6704 PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist) 6705 __attribute__warn_unused_result__ 6706 __attribute__nonnull__(pTHX_1); 6707 #define PERL_ARGS_ASSERT_INVLIST_CLONE \ 6708 assert(invlist) 6709 6710 STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len) 6711 __attribute__nonnull__(pTHX_1); 6712 #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ 6713 assert(invlist) 6714 6715 PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist) 6716 __attribute__warn_unused_result__ 6717 __attribute__nonnull__(pTHX_1); 6718 #define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ 6719 assert(invlist) 6720 6721 PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist) 6722 __attribute__warn_unused_result__ 6723 __attribute__nonnull__(pTHX_1); 6724 #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ 6725 assert(invlist) 6726 6727 PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist) 6728 __attribute__nonnull__(pTHX_1); 6729 #define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ 6730 assert(invlist) 6731 6732 PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist) 6733 __attribute__nonnull__(pTHX_1); 6734 #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ 6735 assert(invlist) 6736 6737 STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end) 6738 __attribute__warn_unused_result__ 6739 __attribute__nonnull__(pTHX_1) 6740 __attribute__nonnull__(pTHX_2) 6741 __attribute__nonnull__(pTHX_3); 6742 #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ 6743 assert(invlist); assert(start); assert(end) 6744 6745 PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist) 6746 __attribute__warn_unused_result__ 6747 __attribute__nonnull__(pTHX_1); 6748 #define PERL_ARGS_ASSERT_INVLIST_MAX \ 6749 assert(invlist) 6750 6751 PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist) 6752 __attribute__warn_unused_result__ 6753 __attribute__nonnull__(pTHX_1); 6754 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ 6755 assert(invlist) 6756 6757 PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset) 6758 __attribute__nonnull__(pTHX_1); 6759 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ 6760 assert(invlist) 6761 6762 PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index) 6763 __attribute__nonnull__(pTHX_1); 6764 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ 6765 assert(invlist) 6766 6767 PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist) 6768 __attribute__nonnull__(pTHX_1); 6769 #define PERL_ARGS_ASSERT_INVLIST_TRIM \ 6770 assert(invlist) 6771 6772 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) 6773 __attribute__nonnull__(pTHX_1) 6774 __attribute__nonnull__(pTHX_2) 6775 __attribute__nonnull__(pTHX_3) 6776 __attribute__nonnull__(pTHX_4); 6777 #define PERL_ARGS_ASSERT_JOIN_EXACT \ 6778 assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char) 6779 6780 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) 6781 __attribute__nonnull__(pTHX_1) 6782 __attribute__nonnull__(pTHX_2) 6783 __attribute__nonnull__(pTHX_3) 6784 __attribute__nonnull__(pTHX_4) 6785 __attribute__nonnull__(pTHX_5); 6786 #define PERL_ARGS_ASSERT_MAKE_TRIE \ 6787 assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) 6788 6789 STATIC void S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth) 6790 __attribute__nonnull__(pTHX_1) 6791 __attribute__nonnull__(pTHX_2) 6792 __attribute__nonnull__(pTHX_3); 6793 #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \ 6794 assert(pRExC_state); assert(source); assert(stclass) 6795 6796 STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state) 6797 __attribute__nonnull__(pTHX_1); 6798 #define PERL_ARGS_ASSERT_NEXTCHAR \ 6799 assert(pRExC_state) 6800 6801 STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state) 6802 __attribute__nonnull__(pTHX_1); 6803 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ 6804 assert(pRExC_state) 6805 6806 STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr) 6807 __attribute__nonnull__(pTHX_1) 6808 __attribute__nonnull__(pTHX_2); 6809 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \ 6810 assert(node); assert(invlist_ptr) 6811 6812 PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...) 6813 __attribute__noreturn__ 6814 __attribute__nonnull__(pTHX_2) 6815 __attribute__nonnull__(pTHX_3); 6816 #define PERL_ARGS_ASSERT_RE_CROAK2 \ 6817 assert(pat1); assert(pat2) 6818 6819 STATIC regnode* S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) 6820 __attribute__nonnull__(pTHX_1) 6821 __attribute__nonnull__(pTHX_3); 6822 #define PERL_ARGS_ASSERT_REG \ 6823 assert(pRExC_state); assert(flagp) 6824 6825 STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op) 6826 __attribute__nonnull__(pTHX_1); 6827 #define PERL_ARGS_ASSERT_REG_NODE \ 6828 assert(pRExC_state) 6829 6830 STATIC UV S_reg_recode(pTHX_ const char value, SV **encp) 6831 __attribute__nonnull__(pTHX_2); 6832 #define PERL_ARGS_ASSERT_REG_RECODE \ 6833 assert(encp) 6834 6835 STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) 6836 __attribute__nonnull__(pTHX_1); 6837 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ 6838 assert(pRExC_state) 6839 6840 STATIC bool S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state) 6841 __attribute__nonnull__(pTHX_1); 6842 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ 6843 assert(pRExC_state) 6844 6845 STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg) 6846 __attribute__nonnull__(pTHX_1); 6847 #define PERL_ARGS_ASSERT_REGANODE \ 6848 assert(pRExC_state) 6849 6850 STATIC regnode* S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 6851 __attribute__nonnull__(pTHX_1) 6852 __attribute__nonnull__(pTHX_2); 6853 #define PERL_ARGS_ASSERT_REGATOM \ 6854 assert(pRExC_state); assert(flagp) 6855 6856 STATIC regnode* S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) 6857 __attribute__nonnull__(pTHX_1) 6858 __attribute__nonnull__(pTHX_2); 6859 #define PERL_ARGS_ASSERT_REGBRANCH \ 6860 assert(pRExC_state); assert(flagp) 6861 6862 STATIC regnode* 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, SV** ret_invlist) 6863 __attribute__nonnull__(pTHX_1) 6864 __attribute__nonnull__(pTHX_2); 6865 #define PERL_ARGS_ASSERT_REGCLASS \ 6866 assert(pRExC_state); assert(flagp) 6867 6868 STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth) 6869 __attribute__nonnull__(pTHX_1) 6870 __attribute__nonnull__(pTHX_3); 6871 #define PERL_ARGS_ASSERT_REGINSERT \ 6872 assert(pRExC_state); assert(opnd) 6873 6874 STATIC char * S_regpatws(RExC_state_t *pRExC_state, char *p, const bool recognize_comment) 6875 __attribute__warn_unused_result__ 6876 __attribute__nonnull__(1) 6877 __attribute__nonnull__(2); 6878 #define PERL_ARGS_ASSERT_REGPATWS \ 6879 assert(pRExC_state); assert(p) 6880 6881 STATIC regnode* S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 6882 __attribute__nonnull__(pTHX_1) 6883 __attribute__nonnull__(pTHX_2); 6884 #define PERL_ARGS_ASSERT_REGPIECE \ 6885 assert(pRExC_state); assert(flagp) 6886 6887 PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict) 6888 __attribute__nonnull__(pTHX_1); 6889 #define PERL_ARGS_ASSERT_REGPPOSIXCC \ 6890 assert(pRExC_state) 6891 6892 STATIC void S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 6893 __attribute__nonnull__(pTHX_1) 6894 __attribute__nonnull__(pTHX_2) 6895 __attribute__nonnull__(pTHX_3); 6896 #define PERL_ARGS_ASSERT_REGTAIL \ 6897 assert(pRExC_state); assert(p); assert(val) 6898 6899 PERL_STATIC_INLINE STRLEN S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char *s) 6900 __attribute__nonnull__(pTHX_1) 6901 __attribute__nonnull__(pTHX_3); 6902 #define PERL_ARGS_ASSERT_REGUNI \ 6903 assert(pRExC_state); assert(s) 6904 6905 STATIC char * S_regwhite(RExC_state_t *pRExC_state, char *p) 6906 __attribute__warn_unused_result__ 6907 __attribute__nonnull__(1) 6908 __attribute__nonnull__(2); 6909 #define PERL_ARGS_ASSERT_REGWHITE \ 6910 assert(pRExC_state); assert(p) 6911 6912 STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) 6913 __attribute__nonnull__(pTHX_1) 6914 __attribute__nonnull__(pTHX_2) 6915 __attribute__nonnull__(pTHX_3); 6916 #define PERL_ARGS_ASSERT_SCAN_COMMIT \ 6917 assert(pRExC_state); assert(data); assert(minlenp) 6918 6919 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, SV* const swash, const bool has_user_defined_property) 6920 __attribute__nonnull__(pTHX_1) 6921 __attribute__nonnull__(pTHX_2); 6922 #define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ 6923 assert(pRExC_state); assert(node) 6924 6925 PERL_STATIC_INLINE void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end) 6926 __attribute__nonnull__(pTHX_1); 6927 #define PERL_ARGS_ASSERT_SSC_ADD_RANGE \ 6928 assert(ssc) 6929 6930 STATIC void S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with) 6931 __attribute__nonnull__(pTHX_1) 6932 __attribute__nonnull__(pTHX_2) 6933 __attribute__nonnull__(pTHX_3); 6934 #define PERL_ARGS_ASSERT_SSC_AND \ 6935 assert(pRExC_state); assert(ssc); assert(and_with) 6936 6937 STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc) 6938 __attribute__nonnull__(pTHX_1); 6939 #define PERL_ARGS_ASSERT_SSC_ANYTHING \ 6940 assert(ssc) 6941 6942 PERL_STATIC_INLINE void S_ssc_clear_locale(pTHX_ regnode_ssc *ssc) 6943 __attribute__nonnull__(pTHX_1); 6944 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ 6945 assert(ssc) 6946 6947 PERL_STATIC_INLINE void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp) 6948 __attribute__nonnull__(pTHX_1); 6949 #define PERL_ARGS_ASSERT_SSC_CP_AND \ 6950 assert(ssc) 6951 6952 STATIC void S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc) 6953 __attribute__nonnull__(pTHX_1) 6954 __attribute__nonnull__(pTHX_2); 6955 #define PERL_ARGS_ASSERT_SSC_FINALIZE \ 6956 assert(pRExC_state); assert(ssc) 6957 6958 STATIC void S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc) 6959 __attribute__nonnull__(pTHX_1) 6960 __attribute__nonnull__(pTHX_2); 6961 #define PERL_ARGS_ASSERT_SSC_INIT \ 6962 assert(pRExC_state); assert(ssc) 6963 6964 PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd) 6965 __attribute__nonnull__(pTHX_1) 6966 __attribute__nonnull__(pTHX_2); 6967 #define PERL_ARGS_ASSERT_SSC_INTERSECTION \ 6968 assert(ssc); assert(invlist) 6969 6970 STATIC int S_ssc_is_anything(pTHX_ const regnode_ssc *ssc) 6971 __attribute__warn_unused_result__ 6972 __attribute__nonnull__(pTHX_1); 6973 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ 6974 assert(ssc) 6975 6976 STATIC int S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state, const regnode_ssc *ssc) 6977 __attribute__warn_unused_result__ 6978 __attribute__nonnull__(pTHX_1) 6979 __attribute__nonnull__(pTHX_2); 6980 #define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ 6981 assert(pRExC_state); assert(ssc) 6982 6983 STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with) 6984 __attribute__nonnull__(pTHX_1) 6985 __attribute__nonnull__(pTHX_2) 6986 __attribute__nonnull__(pTHX_3); 6987 #define PERL_ARGS_ASSERT_SSC_OR \ 6988 assert(pRExC_state); assert(ssc); assert(or_with) 6989 6990 PERL_STATIC_INLINE void S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd) 6991 __attribute__nonnull__(pTHX_1) 6992 __attribute__nonnull__(pTHX_2); 6993 #define PERL_ARGS_ASSERT_SSC_UNION \ 6994 assert(ssc); assert(invlist) 6995 6996 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) 6997 __attribute__nonnull__(pTHX_1) 6998 __attribute__nonnull__(pTHX_2) 6999 __attribute__nonnull__(pTHX_3) 7000 __attribute__nonnull__(pTHX_4) 7001 __attribute__nonnull__(pTHX_5); 7002 #define PERL_ARGS_ASSERT_STUDY_CHUNK \ 7003 assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) 7004 7005 #endif 7006 #if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C) 7007 PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist) 7008 __attribute__nonnull__(pTHX_1) 7009 __attribute__nonnull__(pTHX_3) 7010 __attribute__nonnull__(pTHX_4); 7011 #define PERL_ARGS_ASSERT__INVLIST_DUMP \ 7012 assert(file); assert(indent); assert(invlist) 7013 7014 #endif 7015 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C) 7016 PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list) 7017 __attribute__warn_unused_result__ 7018 __attribute__nonnull__(pTHX_1); 7019 #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ 7020 assert(list) 7021 7022 #endif 7023 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 7024 PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale) 7025 __attribute__nonnull__(pTHX_2); 7026 #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \ 7027 assert(node) 7028 7029 #endif 7030 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) 7031 PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) 7032 __attribute__warn_unused_result__ 7033 __attribute__nonnull__(pTHX_1); 7034 #define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ 7035 assert(swash) 7036 7037 PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp) 7038 __attribute__warn_unused_result__ 7039 __attribute__nonnull__(pTHX_1); 7040 #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ 7041 assert(invlist) 7042 7043 PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) 7044 __attribute__warn_unused_result__ 7045 __attribute__nonnull__(pTHX_1); 7046 #define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ 7047 assert(invlist) 7048 7049 PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist) 7050 __attribute__warn_unused_result__ 7051 __attribute__nonnull__(pTHX_1); 7052 #define PERL_ARGS_ASSERT__INVLIST_LEN \ 7053 assert(invlist) 7054 7055 PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp) 7056 __attribute__warn_unused_result__ 7057 __attribute__nonnull__(pTHX_1); 7058 #define PERL_ARGS_ASSERT__INVLIST_SEARCH \ 7059 assert(invlist) 7060 7061 PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) 7062 __attribute__warn_unused_result__ 7063 __attribute__nonnull__(pTHX_1); 7064 #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ 7065 assert(swash) 7066 7067 PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(pTHX_ SV* invlist) 7068 __attribute__warn_unused_result__ 7069 __attribute__nonnull__(pTHX_1); 7070 #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ 7071 assert(invlist) 7072 7073 #endif 7074 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) 7075 PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p) 7076 __attribute__nonnull__(pTHX_1) 7077 __attribute__nonnull__(pTHX_2) 7078 __attribute__nonnull__(pTHX_3); 7079 #define PERL_ARGS_ASSERT__CORE_SWASH_INIT \ 7080 assert(pkg); assert(name); assert(listsv) 7081 7082 #endif 7083 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) 7084 STATIC char* S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len) 7085 __attribute__warn_unused_result__ 7086 __attribute__pure__ 7087 __attribute__nonnull__(pTHX_1); 7088 #define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \ 7089 assert(s) 7090 7091 STATIC char S_grok_bslash_c(pTHX_ const char source, const bool output_warning) 7092 __attribute__warn_unused_result__; 7093 7094 STATIC bool S_grok_bslash_o(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) 7095 __attribute__warn_unused_result__ 7096 __attribute__nonnull__(pTHX_1) 7097 __attribute__nonnull__(pTHX_2) 7098 __attribute__nonnull__(pTHX_3); 7099 #define PERL_ARGS_ASSERT_GROK_BSLASH_O \ 7100 assert(s); assert(uv); assert(error_msg) 7101 7102 PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ char** s, UV* uv, const char** error_msg, const bool output_warning, const bool strict, const bool silence_non_portable, const bool utf8) 7103 __attribute__warn_unused_result__ 7104 __attribute__nonnull__(pTHX_1) 7105 __attribute__nonnull__(pTHX_2) 7106 __attribute__nonnull__(pTHX_3); 7107 #define PERL_ARGS_ASSERT_GROK_BSLASH_X \ 7108 assert(s); assert(uv); assert(error_msg) 7109 7110 PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped) 7111 __attribute__warn_unused_result__ 7112 __attribute__pure__ 7113 __attribute__nonnull__(pTHX_1); 7114 #define PERL_ARGS_ASSERT_REGCURLY \ 7115 assert(s) 7116 7117 #endif 7118 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) 7119 PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end) 7120 __attribute__warn_unused_result__; 7121 7122 /* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i) 7123 __attribute__nonnull__(pTHX_1) 7124 __attribute__nonnull__(pTHX_2) 7125 __attribute__nonnull__(pTHX_3); */ 7126 7127 PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i) 7128 __attribute__nonnull__(pTHX_2) 7129 __attribute__nonnull__(pTHX_4); 7130 #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ 7131 assert(b); assert(i) 7132 7133 PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist) 7134 __attribute__nonnull__(pTHX_1); 7135 #define PERL_ARGS_ASSERT__INVLIST_INVERT \ 7136 assert(invlist) 7137 7138 PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch) 7139 __attribute__nonnull__(pTHX_1) 7140 __attribute__nonnull__(pTHX_4); 7141 #define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \ 7142 assert(invlist); assert(swatch) 7143 7144 /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result) 7145 __attribute__nonnull__(pTHX_1) 7146 __attribute__nonnull__(pTHX_2) 7147 __attribute__nonnull__(pTHX_3); */ 7148 7149 /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output) 7150 __attribute__nonnull__(pTHX_2) 7151 __attribute__nonnull__(pTHX_3); */ 7152 7153 PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output) 7154 __attribute__nonnull__(pTHX_2) 7155 __attribute__nonnull__(pTHX_4); 7156 #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ 7157 assert(b); assert(output) 7158 7159 PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) 7160 __attribute__warn_unused_result__; 7161 7162 PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) 7163 __attribute__warn_unused_result__ 7164 __attribute__nonnull__(pTHX_3); 7165 #define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ 7166 assert(other_elements_ptr) 7167 7168 PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) 7169 __attribute__warn_unused_result__ 7170 __attribute__nonnull__(pTHX_1); 7171 #define PERL_ARGS_ASSERT__SWASH_TO_INVLIST \ 7172 assert(swash) 7173 7174 #endif 7175 #if defined(PERL_IN_REGEXEC_C) 7176 STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) 7177 __attribute__warn_unused_result__ 7178 __attribute__nonnull__(pTHX_1) 7179 __attribute__nonnull__(pTHX_2) 7180 __attribute__nonnull__(pTHX_3) 7181 __attribute__nonnull__(pTHX_4); 7182 #define PERL_ARGS_ASSERT_FIND_BYCLASS \ 7183 assert(prog); assert(c); assert(s); assert(strend) 7184 7185 STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) 7186 __attribute__warn_unused_result__; 7187 7188 STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) 7189 __attribute__warn_unused_result__ 7190 __attribute__nonnull__(pTHX_2); 7191 #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ 7192 assert(character) 7193 7194 STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) 7195 __attribute__warn_unused_result__ 7196 __attribute__nonnull__(pTHX_1) 7197 __attribute__nonnull__(pTHX_2); 7198 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ 7199 assert(rex); assert(scan) 7200 7201 STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p) 7202 __attribute__nonnull__(pTHX_1) 7203 __attribute__nonnull__(pTHX_2); 7204 #define PERL_ARGS_ASSERT_REGCPPOP \ 7205 assert(rex); assert(maxopenparen_p) 7206 7207 STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen) 7208 __attribute__nonnull__(pTHX_1); 7209 #define PERL_ARGS_ASSERT_REGCPPUSH \ 7210 assert(rex) 7211 7212 STATIC U8* S_reghop3(U8 *s, SSize_t off, const U8 *lim) 7213 __attribute__warn_unused_result__ 7214 __attribute__nonnull__(1) 7215 __attribute__nonnull__(3); 7216 #define PERL_ARGS_ASSERT_REGHOP3 \ 7217 assert(s); assert(lim) 7218 7219 STATIC U8* S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim) 7220 __attribute__warn_unused_result__ 7221 __attribute__nonnull__(1) 7222 __attribute__nonnull__(3) 7223 __attribute__nonnull__(4); 7224 #define PERL_ARGS_ASSERT_REGHOP4 \ 7225 assert(s); assert(llim); assert(rlim) 7226 7227 STATIC U8* S_reghopmaybe3(U8 *s, SSize_t off, const U8 *lim) 7228 __attribute__warn_unused_result__ 7229 __attribute__nonnull__(1) 7230 __attribute__nonnull__(3); 7231 #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ 7232 assert(s); assert(lim) 7233 7234 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) 7235 __attribute__warn_unused_result__ 7236 __attribute__nonnull__(pTHX_2) 7237 __attribute__nonnull__(pTHX_3) 7238 __attribute__nonnull__(pTHX_4); 7239 #define PERL_ARGS_ASSERT_REGINCLASS \ 7240 assert(n); assert(p); assert(p_end) 7241 7242 STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) 7243 __attribute__warn_unused_result__ 7244 __attribute__nonnull__(pTHX_1) 7245 __attribute__nonnull__(pTHX_2) 7246 __attribute__nonnull__(pTHX_3); 7247 #define PERL_ARGS_ASSERT_REGMATCH \ 7248 assert(reginfo); assert(startpos); assert(prog) 7249 7250 STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth) 7251 __attribute__warn_unused_result__ 7252 __attribute__nonnull__(pTHX_1) 7253 __attribute__nonnull__(pTHX_2) 7254 __attribute__nonnull__(pTHX_3) 7255 __attribute__nonnull__(pTHX_4); 7256 #define PERL_ARGS_ASSERT_REGREPEAT \ 7257 assert(prog); assert(startposp); assert(p); assert(reginfo) 7258 7259 STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) 7260 __attribute__warn_unused_result__ 7261 __attribute__nonnull__(pTHX_1) 7262 __attribute__nonnull__(pTHX_2); 7263 #define PERL_ARGS_ASSERT_REGTRY \ 7264 assert(reginfo); assert(startposp) 7265 7266 STATIC bool S_to_byte_substr(pTHX_ regexp * prog) 7267 __attribute__nonnull__(pTHX_1); 7268 #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ 7269 assert(prog) 7270 7271 STATIC void S_to_utf8_substr(pTHX_ regexp * prog) 7272 __attribute__nonnull__(pTHX_1); 7273 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ 7274 assert(prog) 7275 7276 #endif 7277 #if defined(PERL_IN_SCOPE_C) 7278 STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); 7279 STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) 7280 __attribute__nonnull__(pTHX_1); 7281 #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ 7282 assert(sptr) 7283 7284 #endif 7285 #if defined(PERL_IN_SV_C) 7286 STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len) 7287 __attribute__nonnull__(2) 7288 __attribute__nonnull__(3); 7289 #define PERL_ARGS_ASSERT_F0CONVERT \ 7290 assert(endbuf); assert(len) 7291 7292 STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) 7293 __attribute__nonnull__(pTHX_1) 7294 __attribute__nonnull__(pTHX_2); 7295 #define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ 7296 assert(gv); assert(cv) 7297 7298 STATIC void S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN from_cache, STRLEN real, SV *const sv) 7299 __attribute__nonnull__(pTHX_1) 7300 __attribute__nonnull__(pTHX_4); 7301 #define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ 7302 assert(func); assert(sv) 7303 7304 STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt) 7305 __attribute__nonnull__(pTHX_1); 7306 #define PERL_ARGS_ASSERT_CURSE \ 7307 assert(sv) 7308 7309 STATIC I32 S_expect_number(pTHX_ char **const pattern) 7310 __attribute__warn_unused_result__ 7311 __attribute__nonnull__(pTHX_1); 7312 #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ 7313 assert(pattern) 7314 7315 STATIC I32 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val) 7316 __attribute__nonnull__(pTHX_2); 7317 #define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ 7318 assert(val) 7319 7320 STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val) 7321 __attribute__nonnull__(pTHX_2); 7322 #define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ 7323 assert(val) 7324 7325 STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top); 7326 STATIC bool S_glob_2number(pTHX_ GV* const gv) 7327 __attribute__nonnull__(pTHX_1); 7328 #define PERL_ARGS_ASSERT_GLOB_2NUMBER \ 7329 assert(gv) 7330 7331 STATIC void S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype) 7332 __attribute__nonnull__(pTHX_1) 7333 __attribute__nonnull__(pTHX_2); 7334 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ 7335 assert(dstr); assert(sstr) 7336 7337 STATIC void S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr) 7338 __attribute__nonnull__(pTHX_1) 7339 __attribute__nonnull__(pTHX_2); 7340 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \ 7341 assert(dstr); assert(sstr) 7342 7343 STATIC SV * S_more_sv(pTHX); 7344 STATIC void S_not_a_number(pTHX_ SV *const sv) 7345 __attribute__nonnull__(pTHX_1); 7346 #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ 7347 assert(sv) 7348 7349 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) 7350 __attribute__warn_unused_result__ 7351 __attribute__nonnull__(1); 7352 #define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ 7353 assert(tbl) 7354 7355 STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv) 7356 __attribute__nonnull__(pTHX_1); 7357 #define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ 7358 assert(sv) 7359 7360 STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags) 7361 __attribute__nonnull__(pTHX_1); 7362 #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ 7363 assert(ptr) 7364 7365 STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu) 7366 __attribute__nonnull__(pTHX_1) 7367 __attribute__nonnull__(pTHX_2) 7368 __attribute__nonnull__(pTHX_3); 7369 #define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ 7370 assert(s); assert(target); assert(end) 7371 7372 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) 7373 __attribute__nonnull__(pTHX_1) 7374 __attribute__nonnull__(pTHX_2) 7375 __attribute__nonnull__(pTHX_3) 7376 __attribute__nonnull__(pTHX_4); 7377 #define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ 7378 assert(sv); assert(mgp); assert(start); assert(send) 7379 7380 STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STRLEN *const uoffset, bool *const at_end) 7381 __attribute__nonnull__(1) 7382 __attribute__nonnull__(2) 7383 __attribute__nonnull__(3) 7384 __attribute__nonnull__(4); 7385 #define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ 7386 assert(start); assert(send); assert(uoffset); assert(at_end) 7387 7388 STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, const STRLEN uend) 7389 __attribute__nonnull__(1) 7390 __attribute__nonnull__(2); 7391 #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ 7392 assert(start); assert(send) 7393 7394 PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags) 7395 __attribute__nonnull__(pTHX_1); 7396 #define PERL_ARGS_ASSERT_SV_UNGLOB \ 7397 assert(sv) 7398 7399 STATIC char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) 7400 __attribute__warn_unused_result__ 7401 __attribute__nonnull__(1) 7402 __attribute__nonnull__(5); 7403 #define PERL_ARGS_ASSERT_UIV_2BUF \ 7404 assert(buf); assert(peob) 7405 7406 STATIC void S_utf8_mg_len_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN ulen) 7407 __attribute__nonnull__(pTHX_1) 7408 __attribute__nonnull__(pTHX_2); 7409 #define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ 7410 assert(sv); assert(mgp) 7411 7412 STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) 7413 __attribute__nonnull__(pTHX_1) 7414 __attribute__nonnull__(pTHX_2); 7415 #define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ 7416 assert(sv); assert(mgp) 7417 7418 STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) 7419 __attribute__nonnull__(pTHX_1); 7420 #define PERL_ARGS_ASSERT_VISIT \ 7421 assert(f) 7422 7423 # if defined(PERL_OLD_COPY_ON_WRITE) 7424 STATIC void S_sv_release_COW(pTHX_ SV *sv, const char *pvx, SV *after) 7425 __attribute__nonnull__(pTHX_1) 7426 __attribute__nonnull__(pTHX_2) 7427 __attribute__nonnull__(pTHX_3); 7428 #define PERL_ARGS_ASSERT_SV_RELEASE_COW \ 7429 assert(sv); assert(pvx); assert(after) 7430 7431 # endif 7432 # if defined(USE_ITHREADS) 7433 STATIC SV* S_sv_dup_common(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 7434 __attribute__warn_unused_result__ 7435 __attribute__nonnull__(pTHX_1) 7436 __attribute__nonnull__(pTHX_2); 7437 #define PERL_ARGS_ASSERT_SV_DUP_COMMON \ 7438 assert(sstr); assert(param) 7439 7440 STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param) 7441 __attribute__nonnull__(pTHX_1) 7442 __attribute__nonnull__(pTHX_2) 7443 __attribute__nonnull__(pTHX_4); 7444 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ 7445 assert(source); assert(dest); assert(param) 7446 7447 STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced) 7448 __attribute__nonnull__(pTHX_1); 7449 #define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ 7450 assert(unreferenced) 7451 7452 # endif 7453 #endif 7454 #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) 7455 PERL_CALLCONV SV * Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, I32 aindex, int subscript_type) 7456 __attribute__warn_unused_result__; 7457 7458 #endif 7459 #if defined(PERL_IN_TOKE_C) 7460 STATIC int S_ao(pTHX_ int toketype); 7461 STATIC void S_check_uni(pTHX); 7462 STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what) 7463 __attribute__nonnull__(pTHX_1) 7464 __attribute__nonnull__(pTHX_2) 7465 __attribute__nonnull__(pTHX_3); 7466 #define PERL_ARGS_ASSERT_CHECKCOMMA \ 7467 assert(s); assert(name); assert(what) 7468 7469 STATIC int S_deprecate_commaless_var_list(pTHX); 7470 STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) 7471 __attribute__warn_unused_result__ 7472 __attribute__nonnull__(pTHX_1); 7473 #define PERL_ARGS_ASSERT_FILTER_GETS \ 7474 assert(sv) 7475 7476 STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) 7477 __attribute__warn_unused_result__ 7478 __attribute__nonnull__(pTHX_1); 7479 #define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ 7480 assert(pkgname) 7481 7482 STATIC void S_force_ident(pTHX_ const char *s, int kind) 7483 __attribute__nonnull__(pTHX_1); 7484 #define PERL_ARGS_ASSERT_FORCE_IDENT \ 7485 assert(s) 7486 7487 STATIC void S_force_ident_maybe_lex(pTHX_ char pit); 7488 STATIC void S_force_next(pTHX_ I32 type); 7489 STATIC char* S_force_strict_version(pTHX_ char *s) 7490 __attribute__nonnull__(pTHX_1); 7491 #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ 7492 assert(s) 7493 7494 STATIC char* S_force_version(pTHX_ char *s, int guessing) 7495 __attribute__nonnull__(pTHX_1); 7496 #define PERL_ARGS_ASSERT_FORCE_VERSION \ 7497 assert(s) 7498 7499 STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack) 7500 __attribute__nonnull__(pTHX_1); 7501 #define PERL_ARGS_ASSERT_FORCE_WORD \ 7502 assert(start) 7503 7504 PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e) 7505 __attribute__warn_unused_result__ 7506 __attribute__nonnull__(pTHX_1) 7507 __attribute__nonnull__(pTHX_2); 7508 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ 7509 assert(s); assert(e) 7510 7511 STATIC void S_incline(pTHX_ const char *s) 7512 __attribute__nonnull__(pTHX_1); 7513 #define PERL_ARGS_ASSERT_INCLINE \ 7514 assert(s) 7515 7516 STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv) 7517 __attribute__nonnull__(pTHX_1); 7518 #define PERL_ARGS_ASSERT_INTUIT_METHOD \ 7519 assert(s) 7520 7521 STATIC int S_intuit_more(pTHX_ char *s) 7522 __attribute__nonnull__(pTHX_1); 7523 #define PERL_ARGS_ASSERT_INTUIT_MORE \ 7524 assert(s) 7525 7526 STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) 7527 __attribute__nonnull__(pTHX_3); 7528 #define PERL_ARGS_ASSERT_LOP \ 7529 assert(s) 7530 7531 PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s) 7532 __attribute__noreturn__; 7533 7534 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) 7535 __attribute__nonnull__(pTHX_3) 7536 __attribute__nonnull__(pTHX_5); 7537 #define PERL_ARGS_ASSERT_NEW_CONSTANT \ 7538 assert(key); assert(sv) 7539 7540 STATIC void S_no_op(pTHX_ const char *const what, char *s) 7541 __attribute__nonnull__(pTHX_1); 7542 #define PERL_ARGS_ASSERT_NO_OP \ 7543 assert(what) 7544 7545 STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8) 7546 __attribute__nonnull__(pTHX_1) 7547 __attribute__nonnull__(pTHX_2) 7548 __attribute__nonnull__(pTHX_3); 7549 #define PERL_ARGS_ASSERT_PARSE_IDENT \ 7550 assert(s); assert(d); assert(e) 7551 7552 STATIC int S_pending_ident(pTHX); 7553 STATIC char* S_scan_const(pTHX_ char *start) 7554 __attribute__warn_unused_result__ 7555 __attribute__nonnull__(pTHX_1); 7556 #define PERL_ARGS_ASSERT_SCAN_CONST \ 7557 assert(start) 7558 7559 STATIC char* S_scan_formline(pTHX_ char *s) 7560 __attribute__warn_unused_result__ 7561 __attribute__nonnull__(pTHX_1); 7562 #define PERL_ARGS_ASSERT_SCAN_FORMLINE \ 7563 assert(s) 7564 7565 STATIC char* S_scan_heredoc(pTHX_ char *s) 7566 __attribute__warn_unused_result__ 7567 __attribute__nonnull__(pTHX_1); 7568 #define PERL_ARGS_ASSERT_SCAN_HEREDOC \ 7569 assert(s) 7570 7571 STATIC char* S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) 7572 __attribute__nonnull__(pTHX_1) 7573 __attribute__nonnull__(pTHX_2); 7574 #define PERL_ARGS_ASSERT_SCAN_IDENT \ 7575 assert(s); assert(dest) 7576 7577 STATIC char* S_scan_inputsymbol(pTHX_ char *start) 7578 __attribute__warn_unused_result__ 7579 __attribute__nonnull__(pTHX_1); 7580 #define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ 7581 assert(start) 7582 7583 STATIC char* S_scan_pat(pTHX_ char *start, I32 type) 7584 __attribute__warn_unused_result__ 7585 __attribute__nonnull__(pTHX_1); 7586 #define PERL_ARGS_ASSERT_SCAN_PAT \ 7587 assert(start) 7588 7589 STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char **delimp) 7590 __attribute__warn_unused_result__ 7591 __attribute__nonnull__(pTHX_1); 7592 #define PERL_ARGS_ASSERT_SCAN_STR \ 7593 assert(start) 7594 7595 STATIC char* S_scan_subst(pTHX_ char *start) 7596 __attribute__warn_unused_result__ 7597 __attribute__nonnull__(pTHX_1); 7598 #define PERL_ARGS_ASSERT_SCAN_SUBST \ 7599 assert(start) 7600 7601 STATIC char* S_scan_trans(pTHX_ char *start) 7602 __attribute__warn_unused_result__ 7603 __attribute__nonnull__(pTHX_1); 7604 #define PERL_ARGS_ASSERT_SCAN_TRANS \ 7605 assert(start) 7606 7607 STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) 7608 __attribute__nonnull__(pTHX_1) 7609 __attribute__nonnull__(pTHX_2) 7610 __attribute__nonnull__(pTHX_5); 7611 #define PERL_ARGS_ASSERT_SCAN_WORD \ 7612 assert(s); assert(dest); assert(slp) 7613 7614 STATIC char* S_skipspace_flags(pTHX_ char *s, U32 flags) 7615 __attribute__warn_unused_result__ 7616 __attribute__nonnull__(pTHX_1); 7617 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ 7618 assert(s) 7619 7620 STATIC I32 S_sublex_done(pTHX) 7621 __attribute__warn_unused_result__; 7622 7623 STATIC I32 S_sublex_push(pTHX) 7624 __attribute__warn_unused_result__; 7625 7626 STATIC I32 S_sublex_start(pTHX) 7627 __attribute__warn_unused_result__; 7628 7629 STATIC char* S_swallow_bom(pTHX_ U8 *s) 7630 __attribute__warn_unused_result__ 7631 __attribute__nonnull__(pTHX_1); 7632 #define PERL_ARGS_ASSERT_SWALLOW_BOM \ 7633 assert(s) 7634 7635 STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) 7636 __attribute__warn_unused_result__ 7637 __attribute__nonnull__(pTHX_2); 7638 #define PERL_ARGS_ASSERT_TOKENIZE_USE \ 7639 assert(s) 7640 7641 STATIC SV* S_tokeq(pTHX_ SV *sv) 7642 __attribute__nonnull__(pTHX_1); 7643 #define PERL_ARGS_ASSERT_TOKEQ \ 7644 assert(sv) 7645 7646 STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); 7647 STATIC int S_yywarn(pTHX_ const char *const s, U32 flags) 7648 __attribute__nonnull__(pTHX_1); 7649 #define PERL_ARGS_ASSERT_YYWARN \ 7650 assert(s) 7651 7652 # if defined(PERL_MAD) 7653 STATIC void S_curmad(pTHX_ char slot, SV *sv); 7654 STATIC char* S_skipspace0(pTHX_ char *s) 7655 __attribute__nonnull__(pTHX_1); 7656 #define PERL_ARGS_ASSERT_SKIPSPACE0 \ 7657 assert(s) 7658 7659 STATIC char* S_skipspace1(pTHX_ char *s) 7660 __attribute__nonnull__(pTHX_1); 7661 #define PERL_ARGS_ASSERT_SKIPSPACE1 \ 7662 assert(s) 7663 7664 STATIC char* S_skipspace2(pTHX_ char *s, SV **sv) 7665 __attribute__nonnull__(pTHX_1); 7666 #define PERL_ARGS_ASSERT_SKIPSPACE2 \ 7667 assert(s) 7668 7669 STATIC void S_start_force(pTHX_ int where); 7670 # endif 7671 #endif 7672 #if defined(PERL_IN_UNIVERSAL_C) 7673 STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags) 7674 __attribute__nonnull__(pTHX_1) 7675 __attribute__nonnull__(pTHX_2); 7676 #define PERL_ARGS_ASSERT_ISA_LOOKUP \ 7677 assert(stash); assert(name) 7678 7679 #endif 7680 #if defined(PERL_IN_UTF8_C) 7681 STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp) 7682 __attribute__warn_unused_result__ 7683 __attribute__nonnull__(pTHX_1) 7684 __attribute__nonnull__(pTHX_3) 7685 __attribute__nonnull__(pTHX_4); 7686 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ 7687 assert(p); assert(ustrp); assert(lenp) 7688 7689 PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) 7690 __attribute__warn_unused_result__ 7691 __attribute__nonnull__(1); 7692 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ 7693 assert(s) 7694 7695 PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname, SV* const invlist) 7696 __attribute__warn_unused_result__ 7697 __attribute__nonnull__(pTHX_1) 7698 __attribute__nonnull__(pTHX_2) 7699 __attribute__nonnull__(pTHX_3); 7700 #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ 7701 assert(p); assert(swash); assert(swashname) 7702 7703 STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) 7704 __attribute__warn_unused_result__ 7705 __attribute__nonnull__(pTHX_1); 7706 #define PERL_ARGS_ASSERT_SWATCH_GET \ 7707 assert(swash) 7708 7709 STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp) 7710 __attribute__warn_unused_result__; 7711 7712 #endif 7713 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) 7714 PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) 7715 __attribute__nonnull__(pTHX_2) 7716 __attribute__nonnull__(pTHX_3); 7717 #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ 7718 assert(p); assert(lenp) 7719 7720 #endif 7721 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 7722 PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags) 7723 __attribute__nonnull__(pTHX_2) 7724 __attribute__nonnull__(pTHX_3); 7725 #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ 7726 assert(p); assert(lenp) 7727 7728 #endif 7729 #if defined(PERL_IN_UTIL_C) 7730 STATIC bool S_ckwarn_common(pTHX_ U32 w); 7731 STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn); 7732 STATIC SV* S_mess_alloc(pTHX); 7733 STATIC SV * S_with_queued_errors(pTHX_ SV *ex) 7734 __attribute__nonnull__(pTHX_1); 7735 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ 7736 assert(ex) 7737 7738 # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) 7739 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) 7740 __attribute__nonnull__(4) 7741 __attribute__nonnull__(8) 7742 __attribute__nonnull__(10); 7743 #define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ 7744 assert(type_name); assert(filename); assert(funcname) 7745 7746 # endif 7747 #endif 7748 #if defined(PERL_MAD) 7749 PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot); 7750 PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot); 7751 PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o) 7752 __attribute__nonnull__(pTHX_2); 7753 #define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \ 7754 assert(file) 7755 7756 PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) 7757 __attribute__nonnull__(pTHX_2); 7758 #define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \ 7759 assert(file) 7760 7761 PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp); 7762 PERL_CALLCONV int Perl_madlex(pTHX); 7763 PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype); 7764 PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 7765 PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen); 7766 PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) 7767 __attribute__nonnull__(pTHX_2); 7768 #define PERL_ARGS_ASSERT_NEWMADSV \ 7769 assert(sv) 7770 7771 PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); 7772 PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); 7773 PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); 7774 PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o) 7775 __attribute__nonnull__(pTHX_1); 7776 #define PERL_ARGS_ASSERT_OP_XMLDUMP \ 7777 assert(o) 7778 7779 PERL_CALLCONV OP* Perl_package(pTHX_ OP* o) 7780 __attribute__nonnull__(pTHX_1); 7781 #define PERL_ARGS_ASSERT_PACKAGE \ 7782 assert(o) 7783 7784 PERL_CALLCONV void Perl_pad_peg(const char* s) 7785 __attribute__nonnull__(1); 7786 #define PERL_ARGS_ASSERT_PAD_PEG \ 7787 assert(s) 7788 7789 PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm); 7790 PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot); 7791 PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8) 7792 __attribute__nonnull__(pTHX_1) 7793 __attribute__nonnull__(pTHX_2); 7794 #define PERL_ARGS_ASSERT_SV_CATXMLPV \ 7795 assert(dsv); assert(pv) 7796 7797 PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8) 7798 __attribute__nonnull__(pTHX_1) 7799 __attribute__nonnull__(pTHX_2); 7800 #define PERL_ARGS_ASSERT_SV_CATXMLPVN \ 7801 assert(dsv); assert(pv) 7802 7803 PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv) 7804 __attribute__nonnull__(pTHX_1) 7805 __attribute__nonnull__(pTHX_2); 7806 #define PERL_ARGS_ASSERT_SV_CATXMLSV \ 7807 assert(dsv); assert(ssv) 7808 7809 PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv) 7810 __attribute__nonnull__(pTHX_1); 7811 #define PERL_ARGS_ASSERT_SV_XMLPEEK \ 7812 assert(sv) 7813 7814 PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk) 7815 __attribute__nonnull__(pTHX_1); 7816 #define PERL_ARGS_ASSERT_TOKEN_FREE \ 7817 assert(tk) 7818 7819 PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot) 7820 __attribute__nonnull__(pTHX_1); 7821 #define PERL_ARGS_ASSERT_TOKEN_GETMAD \ 7822 assert(tk) 7823 7824 PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 7825 __attribute__nonnull__(pTHX_4); 7826 #define PERL_ARGS_ASSERT_UTILIZE \ 7827 assert(idop) 7828 7829 PERL_CALLCONV void Perl_xmldump_all(pTHX); 7830 PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl); 7831 PERL_CALLCONV void Perl_xmldump_eval(pTHX); 7832 PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv) 7833 __attribute__nonnull__(pTHX_1); 7834 #define PERL_ARGS_ASSERT_XMLDUMP_FORM \ 7835 assert(gv) 7836 7837 PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 7838 __attribute__format__(__printf__,pTHX_3,pTHX_4) 7839 __attribute__nonnull__(pTHX_2) 7840 __attribute__nonnull__(pTHX_3); 7841 #define PERL_ARGS_ASSERT_XMLDUMP_INDENT \ 7842 assert(file); assert(pat) 7843 7844 PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash) 7845 __attribute__nonnull__(pTHX_1); 7846 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \ 7847 assert(stash) 7848 7849 PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl) 7850 __attribute__nonnull__(pTHX_1); 7851 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \ 7852 assert(stash) 7853 7854 PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv) 7855 __attribute__nonnull__(pTHX_1); 7856 #define PERL_ARGS_ASSERT_XMLDUMP_SUB \ 7857 assert(gv) 7858 7859 PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl) 7860 __attribute__nonnull__(pTHX_1); 7861 #define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \ 7862 assert(gv) 7863 7864 PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) 7865 __attribute__nonnull__(pTHX_2) 7866 __attribute__nonnull__(pTHX_3); 7867 #define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \ 7868 assert(file); assert(pat) 7869 7870 #endif 7871 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) 7872 STATIC void S_pidgone(pTHX_ Pid_t pid, int status); 7873 #endif 7874 #if defined(UNLINK_ALL_VERSIONS) 7875 PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) 7876 __attribute__nonnull__(pTHX_1); 7877 #define PERL_ARGS_ASSERT_UNLNK \ 7878 assert(f) 7879 7880 #endif 7881 #if defined(USE_ITHREADS) 7882 PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv) 7883 __attribute__nonnull__(pTHX_1); 7884 #define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ 7885 assert(hv) 7886 7887 PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) 7888 __attribute__warn_unused_result__ 7889 __attribute__nonnull__(pTHX_2); 7890 #define PERL_ARGS_ASSERT_ANY_DUP \ 7891 assert(proto_perl) 7892 7893 PERL_CALLCONV void Perl_clone_params_del(CLONE_PARAMS *param) 7894 __attribute__nonnull__(1); 7895 #define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ 7896 assert(param) 7897 7898 PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter *const from, PerlInterpreter *const to) 7899 __attribute__malloc__ 7900 __attribute__warn_unused_result__ 7901 __attribute__nonnull__(1) 7902 __attribute__nonnull__(2); 7903 #define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ 7904 assert(from); assert(to) 7905 7906 PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param) 7907 __attribute__warn_unused_result__ 7908 __attribute__nonnull__(pTHX_4); 7909 #define PERL_ARGS_ASSERT_CX_DUP \ 7910 assert(param) 7911 7912 PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp, CLONE_PARAMS *const param) 7913 __attribute__warn_unused_result__ 7914 __attribute__nonnull__(pTHX_2); 7915 #define PERL_ARGS_ASSERT_DIRP_DUP \ 7916 assert(param) 7917 7918 PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param) 7919 __attribute__nonnull__(pTHX_3); 7920 #define PERL_ARGS_ASSERT_FP_DUP \ 7921 assert(param) 7922 7923 PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param) 7924 __attribute__warn_unused_result__ 7925 __attribute__nonnull__(pTHX_2); 7926 #define PERL_ARGS_ASSERT_GP_DUP \ 7927 assert(param) 7928 7929 PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param) 7930 __attribute__warn_unused_result__ 7931 __attribute__nonnull__(pTHX_3); 7932 #define PERL_ARGS_ASSERT_HE_DUP \ 7933 assert(param) 7934 7935 PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param) 7936 __attribute__warn_unused_result__ 7937 __attribute__nonnull__(pTHX_2); 7938 #define PERL_ARGS_ASSERT_HEK_DUP \ 7939 assert(param) 7940 7941 PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param) 7942 __attribute__warn_unused_result__ 7943 __attribute__nonnull__(pTHX_2); 7944 #define PERL_ARGS_ASSERT_MG_DUP \ 7945 assert(param) 7946 7947 PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param) 7948 __attribute__nonnull__(pTHX_1) 7949 __attribute__nonnull__(pTHX_2); 7950 #define PERL_ARGS_ASSERT_MRO_META_DUP \ 7951 assert(smeta); assert(param) 7952 7953 PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) 7954 __attribute__malloc__ 7955 __attribute__warn_unused_result__ 7956 __attribute__nonnull__(pTHX_3); 7957 #define PERL_ARGS_ASSERT_NEWPADOP \ 7958 assert(sv) 7959 7960 PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) 7961 __attribute__warn_unused_result__ 7962 __attribute__nonnull__(pTHX_2); 7963 #define PERL_ARGS_ASSERT_PADLIST_DUP \ 7964 assert(param) 7965 7966 PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param) 7967 __attribute__nonnull__(pTHX_2); 7968 #define PERL_ARGS_ASSERT_PARSER_DUP \ 7969 assert(param) 7970 7971 PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags) 7972 __attribute__nonnull__(1); 7973 #define PERL_ARGS_ASSERT_PERL_CLONE \ 7974 assert(proto_perl) 7975 7976 PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS* param) 7977 __attribute__nonnull__(pTHX_1) 7978 __attribute__nonnull__(pTHX_2) 7979 __attribute__nonnull__(pTHX_3); 7980 #define PERL_ARGS_ASSERT_RE_DUP_GUTS \ 7981 assert(sstr); assert(dstr); assert(param) 7982 7983 PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param) 7984 __attribute__nonnull__(pTHX_1) 7985 __attribute__nonnull__(pTHX_2); 7986 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ 7987 assert(r); assert(param) 7988 7989 PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param) 7990 __attribute__nonnull__(pTHX_1) 7991 __attribute__nonnull__(pTHX_2) 7992 __attribute__nonnull__(pTHX_3); 7993 #define PERL_ARGS_ASSERT_RVPV_DUP \ 7994 assert(dstr); assert(sstr); assert(param) 7995 7996 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param) 7997 __attribute__warn_unused_result__ 7998 __attribute__nonnull__(pTHX_2); 7999 #define PERL_ARGS_ASSERT_SI_DUP \ 8000 assert(param) 8001 8002 PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param) 8003 __attribute__malloc__ 8004 __attribute__warn_unused_result__ 8005 __attribute__nonnull__(pTHX_1) 8006 __attribute__nonnull__(pTHX_2); 8007 #define PERL_ARGS_ASSERT_SS_DUP \ 8008 assert(proto_perl); assert(param) 8009 8010 PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 8011 __attribute__warn_unused_result__ 8012 __attribute__nonnull__(pTHX_2); 8013 #define PERL_ARGS_ASSERT_SV_DUP \ 8014 assert(param) 8015 8016 PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 8017 __attribute__warn_unused_result__ 8018 __attribute__nonnull__(pTHX_2); 8019 #define PERL_ARGS_ASSERT_SV_DUP_INC \ 8020 assert(param) 8021 8022 #endif 8023 #if defined(USE_LOCALE_COLLATE) 8024 PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg) 8025 __attribute__nonnull__(pTHX_1) 8026 __attribute__nonnull__(pTHX_2); 8027 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ 8028 assert(sv); assert(mg) 8029 8030 PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen) 8031 __attribute__nonnull__(pTHX_1) 8032 __attribute__nonnull__(pTHX_3); 8033 #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ 8034 assert(s); assert(xlen) 8035 8036 /* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp) 8037 __attribute__nonnull__(pTHX_1) 8038 __attribute__nonnull__(pTHX_2); */ 8039 8040 PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags) 8041 __attribute__nonnull__(pTHX_1) 8042 __attribute__nonnull__(pTHX_2); 8043 #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ 8044 assert(sv); assert(nxp) 8045 8046 #endif 8047 #if defined(USE_PERLIO) 8048 PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); 8049 PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); 8050 PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); 8051 PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); 8052 PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); 8053 PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); 8054 PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); 8055 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); 8056 PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) 8057 __attribute__warn_unused_result__; 8058 8059 PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) 8060 __attribute__warn_unused_result__; 8061 8062 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); 8063 PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) 8064 __attribute__nonnull__(pTHX_2); 8065 #define PERL_ARGS_ASSERT_PERLIO_READ \ 8066 assert(vbuf) 8067 8068 PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); 8069 PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); 8070 PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); 8071 PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); 8072 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) 8073 __attribute__warn_unused_result__; 8074 8075 PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) 8076 __attribute__warn_unused_result__; 8077 8078 PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) 8079 __attribute__warn_unused_result__; 8080 8081 PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); 8082 PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 8083 __attribute__nonnull__(pTHX_2); 8084 #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ 8085 assert(vbuf) 8086 8087 PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 8088 __attribute__nonnull__(pTHX_2); 8089 #define PERL_ARGS_ASSERT_PERLIO_WRITE \ 8090 assert(vbuf) 8091 8092 #endif 8093 #if defined(WIN32) 8094 PERL_CALLCONV char* Perl_my_setlocale(pTHX_ int category, const char* locale) 8095 __attribute__pure__; 8096 8097 PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname) 8098 __attribute__noreturn__ 8099 __attribute__nonnull__(1); 8100 #define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ 8101 assert(fname) 8102 8103 #endif 8104 #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) 8105 PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp) 8106 __attribute__nonnull__(pTHX_2) 8107 __attribute__nonnull__(pTHX_3); 8108 #define PERL_ARGS_ASSERT_DO_ASPAWN \ 8109 assert(mark); assert(sp) 8110 8111 PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd) 8112 __attribute__nonnull__(pTHX_1); 8113 #define PERL_ARGS_ASSERT_DO_SPAWN \ 8114 assert(cmd) 8115 8116 PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) 8117 __attribute__nonnull__(pTHX_1); 8118 #define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ 8119 assert(cmd) 8120 8121 #endif 8122 #if defined(_MSC_VER) 8123 PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 8124 __attribute__nonnull__(pTHX_1) 8125 __attribute__nonnull__(pTHX_2); 8126 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 8127 assert(sv); assert(mg) 8128 8129 #endif 8130 #ifdef PERL_CORE 8131 # include "pp_proto.h" 8132 #endif 8133 END_EXTERN_C 8134 8135 /* ex: set ro: */ 8136