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_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv) 4256 __attribute__nonnull__(1); 4257 #define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ 4258 assert(sv) 4259 4260 PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); 4261 PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp) 4262 __attribute__nonnull__(pTHX_2); 4263 #define PERL_ARGS_ASSERT_SV_POS_B2U \ 4264 assert(offsetp) 4265 4266 PERL_CALLCONV STRLEN Perl_sv_pos_b2u_flags(pTHX_ SV *const sv, STRLEN const offset, U32 flags) 4267 __attribute__nonnull__(pTHX_1); 4268 #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ 4269 assert(sv) 4270 4271 PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp) 4272 __attribute__nonnull__(pTHX_2); 4273 #define PERL_ARGS_ASSERT_SV_POS_U2B \ 4274 assert(offsetp) 4275 4276 PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags) 4277 __attribute__nonnull__(pTHX_1); 4278 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ 4279 assert(sv) 4280 4281 /* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv) 4282 __attribute__warn_unused_result__ 4283 __attribute__nonnull__(pTHX_1); */ 4284 #define PERL_ARGS_ASSERT_SV_PV \ 4285 assert(sv) 4286 4287 /* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) 4288 __attribute__warn_unused_result__ 4289 __attribute__nonnull__(pTHX_1); */ 4290 #define PERL_ARGS_ASSERT_SV_PVBYTE \ 4291 assert(sv) 4292 4293 PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp) 4294 __attribute__nonnull__(pTHX_1) 4295 __attribute__nonnull__(pTHX_2); 4296 #define PERL_ARGS_ASSERT_SV_PVBYTEN \ 4297 assert(sv); assert(lp) 4298 4299 PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp) 4300 __attribute__nonnull__(pTHX_1); 4301 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ 4302 assert(sv) 4303 4304 PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp) 4305 __attribute__nonnull__(pTHX_1) 4306 __attribute__nonnull__(pTHX_2); 4307 #define PERL_ARGS_ASSERT_SV_PVN \ 4308 assert(sv); assert(lp) 4309 4310 /* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp) 4311 __attribute__nonnull__(pTHX_1); */ 4312 #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ 4313 assert(sv) 4314 4315 PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags) 4316 __attribute__nonnull__(pTHX_1); 4317 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ 4318 assert(sv) 4319 4320 PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp) 4321 __attribute__nonnull__(pTHX_1); 4322 #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ 4323 assert(sv) 4324 4325 /* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) 4326 __attribute__warn_unused_result__ 4327 __attribute__nonnull__(pTHX_1); */ 4328 #define PERL_ARGS_ASSERT_SV_PVUTF8 \ 4329 assert(sv) 4330 4331 PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp) 4332 __attribute__nonnull__(pTHX_1) 4333 __attribute__nonnull__(pTHX_2); 4334 #define PERL_ARGS_ASSERT_SV_PVUTF8N \ 4335 assert(sv); assert(lp) 4336 4337 PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp) 4338 __attribute__nonnull__(pTHX_1); 4339 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ 4340 assert(sv) 4341 4342 PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding) 4343 __attribute__nonnull__(pTHX_1) 4344 __attribute__nonnull__(pTHX_2); 4345 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ 4346 assert(sv); assert(encoding) 4347 4348 PERL_CALLCONV SV* Perl_sv_ref(pTHX_ SV *dst, const SV *const sv, const int ob) 4349 __attribute__nonnull__(pTHX_2); 4350 #define PERL_ARGS_ASSERT_SV_REF \ 4351 assert(sv) 4352 4353 PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob) 4354 __attribute__warn_unused_result__ 4355 __attribute__nonnull__(pTHX_1); 4356 #define PERL_ARGS_ASSERT_SV_REFTYPE \ 4357 assert(sv) 4358 4359 PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv) 4360 __attribute__nonnull__(pTHX_1) 4361 __attribute__nonnull__(pTHX_2); 4362 #define PERL_ARGS_ASSERT_SV_REPLACE \ 4363 assert(sv); assert(nsv) 4364 4365 PERL_CALLCONV void Perl_sv_report_used(pTHX); 4366 PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash) 4367 __attribute__nonnull__(pTHX_1); 4368 #define PERL_ARGS_ASSERT_SV_RESET \ 4369 assert(s) 4370 4371 PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const stash); 4372 PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv) 4373 __attribute__nonnull__(pTHX_1); 4374 #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ 4375 assert(sv) 4376 4377 PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek) 4378 __attribute__nonnull__(pTHX_1); 4379 #define PERL_ARGS_ASSERT_SV_SETHEK \ 4380 assert(sv) 4381 4382 PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num) 4383 __attribute__nonnull__(pTHX_1); 4384 #define PERL_ARGS_ASSERT_SV_SETIV \ 4385 assert(sv) 4386 4387 PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i) 4388 __attribute__nonnull__(pTHX_1); 4389 #define PERL_ARGS_ASSERT_SV_SETIV_MG \ 4390 assert(sv) 4391 4392 PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num) 4393 __attribute__nonnull__(pTHX_1); 4394 #define PERL_ARGS_ASSERT_SV_SETNV \ 4395 assert(sv) 4396 4397 PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num) 4398 __attribute__nonnull__(pTHX_1); 4399 #define PERL_ARGS_ASSERT_SV_SETNV_MG \ 4400 assert(sv) 4401 4402 PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr) 4403 __attribute__nonnull__(pTHX_1); 4404 #define PERL_ARGS_ASSERT_SV_SETPV \ 4405 assert(sv) 4406 4407 PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr) 4408 __attribute__nonnull__(pTHX_1); 4409 #define PERL_ARGS_ASSERT_SV_SETPV_MG \ 4410 assert(sv) 4411 4412 PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...) 4413 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4414 __attribute__nonnull__(pTHX_1) 4415 __attribute__nonnull__(pTHX_2); 4416 #define PERL_ARGS_ASSERT_SV_SETPVF \ 4417 assert(sv); assert(pat) 4418 4419 PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 4420 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4421 __attribute__nonnull__(pTHX_1) 4422 __attribute__nonnull__(pTHX_2); 4423 #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ 4424 assert(sv); assert(pat) 4425 4426 PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num) 4427 __attribute__nonnull__(pTHX_1); 4428 #define PERL_ARGS_ASSERT_SV_SETPVIV \ 4429 assert(sv) 4430 4431 PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv) 4432 __attribute__nonnull__(pTHX_1); 4433 #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \ 4434 assert(sv) 4435 4436 PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 4437 __attribute__nonnull__(pTHX_1); 4438 #define PERL_ARGS_ASSERT_SV_SETPVN \ 4439 assert(sv) 4440 4441 PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 4442 __attribute__nonnull__(pTHX_1) 4443 __attribute__nonnull__(pTHX_2); 4444 #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ 4445 assert(sv); assert(ptr) 4446 4447 PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv) 4448 __attribute__nonnull__(pTHX_1); 4449 #define PERL_ARGS_ASSERT_SV_SETREF_IV \ 4450 assert(rv) 4451 4452 PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv) 4453 __attribute__nonnull__(pTHX_1); 4454 #define PERL_ARGS_ASSERT_SV_SETREF_NV \ 4455 assert(rv) 4456 4457 PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv) 4458 __attribute__nonnull__(pTHX_1); 4459 #define PERL_ARGS_ASSERT_SV_SETREF_PV \ 4460 assert(rv) 4461 4462 PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n) 4463 __attribute__nonnull__(pTHX_1) 4464 __attribute__nonnull__(pTHX_3); 4465 #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ 4466 assert(rv); assert(pv) 4467 4468 PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv) 4469 __attribute__nonnull__(pTHX_1); 4470 #define PERL_ARGS_ASSERT_SV_SETREF_UV \ 4471 assert(rv) 4472 4473 /* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr) 4474 __attribute__nonnull__(pTHX_1); */ 4475 #define PERL_ARGS_ASSERT_SV_SETSV \ 4476 assert(dstr) 4477 4478 PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags) 4479 __attribute__nonnull__(pTHX_1); 4480 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ 4481 assert(dstr) 4482 4483 PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr) 4484 __attribute__nonnull__(pTHX_1); 4485 #define PERL_ARGS_ASSERT_SV_SETSV_MG \ 4486 assert(dstr) 4487 4488 PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num) 4489 __attribute__nonnull__(pTHX_1); 4490 #define PERL_ARGS_ASSERT_SV_SETUV \ 4491 assert(sv) 4492 4493 PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u) 4494 __attribute__nonnull__(pTHX_1); 4495 #define PERL_ARGS_ASSERT_SV_SETUV_MG \ 4496 assert(sv) 4497 4498 /* PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv) 4499 __attribute__nonnull__(pTHX_1); */ 4500 #define PERL_ARGS_ASSERT_SV_TAINT \ 4501 assert(sv) 4502 4503 PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) 4504 __attribute__warn_unused_result__ 4505 __attribute__nonnull__(pTHX_1); 4506 #define PERL_ARGS_ASSERT_SV_TAINTED \ 4507 assert(sv) 4508 4509 PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); 4510 PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) 4511 __attribute__warn_unused_result__ 4512 __attribute__nonnull__(pTHX_1) 4513 __attribute__nonnull__(pTHX_2); 4514 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ 4515 assert(dsv); assert(ssv) 4516 4517 PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type) 4518 __attribute__nonnull__(pTHX_1); 4519 #define PERL_ARGS_ASSERT_SV_UNMAGIC \ 4520 assert(sv) 4521 4522 PERL_CALLCONV int Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl) 4523 __attribute__nonnull__(pTHX_1); 4524 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ 4525 assert(sv) 4526 4527 /* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv) 4528 __attribute__nonnull__(pTHX_1); */ 4529 #define PERL_ARGS_ASSERT_SV_UNREF \ 4530 assert(sv) 4531 4532 PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags) 4533 __attribute__nonnull__(pTHX_1); 4534 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ 4535 assert(ref) 4536 4537 PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv) 4538 __attribute__nonnull__(pTHX_1); 4539 #define PERL_ARGS_ASSERT_SV_UNTAINT \ 4540 assert(sv) 4541 4542 PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type) 4543 __attribute__nonnull__(pTHX_1); 4544 #define PERL_ARGS_ASSERT_SV_UPGRADE \ 4545 assert(sv) 4546 4547 /* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len) 4548 __attribute__nonnull__(pTHX_1); */ 4549 #define PERL_ARGS_ASSERT_SV_USEPVN \ 4550 assert(sv) 4551 4552 PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags) 4553 __attribute__nonnull__(pTHX_1); 4554 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ 4555 assert(sv) 4556 4557 /* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) 4558 __attribute__nonnull__(pTHX_1); */ 4559 #define PERL_ARGS_ASSERT_SV_USEPVN_MG \ 4560 assert(sv) 4561 4562 PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv) 4563 __attribute__nonnull__(pTHX_1); 4564 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ 4565 assert(sv) 4566 4567 PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok) 4568 __attribute__nonnull__(pTHX_1); 4569 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ 4570 assert(sv) 4571 4572 PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv) 4573 __attribute__nonnull__(pTHX_1); 4574 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ 4575 assert(sv) 4576 4577 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv) 4578 __attribute__nonnull__(pTHX_1); */ 4579 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ 4580 assert(sv) 4581 4582 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags) 4583 __attribute__nonnull__(pTHX_1); */ 4584 4585 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra) 4586 __attribute__nonnull__(pTHX_1); 4587 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ 4588 assert(sv) 4589 4590 /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv) 4591 __attribute__nonnull__(pTHX_1); */ 4592 4593 PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) 4594 __attribute__nonnull__(pTHX_1); 4595 #define PERL_ARGS_ASSERT_SV_UV \ 4596 assert(sv) 4597 4598 PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4599 __attribute__nonnull__(pTHX_1) 4600 __attribute__nonnull__(pTHX_2); 4601 #define PERL_ARGS_ASSERT_SV_VCATPVF \ 4602 assert(sv); assert(pat) 4603 4604 PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4605 __attribute__nonnull__(pTHX_1) 4606 __attribute__nonnull__(pTHX_2); 4607 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ 4608 assert(sv); assert(pat) 4609 4610 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) 4611 __attribute__nonnull__(pTHX_1) 4612 __attribute__nonnull__(pTHX_2); 4613 #define PERL_ARGS_ASSERT_SV_VCATPVFN \ 4614 assert(sv); assert(pat) 4615 4616 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) 4617 __attribute__nonnull__(pTHX_1) 4618 __attribute__nonnull__(pTHX_2); 4619 #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ 4620 assert(sv); assert(pat) 4621 4622 PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4623 __attribute__nonnull__(pTHX_1) 4624 __attribute__nonnull__(pTHX_2); 4625 #define PERL_ARGS_ASSERT_SV_VSETPVF \ 4626 assert(sv); assert(pat) 4627 4628 PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 4629 __attribute__nonnull__(pTHX_1) 4630 __attribute__nonnull__(pTHX_2); 4631 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ 4632 assert(sv); assert(pat) 4633 4634 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) 4635 __attribute__nonnull__(pTHX_1) 4636 __attribute__nonnull__(pTHX_2); 4637 #define PERL_ARGS_ASSERT_SV_VSETPVFN \ 4638 assert(sv); assert(pat) 4639 4640 PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8) 4641 __attribute__nonnull__(pTHX_1) 4642 __attribute__nonnull__(pTHX_2); 4643 #define PERL_ARGS_ASSERT_SWASH_FETCH \ 4644 assert(swash); assert(ptr) 4645 4646 PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none) 4647 __attribute__warn_unused_result__ 4648 __attribute__nonnull__(pTHX_1) 4649 __attribute__nonnull__(pTHX_2) 4650 __attribute__nonnull__(pTHX_3); 4651 #define PERL_ARGS_ASSERT_SWASH_INIT \ 4652 assert(pkg); assert(name); assert(listsv) 4653 4654 /* PERL_CALLCONV void sync_locale(void); */ 4655 PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv) 4656 __attribute__nonnull__(1) 4657 __attribute__nonnull__(2); 4658 #define PERL_ARGS_ASSERT_SYS_INIT \ 4659 assert(argc); assert(argv) 4660 4661 PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env) 4662 __attribute__nonnull__(1) 4663 __attribute__nonnull__(2) 4664 __attribute__nonnull__(3); 4665 #define PERL_ARGS_ASSERT_SYS_INIT3 \ 4666 assert(argc); assert(argv); assert(env) 4667 4668 PERL_CALLCONV void Perl_sys_term(void); 4669 PERL_CALLCONV void Perl_taint_env(pTHX); 4670 PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s) 4671 __attribute__nonnull__(pTHX_2); 4672 #define PERL_ARGS_ASSERT_TAINT_PROPER \ 4673 assert(s) 4674 4675 PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...) 4676 __attribute__nonnull__(pTHX_1) 4677 __attribute__nonnull__(pTHX_2) 4678 __attribute__nonnull__(pTHX_3) 4679 __attribute__nonnull__(pTHX_4); 4680 #define PERL_ARGS_ASSERT_TIED_METHOD \ 4681 assert(methname); assert(sp); assert(sv); assert(mg) 4682 4683 PERL_CALLCONV void Perl_tmps_grow(pTHX_ SSize_t n); 4684 /* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) 4685 __attribute__nonnull__(pTHX_2) 4686 __attribute__nonnull__(pTHX_3); */ 4687 4688 PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) 4689 __attribute__nonnull__(pTHX_2) 4690 __attribute__nonnull__(pTHX_3); 4691 #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ 4692 assert(p); assert(lenp) 4693 4694 PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) 4695 __attribute__deprecated__ 4696 __attribute__warn_unused_result__ 4697 __attribute__pure__; 4698 4699 PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) 4700 __attribute__nonnull__(pTHX_2) 4701 __attribute__nonnull__(pTHX_3); 4702 #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ 4703 assert(p); assert(lenp) 4704 4705 PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) 4706 __attribute__deprecated__ 4707 __attribute__warn_unused_result__ 4708 __attribute__pure__; 4709 4710 PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) 4711 __attribute__nonnull__(pTHX_2) 4712 __attribute__nonnull__(pTHX_3); 4713 #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ 4714 assert(p); assert(lenp) 4715 4716 PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) 4717 __attribute__deprecated__ 4718 __attribute__warn_unused_result__ 4719 __attribute__pure__; 4720 4721 PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special) 4722 __attribute__nonnull__(pTHX_1) 4723 __attribute__nonnull__(pTHX_2) 4724 __attribute__nonnull__(pTHX_4) 4725 __attribute__nonnull__(pTHX_5); 4726 #define PERL_ARGS_ASSERT_TO_UTF8_CASE \ 4727 assert(p); assert(ustrp); assert(swashp); assert(normal) 4728 4729 /* PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4730 __attribute__nonnull__(pTHX_1) 4731 __attribute__nonnull__(pTHX_2); */ 4732 #define PERL_ARGS_ASSERT_TO_UTF8_FOLD \ 4733 assert(p); assert(ustrp) 4734 4735 /* PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4736 __attribute__nonnull__(pTHX_1) 4737 __attribute__nonnull__(pTHX_2); */ 4738 #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \ 4739 assert(p); assert(ustrp) 4740 4741 /* PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4742 __attribute__nonnull__(pTHX_1) 4743 __attribute__nonnull__(pTHX_2); */ 4744 #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \ 4745 assert(p); assert(ustrp) 4746 4747 /* PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 4748 __attribute__nonnull__(pTHX_1) 4749 __attribute__nonnull__(pTHX_2); */ 4750 #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \ 4751 assert(p); assert(ustrp) 4752 4753 PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); 4754 PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); 4755 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) 4756 __attribute__nonnull__(pTHX_1) 4757 __attribute__nonnull__(pTHX_2) 4758 __attribute__nonnull__(pTHX_3) 4759 __attribute__nonnull__(pTHX_5); 4760 #define PERL_ARGS_ASSERT_UNPACK_STR \ 4761 assert(pat); assert(patend); assert(s); assert(strend) 4762 4763 PERL_CALLCONV I32 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) 4764 __attribute__nonnull__(pTHX_1) 4765 __attribute__nonnull__(pTHX_2) 4766 __attribute__nonnull__(pTHX_3) 4767 __attribute__nonnull__(pTHX_4); 4768 #define PERL_ARGS_ASSERT_UNPACKSTRING \ 4769 assert(pat); assert(patend); assert(s); assert(strend) 4770 4771 PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); 4772 PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); 4773 PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv) 4774 __attribute__nonnull__(pTHX_1); 4775 #define PERL_ARGS_ASSERT_UPG_VERSION \ 4776 assert(ver) 4777 4778 PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 4779 __attribute__nonnull__(pTHX_1) 4780 __attribute__nonnull__(pTHX_2) 4781 __attribute__nonnull__(pTHX_4); 4782 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ 4783 assert(p); assert(d); assert(newlen) 4784 4785 PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 4786 __attribute__nonnull__(pTHX_1) 4787 __attribute__nonnull__(pTHX_2) 4788 __attribute__nonnull__(pTHX_4); 4789 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ 4790 assert(p); assert(d); assert(newlen) 4791 4792 PERL_CALLCONV IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) 4793 __attribute__warn_unused_result__ 4794 __attribute__pure__ 4795 __attribute__nonnull__(pTHX_1) 4796 __attribute__nonnull__(pTHX_2); 4797 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ 4798 assert(a); assert(b) 4799 4800 PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off) 4801 __attribute__warn_unused_result__ 4802 __attribute__pure__ 4803 __attribute__nonnull__(pTHX_1); 4804 #define PERL_ARGS_ASSERT_UTF8_HOP \ 4805 assert(s) 4806 4807 PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) 4808 __attribute__warn_unused_result__ 4809 __attribute__pure__ 4810 __attribute__nonnull__(pTHX_1) 4811 __attribute__nonnull__(pTHX_2); 4812 #define PERL_ARGS_ASSERT_UTF8_LENGTH \ 4813 assert(s); assert(e) 4814 4815 PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *len) 4816 __attribute__nonnull__(pTHX_1) 4817 __attribute__nonnull__(pTHX_2); 4818 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ 4819 assert(s); assert(len) 4820 4821 PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 4822 __attribute__deprecated__ 4823 __attribute__nonnull__(pTHX_1); 4824 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ 4825 assert(s) 4826 4827 /* PERL_CALLCONV UV utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) 4828 __attribute__nonnull__(pTHX_1) 4829 __attribute__nonnull__(pTHX_2); */ 4830 4831 PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4832 __attribute__deprecated__ 4833 __attribute__nonnull__(pTHX_1); 4834 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ 4835 assert(s) 4836 4837 PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) 4838 __attribute__deprecated__ 4839 __attribute__nonnull__(pTHX_1) 4840 __attribute__nonnull__(pTHX_2); 4841 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \ 4842 assert(s); assert(send) 4843 4844 PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 4845 __attribute__nonnull__(pTHX_1); 4846 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 4847 assert(s) 4848 4849 PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 4850 __attribute__nonnull__(pTHX_1); 4851 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ 4852 assert(s) 4853 4854 /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv) 4855 __attribute__nonnull__(pTHX_1); */ 4856 4857 /* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4858 __attribute__nonnull__(pTHX_1); */ 4859 4860 PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4861 __attribute__nonnull__(pTHX_1); 4862 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ 4863 assert(d) 4864 4865 PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) 4866 __attribute__nonnull__(pTHX_1); 4867 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ 4868 assert(d) 4869 4870 PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 4871 __attribute__nonnull__(pTHX_1); 4872 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ 4873 assert(d) 4874 4875 PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 4876 __attribute__nonnull__(pTHX_1); 4877 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ 4878 assert(s) 4879 4880 PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 4881 __attribute__deprecated__ 4882 __attribute__nonnull__(pTHX_1); 4883 #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ 4884 assert(s) 4885 4886 PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn) 4887 __attribute__nonnull__(pTHX_1); 4888 #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ 4889 assert(name) 4890 4891 PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) 4892 __attribute__nonnull__(pTHX_1) 4893 __attribute__nonnull__(pTHX_2); 4894 #define PERL_ARGS_ASSERT_VCMP \ 4895 assert(lhv); assert(rhv) 4896 4897 PERL_CALLCONV_NO_RET void Perl_vcroak(pTHX_ const char* pat, va_list* args) 4898 __attribute__noreturn__; 4899 4900 PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args) 4901 __attribute__nonnull__(pTHX_1); 4902 #define PERL_ARGS_ASSERT_VDEB \ 4903 assert(pat) 4904 4905 PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args) 4906 __attribute__nonnull__(pTHX_1); 4907 #define PERL_ARGS_ASSERT_VFORM \ 4908 assert(pat) 4909 4910 PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv) 4911 __attribute__nonnull__(pTHX_1); 4912 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ 4913 assert(sv) 4914 4915 PERL_CALLCONV SV* Perl_vivify_ref(pTHX_ SV* sv, U32 to_what) 4916 __attribute__warn_unused_result__ 4917 __attribute__nonnull__(pTHX_1); 4918 #define PERL_ARGS_ASSERT_VIVIFY_REF \ 4919 assert(sv) 4920 4921 PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args) 4922 __attribute__nonnull__(pTHX_2); 4923 #define PERL_ARGS_ASSERT_VLOAD_MODULE \ 4924 assert(name) 4925 4926 PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args) 4927 __attribute__nonnull__(pTHX_1); 4928 #define PERL_ARGS_ASSERT_VMESS \ 4929 assert(pat) 4930 4931 PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args) 4932 __attribute__malloc__ 4933 __attribute__warn_unused_result__ 4934 __attribute__nonnull__(pTHX_1); 4935 #define PERL_ARGS_ASSERT_VNEWSVPVF \ 4936 assert(pat) 4937 4938 PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs) 4939 __attribute__nonnull__(pTHX_1); 4940 #define PERL_ARGS_ASSERT_VNORMAL \ 4941 assert(vs) 4942 4943 PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs) 4944 __attribute__nonnull__(pTHX_1); 4945 #define PERL_ARGS_ASSERT_VNUMIFY \ 4946 assert(vs) 4947 4948 PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs) 4949 __attribute__nonnull__(pTHX_1); 4950 #define PERL_ARGS_ASSERT_VSTRINGIFY \ 4951 assert(vs) 4952 4953 PERL_CALLCONV SV* Perl_vverify(pTHX_ SV *vs) 4954 __attribute__nonnull__(pTHX_1); 4955 #define PERL_ARGS_ASSERT_VVERIFY \ 4956 assert(vs) 4957 4958 PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args) 4959 __attribute__nonnull__(pTHX_1); 4960 #define PERL_ARGS_ASSERT_VWARN \ 4961 assert(pat) 4962 4963 PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args) 4964 __attribute__nonnull__(pTHX_2); 4965 #define PERL_ARGS_ASSERT_VWARNER \ 4966 assert(pat) 4967 4968 PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags) 4969 __attribute__nonnull__(pTHX_2); 4970 #define PERL_ARGS_ASSERT_WAIT4PID \ 4971 assert(statusp) 4972 4973 PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...) 4974 __attribute__format__(__printf__,pTHX_1,pTHX_2) 4975 __attribute__nonnull__(pTHX_1); 4976 #define PERL_ARGS_ASSERT_WARN \ 4977 assert(pat) 4978 4979 PERL_CALLCONV void Perl_warn_sv(pTHX_ SV *baseex) 4980 __attribute__nonnull__(pTHX_1); 4981 #define PERL_ARGS_ASSERT_WARN_SV \ 4982 assert(baseex) 4983 4984 PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) 4985 __attribute__format__(__printf__,pTHX_2,pTHX_3) 4986 __attribute__nonnull__(pTHX_2); 4987 #define PERL_ARGS_ASSERT_WARNER \ 4988 assert(pat) 4989 4990 PERL_CALLCONV I32 Perl_was_lvalue_sub(pTHX) 4991 __attribute__warn_unused_result__; 4992 4993 PERL_CALLCONV void Perl_watch(pTHX_ char** addr) 4994 __attribute__nonnull__(pTHX_1); 4995 #define PERL_ARGS_ASSERT_WATCH \ 4996 assert(addr) 4997 4998 /* PERL_CALLCONV I32 whichsig(pTHX_ const char* sig) 4999 __attribute__nonnull__(pTHX_1); */ 5000 5001 PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char* sig) 5002 __attribute__nonnull__(pTHX_1); 5003 #define PERL_ARGS_ASSERT_WHICHSIG_PV \ 5004 assert(sig) 5005 5006 PERL_CALLCONV I32 Perl_whichsig_pvn(pTHX_ const char* sig, STRLEN len) 5007 __attribute__nonnull__(pTHX_1); 5008 #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ 5009 assert(sig) 5010 5011 PERL_CALLCONV I32 Perl_whichsig_sv(pTHX_ SV* sigsv) 5012 __attribute__nonnull__(pTHX_1); 5013 #define PERL_ARGS_ASSERT_WHICHSIG_SV \ 5014 assert(sigsv) 5015 5016 PERL_CALLCONV void Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p) 5017 __attribute__nonnull__(pTHX_2) 5018 __attribute__nonnull__(pTHX_3); 5019 #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ 5020 assert(new_checker); assert(old_checker_p) 5021 5022 PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv) 5023 __attribute__nonnull__(pTHX_1); 5024 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ 5025 assert(msv) 5026 5027 PERL_CALLCONV void Perl_xs_apiversion_bootcheck(pTHX_ SV *module, const char *api_p, STRLEN api_len) 5028 __attribute__nonnull__(pTHX_1) 5029 __attribute__nonnull__(pTHX_2); 5030 #define PERL_ARGS_ASSERT_XS_APIVERSION_BOOTCHECK \ 5031 assert(module); assert(api_p) 5032 5033 PERL_CALLCONV void Perl_xs_version_bootcheck(pTHX_ U32 items, U32 ax, const char *xs_p, STRLEN xs_len) 5034 __attribute__nonnull__(pTHX_3); 5035 #define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ 5036 assert(xs_p) 5037 5038 PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s) 5039 __attribute__nonnull__(pTHX_1); 5040 #define PERL_ARGS_ASSERT_YYERROR \ 5041 assert(s) 5042 5043 PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags) 5044 __attribute__nonnull__(pTHX_1); 5045 #define PERL_ARGS_ASSERT_YYERROR_PV \ 5046 assert(s) 5047 5048 PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags) 5049 __attribute__nonnull__(pTHX_1); 5050 #define PERL_ARGS_ASSERT_YYERROR_PVN \ 5051 assert(s) 5052 5053 PERL_CALLCONV int Perl_yylex(pTHX); 5054 PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); 5055 PERL_CALLCONV void Perl_yyunlex(pTHX); 5056 #if !(defined(DEBUGGING)) 5057 # if !defined(NV_PRESERVES_UV) 5058 # if defined(PERL_IN_SV_C) 5059 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv) 5060 __attribute__nonnull__(pTHX_1); 5061 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5062 assert(sv) 5063 5064 # endif 5065 # endif 5066 #endif 5067 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO)) 5068 PERL_CALLCONV Signal_t Perl_csighandler(int sig); 5069 PERL_CALLCONV Signal_t Perl_sighandler(int sig); 5070 #endif 5071 #if !(defined(NO_MATHOMS)) 5072 PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); 5073 #endif 5074 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION)) 5075 PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 5076 __attribute__nonnull__(pTHX_1); 5077 #define PERL_ARGS_ASSERT_DO_EXEC \ 5078 assert(cmd) 5079 5080 #endif 5081 #if !(defined(PERL_GLOBAL_STRUCT_PRIVATE)) 5082 # if defined(PERL_IMPLICIT_CONTEXT) 5083 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) 5084 __attribute__nonnull__(pTHX_1); 5085 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 5086 assert(index) 5087 5088 # endif 5089 #endif 5090 #if !(defined(PERL_MAD)) 5091 PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 5092 PERL_CALLCONV void Perl_package(pTHX_ OP* o) 5093 __attribute__nonnull__(pTHX_1); 5094 #define PERL_ARGS_ASSERT_PACKAGE \ 5095 assert(o) 5096 5097 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 5098 __attribute__nonnull__(pTHX_4); 5099 #define PERL_ARGS_ASSERT_UTILIZE \ 5100 assert(idop) 5101 5102 #endif 5103 #if !(defined(WIN32)) 5104 /* PERL_CALLCONV char* my_setlocale(pTHX_ int category, const char* locale) 5105 __attribute__pure__; */ 5106 5107 #endif 5108 #if !(defined(_MSC_VER)) 5109 PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 5110 __attribute__noreturn__ 5111 __attribute__nonnull__(pTHX_1) 5112 __attribute__nonnull__(pTHX_2); 5113 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 5114 assert(sv); assert(mg) 5115 5116 #endif 5117 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) 5118 PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) 5119 __attribute__nonnull__(1); 5120 #define PERL_ARGS_ASSERT_MY_BZERO \ 5121 assert(loc) 5122 5123 #endif 5124 #if !defined(HAS_GETENV_LEN) 5125 PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) 5126 __attribute__nonnull__(pTHX_1) 5127 __attribute__nonnull__(pTHX_2); 5128 #define PERL_ARGS_ASSERT_GETENV_LEN \ 5129 assert(env_elem); assert(len) 5130 5131 #endif 5132 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) 5133 PERL_CALLCONV I32 Perl_my_memcmp(const char* s1, const char* s2, I32 len) 5134 __attribute__pure__ 5135 __attribute__nonnull__(1) 5136 __attribute__nonnull__(2); 5137 #define PERL_ARGS_ASSERT_MY_MEMCMP \ 5138 assert(s1); assert(s2) 5139 5140 #endif 5141 #if !defined(HAS_MEMSET) 5142 PERL_CALLCONV void* Perl_my_memset(char* loc, I32 ch, I32 len) 5143 __attribute__nonnull__(1); 5144 #define PERL_ARGS_ASSERT_MY_MEMSET \ 5145 assert(loc) 5146 5147 #endif 5148 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) 5149 # if defined(PERL_IN_PP_SYS_C) 5150 STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) 5151 __attribute__warn_unused_result__ 5152 __attribute__nonnull__(pTHX_1) 5153 __attribute__nonnull__(pTHX_2); 5154 #define PERL_ARGS_ASSERT_DOONELINER \ 5155 assert(cmd); assert(filename) 5156 5157 # endif 5158 #endif 5159 #if !defined(HAS_RENAME) 5160 PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b) 5161 __attribute__nonnull__(pTHX_1) 5162 __attribute__nonnull__(pTHX_2); 5163 #define PERL_ARGS_ASSERT_SAME_DIRENT \ 5164 assert(a); assert(b) 5165 5166 #endif 5167 #if !defined(HAS_SIGNBIT) 5168 PERL_CALLCONV int Perl_signbit(NV f) 5169 __attribute__pure__; 5170 5171 #endif 5172 #if !defined(HAS_STRLCAT) 5173 PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); 5174 #endif 5175 #if !defined(HAS_STRLCPY) 5176 PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); 5177 #endif 5178 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) 5179 PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) 5180 __attribute__warn_unused_result__; 5181 5182 #endif 5183 #if !defined(NV_PRESERVES_UV) 5184 # if defined(DEBUGGING) 5185 # if defined(PERL_IN_SV_C) 5186 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype) 5187 __attribute__nonnull__(pTHX_1); 5188 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5189 assert(sv) 5190 5191 # endif 5192 # endif 5193 #endif 5194 #if !defined(PERL_DISABLE_PMC) 5195 # if defined(PERL_IN_PP_CTL_C) 5196 STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) 5197 __attribute__warn_unused_result__ 5198 __attribute__nonnull__(pTHX_1); 5199 #define PERL_ARGS_ASSERT_DOOPEN_PM \ 5200 assert(name) 5201 5202 # endif 5203 #endif 5204 #if !defined(PERL_IMPLICIT_SYS) 5205 PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); 5206 PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode) 5207 __attribute__nonnull__(pTHX_1) 5208 __attribute__nonnull__(pTHX_2); 5209 #define PERL_ARGS_ASSERT_MY_POPEN \ 5210 assert(cmd); assert(mode) 5211 5212 #endif 5213 #if !defined(PERL_IS_MINIPERL) 5214 # if defined(PERL_IN_PERL_C) 5215 STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem) 5216 __attribute__nonnull__(pTHX_1) 5217 __attribute__nonnull__(pTHX_2) 5218 __attribute__nonnull__(pTHX_3); 5219 #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ 5220 assert(av); assert(dir); assert(stem) 5221 5222 # endif 5223 #endif 5224 #if !defined(PERL_NO_UTF16_FILTER) 5225 # if defined(PERL_IN_TOKE_C) 5226 STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed) 5227 __attribute__nonnull__(pTHX_1); 5228 #define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ 5229 assert(s) 5230 5231 STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) 5232 __attribute__nonnull__(pTHX_2); 5233 #define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ 5234 assert(sv) 5235 5236 # endif 5237 #endif 5238 #if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) 5239 # if defined(PERL_IN_PERL_C) 5240 STATIC void S_validate_suid(pTHX_ PerlIO *rsfp) 5241 __attribute__nonnull__(pTHX_1); 5242 #define PERL_ARGS_ASSERT_VALIDATE_SUID \ 5243 assert(rsfp) 5244 5245 # endif 5246 #endif 5247 #if !defined(SPRINTF_RETURNS_STRLEN) 5248 PERL_CALLCONV int Perl_my_sprintf(char *buffer, const char *pat, ...) 5249 __attribute__nonnull__(1) 5250 __attribute__nonnull__(2); 5251 #define PERL_ARGS_ASSERT_MY_SPRINTF \ 5252 assert(buffer); assert(pat) 5253 5254 #endif 5255 #if !defined(WIN32) 5256 PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) 5257 __attribute__nonnull__(pTHX_1); 5258 #define PERL_ARGS_ASSERT_DO_EXEC3 \ 5259 assert(incmd) 5260 5261 #endif 5262 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY)) 5263 PERL_CALLCONV char* Perl_my_bcopy(const char* from, char* to, I32 len) 5264 __attribute__nonnull__(1) 5265 __attribute__nonnull__(2); 5266 #define PERL_ARGS_ASSERT_MY_BCOPY \ 5267 assert(from); assert(to) 5268 5269 #endif 5270 #if defined(DEBUGGING) 5271 PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) 5272 __attribute__warn_unused_result__ 5273 __attribute__nonnull__(pTHX_1); 5274 #define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ 5275 assert(s) 5276 5277 PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv) 5278 __attribute__nonnull__(pTHX_1); 5279 #define PERL_ARGS_ASSERT_HV_ASSERT \ 5280 assert(hv) 5281 5282 PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv) 5283 __attribute__nonnull__(pTHX_2); 5284 #define PERL_ARGS_ASSERT_PAD_SETSV \ 5285 assert(sv) 5286 5287 PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); 5288 # if defined(PERL_IN_PAD_C) 5289 STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) 5290 __attribute__nonnull__(pTHX_1) 5291 __attribute__nonnull__(pTHX_2); 5292 #define PERL_ARGS_ASSERT_CV_DUMP \ 5293 assert(cv); assert(title) 5294 5295 # endif 5296 # if defined(PERL_IN_REGCOMP_C) 5297 STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth) 5298 __attribute__nonnull__(pTHX_1) 5299 __attribute__nonnull__(pTHX_3); 5300 #define PERL_ARGS_ASSERT_DUMP_TRIE \ 5301 assert(trie); assert(revcharmap) 5302 5303 STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5304 __attribute__nonnull__(pTHX_1) 5305 __attribute__nonnull__(pTHX_3); 5306 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ 5307 assert(trie); assert(revcharmap) 5308 5309 STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5310 __attribute__nonnull__(pTHX_1) 5311 __attribute__nonnull__(pTHX_3); 5312 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ 5313 assert(trie); assert(revcharmap) 5314 5315 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) 5316 __attribute__nonnull__(pTHX_1) 5317 __attribute__nonnull__(pTHX_2) 5318 __attribute__nonnull__(pTHX_3) 5319 __attribute__nonnull__(pTHX_6); 5320 #define PERL_ARGS_ASSERT_DUMPUNTIL \ 5321 assert(r); assert(start); assert(node); assert(sv) 5322 5323 STATIC void S_put_byte(pTHX_ SV* sv, int c) 5324 __attribute__nonnull__(pTHX_1); 5325 #define PERL_ARGS_ASSERT_PUT_BYTE \ 5326 assert(sv) 5327 5328 STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap) 5329 __attribute__nonnull__(pTHX_1) 5330 __attribute__nonnull__(pTHX_2); 5331 #define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \ 5332 assert(sv); assert(bitmap) 5333 5334 STATIC void S_put_range(pTHX_ SV* sv, UV start, UV end) 5335 __attribute__nonnull__(pTHX_1); 5336 #define PERL_ARGS_ASSERT_PUT_RANGE \ 5337 assert(sv) 5338 5339 STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); 5340 STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags); 5341 STATIC U8 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 5342 __attribute__nonnull__(pTHX_1) 5343 __attribute__nonnull__(pTHX_2) 5344 __attribute__nonnull__(pTHX_3); 5345 #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ 5346 assert(pRExC_state); assert(p); assert(val) 5347 5348 # endif 5349 # if defined(PERL_IN_REGEXEC_C) 5350 STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) 5351 __attribute__nonnull__(pTHX_1) 5352 __attribute__nonnull__(pTHX_3) 5353 __attribute__nonnull__(pTHX_4) 5354 __attribute__nonnull__(pTHX_5); 5355 #define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ 5356 assert(prog); assert(start); assert(end); assert(blurb) 5357 5358 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) 5359 __attribute__nonnull__(pTHX_1) 5360 __attribute__nonnull__(pTHX_2) 5361 __attribute__nonnull__(pTHX_3) 5362 __attribute__nonnull__(pTHX_4) 5363 __attribute__nonnull__(pTHX_5); 5364 #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ 5365 assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry) 5366 5367 # endif 5368 # if defined(PERL_IN_SV_C) 5369 STATIC void S_del_sv(pTHX_ SV *p) 5370 __attribute__nonnull__(pTHX_1); 5371 #define PERL_ARGS_ASSERT_DEL_SV \ 5372 assert(p) 5373 5374 # endif 5375 # if defined(PERL_IN_TOKE_C) 5376 STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s) 5377 __attribute__format__(__printf__,pTHX_1,0) 5378 __attribute__nonnull__(pTHX_1) 5379 __attribute__nonnull__(pTHX_2); 5380 #define PERL_ARGS_ASSERT_PRINTBUF \ 5381 assert(fmt); assert(s) 5382 5383 STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp) 5384 __attribute__nonnull__(pTHX_2); 5385 #define PERL_ARGS_ASSERT_TOKEREPORT \ 5386 assert(lvalp) 5387 5388 # endif 5389 #endif 5390 #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) 5391 PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) 5392 __attribute__nonnull__(pTHX_1); 5393 #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ 5394 assert(sv) 5395 5396 #endif 5397 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) 5398 PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp) 5399 __attribute__nonnull__(pTHX_2) 5400 __attribute__nonnull__(pTHX_3); 5401 #define PERL_ARGS_ASSERT_DO_IPCCTL \ 5402 assert(mark); assert(sp) 5403 5404 PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV** mark, SV** sp) 5405 __attribute__nonnull__(pTHX_2) 5406 __attribute__nonnull__(pTHX_3); 5407 #define PERL_ARGS_ASSERT_DO_IPCGET \ 5408 assert(mark); assert(sp) 5409 5410 PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV** mark, SV** sp) 5411 __attribute__nonnull__(pTHX_1) 5412 __attribute__nonnull__(pTHX_2); 5413 #define PERL_ARGS_ASSERT_DO_MSGRCV \ 5414 assert(mark); assert(sp) 5415 5416 PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV** mark, SV** sp) 5417 __attribute__nonnull__(pTHX_1) 5418 __attribute__nonnull__(pTHX_2); 5419 #define PERL_ARGS_ASSERT_DO_MSGSND \ 5420 assert(mark); assert(sp) 5421 5422 PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV** mark, SV** sp) 5423 __attribute__nonnull__(pTHX_1) 5424 __attribute__nonnull__(pTHX_2); 5425 #define PERL_ARGS_ASSERT_DO_SEMOP \ 5426 assert(mark); assert(sp) 5427 5428 PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp) 5429 __attribute__nonnull__(pTHX_2) 5430 __attribute__nonnull__(pTHX_3); 5431 #define PERL_ARGS_ASSERT_DO_SHMIO \ 5432 assert(mark); assert(sp) 5433 5434 #endif 5435 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) 5436 PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap); 5437 PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap); 5438 #endif 5439 #if defined(HAVE_INTERP_INTERN) 5440 PERL_CALLCONV void Perl_sys_intern_clear(pTHX); 5441 PERL_CALLCONV void Perl_sys_intern_init(pTHX); 5442 # if defined(USE_ITHREADS) 5443 PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst) 5444 __attribute__nonnull__(pTHX_1) 5445 __attribute__nonnull__(pTHX_2); 5446 #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ 5447 assert(src); assert(dst) 5448 5449 # endif 5450 #endif 5451 #if defined(MYMALLOC) 5452 PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s) 5453 __attribute__nonnull__(pTHX_1); 5454 #define PERL_ARGS_ASSERT_DUMP_MSTATS \ 5455 assert(s) 5456 5457 PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) 5458 __attribute__nonnull__(pTHX_1); 5459 #define PERL_ARGS_ASSERT_GET_MSTATS \ 5460 assert(buf) 5461 5462 PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) 5463 __attribute__warn_unused_result__; 5464 5465 PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) 5466 __attribute__warn_unused_result__ 5467 __attribute__nonnull__(1); 5468 #define PERL_ARGS_ASSERT_MALLOCED_SIZE \ 5469 assert(p) 5470 5471 #endif 5472 #if defined(NO_MATHOMS) 5473 /* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */ 5474 #endif 5475 #if defined(PERL_ANY_COW) 5476 PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) 5477 __attribute__nonnull__(pTHX_2); 5478 #define PERL_ARGS_ASSERT_SV_SETSV_COW \ 5479 assert(sstr) 5480 5481 #endif 5482 #if defined(PERL_CORE) 5483 PERL_CALLCONV void Perl_opslab_force_free(pTHX_ OPSLAB *slab) 5484 __attribute__nonnull__(pTHX_1); 5485 #define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ 5486 assert(slab) 5487 5488 PERL_CALLCONV void Perl_opslab_free(pTHX_ OPSLAB *slab) 5489 __attribute__nonnull__(pTHX_1); 5490 #define PERL_ARGS_ASSERT_OPSLAB_FREE \ 5491 assert(slab) 5492 5493 PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) 5494 __attribute__nonnull__(pTHX_1); 5495 #define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ 5496 assert(slab) 5497 5498 PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) 5499 __attribute__nonnull__(pTHX_1) 5500 __attribute__nonnull__(pTHX_2); 5501 #define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ 5502 assert(parser); assert(slab) 5503 5504 # if defined(PERL_DEBUG_READONLY_OPS) 5505 PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab) 5506 __attribute__nonnull__(pTHX_1); 5507 #define PERL_ARGS_ASSERT_SLAB_TO_RO \ 5508 assert(slab) 5509 5510 PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab) 5511 __attribute__nonnull__(pTHX_1); 5512 #define PERL_ARGS_ASSERT_SLAB_TO_RW \ 5513 assert(slab) 5514 5515 # endif 5516 #endif 5517 #if defined(PERL_CORE) || defined (PERL_EXT) 5518 PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) 5519 __attribute__nonnull__(pTHX_1) 5520 __attribute__nonnull__(pTHX_2); 5521 #define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ 5522 assert(sv); assert(pv) 5523 5524 #endif 5525 #if defined(PERL_CR_FILTER) 5526 # if defined(PERL_IN_TOKE_C) 5527 STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); 5528 STATIC void S_strip_return(pTHX_ SV *sv) 5529 __attribute__nonnull__(pTHX_1); 5530 #define PERL_ARGS_ASSERT_STRIP_RETURN \ 5531 assert(sv) 5532 5533 # endif 5534 #endif 5535 #if defined(PERL_DEBUG_READONLY_COW) 5536 PERL_CALLCONV void Perl_sv_buf_to_ro(pTHX_ SV *sv) 5537 __attribute__nonnull__(pTHX_1); 5538 #define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ 5539 assert(sv) 5540 5541 # if defined(PERL_IN_SV_C) 5542 STATIC void S_sv_buf_to_rw(pTHX_ SV *sv) 5543 __attribute__nonnull__(pTHX_1); 5544 #define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ 5545 assert(sv) 5546 5547 # endif 5548 #endif 5549 #if defined(PERL_DEBUG_READONLY_OPS) 5550 PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) 5551 __attribute__nonnull__(pTHX_1); 5552 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ 5553 assert(o) 5554 5555 PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); 5556 #endif 5557 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) 5558 /* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 5559 __attribute__nonnull__(pTHX_1); */ 5560 5561 #endif 5562 #if defined(PERL_DONT_CREATE_GVSV) 5563 /* PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); */ 5564 #endif 5565 #if defined(PERL_GLOBAL_STRUCT) 5566 PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX); 5567 PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp) 5568 __attribute__nonnull__(pTHX_1); 5569 #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \ 5570 assert(plvarsp) 5571 5572 PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX); 5573 #endif 5574 #if defined(PERL_GLOBAL_STRUCT_PRIVATE) 5575 # if defined(PERL_IMPLICIT_CONTEXT) 5576 PERL_CALLCONV int Perl_my_cxt_index(pTHX_ const char *my_cxt_key) 5577 __attribute__nonnull__(pTHX_1); 5578 #define PERL_ARGS_ASSERT_MY_CXT_INDEX \ 5579 assert(my_cxt_key) 5580 5581 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size) 5582 __attribute__nonnull__(pTHX_1); 5583 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 5584 assert(my_cxt_key) 5585 5586 # endif 5587 #endif 5588 #if defined(PERL_IMPLICIT_CONTEXT) 5589 PERL_CALLCONV_NO_RET void Perl_croak_nocontext(const char* pat, ...) 5590 __attribute__noreturn__ 5591 __attribute__format__null_ok__(__printf__,1,2); 5592 5593 PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) 5594 __attribute__format__(__printf__,1,2) 5595 __attribute__nonnull__(1); 5596 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ 5597 assert(pat) 5598 5599 PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) 5600 __attribute__format__null_ok__(__printf__,1,2); 5601 5602 PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) 5603 __attribute__format__(__printf__,1,2) 5604 __attribute__nonnull__(1); 5605 #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ 5606 assert(pat) 5607 5608 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) 5609 __attribute__format__(__printf__,2,3) 5610 __attribute__nonnull__(1) 5611 __attribute__nonnull__(2); 5612 #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ 5613 assert(stream); assert(format) 5614 5615 PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...) 5616 __attribute__nonnull__(2); 5617 #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ 5618 assert(name) 5619 5620 PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...) 5621 __attribute__format__(__printf__,1,2) 5622 __attribute__nonnull__(1); 5623 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ 5624 assert(pat) 5625 5626 PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) 5627 __attribute__format__(__printf__,1,2) 5628 __attribute__nonnull__(1); 5629 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ 5630 assert(pat) 5631 5632 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) 5633 __attribute__format__(__printf__,1,2) 5634 __attribute__nonnull__(1); 5635 #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ 5636 assert(format) 5637 5638 PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 5639 __attribute__format__(__printf__,2,3) 5640 __attribute__nonnull__(1) 5641 __attribute__nonnull__(2); 5642 #define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ 5643 assert(sv); assert(pat) 5644 5645 PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...) 5646 __attribute__format__(__printf__,2,3) 5647 __attribute__nonnull__(1) 5648 __attribute__nonnull__(2); 5649 #define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ 5650 assert(sv); assert(pat) 5651 5652 PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 5653 __attribute__format__(__printf__,2,3) 5654 __attribute__nonnull__(1) 5655 __attribute__nonnull__(2); 5656 #define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ 5657 assert(sv); assert(pat) 5658 5659 PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...) 5660 __attribute__format__(__printf__,2,3) 5661 __attribute__nonnull__(1) 5662 __attribute__nonnull__(2); 5663 #define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ 5664 assert(sv); assert(pat) 5665 5666 PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...) 5667 __attribute__format__(__printf__,1,2) 5668 __attribute__nonnull__(1); 5669 #define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ 5670 assert(pat) 5671 5672 PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) 5673 __attribute__format__(__printf__,2,3) 5674 __attribute__nonnull__(2); 5675 #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ 5676 assert(pat) 5677 5678 #endif 5679 #if defined(PERL_IMPLICIT_SYS) 5680 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) 5681 __attribute__nonnull__(1) 5682 __attribute__nonnull__(2) 5683 __attribute__nonnull__(3) 5684 __attribute__nonnull__(4) 5685 __attribute__nonnull__(5) 5686 __attribute__nonnull__(6) 5687 __attribute__nonnull__(7) 5688 __attribute__nonnull__(8) 5689 __attribute__nonnull__(9); 5690 #define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ 5691 assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5692 5693 # if defined(USE_ITHREADS) 5694 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) 5695 __attribute__nonnull__(1) 5696 __attribute__nonnull__(3) 5697 __attribute__nonnull__(4) 5698 __attribute__nonnull__(5) 5699 __attribute__nonnull__(6) 5700 __attribute__nonnull__(7) 5701 __attribute__nonnull__(8) 5702 __attribute__nonnull__(9) 5703 __attribute__nonnull__(10) 5704 __attribute__nonnull__(11); 5705 #define PERL_ARGS_ASSERT_PERL_CLONE_USING \ 5706 assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 5707 5708 # endif 5709 #endif 5710 #if defined(PERL_IN_AV_C) 5711 STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av) 5712 __attribute__nonnull__(pTHX_1); 5713 #define PERL_ARGS_ASSERT_GET_AUX_MG \ 5714 assert(av) 5715 5716 #endif 5717 #if defined(PERL_IN_DEB_C) 5718 STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max) 5719 __attribute__nonnull__(pTHX_1); 5720 #define PERL_ARGS_ASSERT_DEB_STACK_N \ 5721 assert(stack_base) 5722 5723 #endif 5724 #if defined(PERL_IN_DOIO_C) 5725 STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) 5726 __attribute__nonnull__(pTHX_1); 5727 #define PERL_ARGS_ASSERT_EXEC_FAILED \ 5728 assert(cmd) 5729 5730 STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) 5731 __attribute__warn_unused_result__; 5732 5733 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) 5734 __attribute__nonnull__(pTHX_1) 5735 __attribute__nonnull__(pTHX_2) 5736 __attribute__nonnull__(pTHX_4) 5737 __attribute__nonnull__(pTHX_5); 5738 #define PERL_ARGS_ASSERT_OPENN_CLEANUP \ 5739 assert(gv); assert(io); assert(mode); assert(oname) 5740 5741 STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype) 5742 __attribute__nonnull__(pTHX_1) 5743 __attribute__nonnull__(pTHX_2) 5744 __attribute__nonnull__(pTHX_3) 5745 __attribute__nonnull__(pTHX_4) 5746 __attribute__nonnull__(pTHX_5) 5747 __attribute__nonnull__(pTHX_6); 5748 #define PERL_ARGS_ASSERT_OPENN_SETUP \ 5749 assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); assert(savetype) 5750 5751 #endif 5752 #if defined(PERL_IN_DOOP_C) 5753 STATIC I32 S_do_trans_complex(pTHX_ SV * const sv) 5754 __attribute__warn_unused_result__ 5755 __attribute__nonnull__(pTHX_1); 5756 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ 5757 assert(sv) 5758 5759 STATIC I32 S_do_trans_complex_utf8(pTHX_ SV * const sv) 5760 __attribute__warn_unused_result__ 5761 __attribute__nonnull__(pTHX_1); 5762 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \ 5763 assert(sv) 5764 5765 STATIC I32 S_do_trans_count(pTHX_ SV * const sv) 5766 __attribute__warn_unused_result__ 5767 __attribute__nonnull__(pTHX_1); 5768 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ 5769 assert(sv) 5770 5771 STATIC I32 S_do_trans_count_utf8(pTHX_ SV * const sv) 5772 __attribute__warn_unused_result__ 5773 __attribute__nonnull__(pTHX_1); 5774 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8 \ 5775 assert(sv) 5776 5777 STATIC I32 S_do_trans_simple(pTHX_ SV * const sv) 5778 __attribute__warn_unused_result__ 5779 __attribute__nonnull__(pTHX_1); 5780 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ 5781 assert(sv) 5782 5783 STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv) 5784 __attribute__warn_unused_result__ 5785 __attribute__nonnull__(pTHX_1); 5786 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8 \ 5787 assert(sv) 5788 5789 #endif 5790 #if defined(PERL_IN_DUMP_C) 5791 STATIC CV* S_deb_curcv(pTHX_ const I32 ix); 5792 STATIC void S_debprof(pTHX_ const OP *o) 5793 __attribute__nonnull__(pTHX_1); 5794 #define PERL_ARGS_ASSERT_DEBPROF \ 5795 assert(o) 5796 5797 STATIC SV* S_pm_description(pTHX_ const PMOP *pm) 5798 __attribute__nonnull__(pTHX_1); 5799 #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ 5800 assert(pm) 5801 5802 STATIC UV S_sequence_num(pTHX_ const OP *o); 5803 # if defined(PERL_MAD) 5804 STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 5805 __attribute__format__(__printf__,pTHX_3,pTHX_4) 5806 __attribute__nonnull__(pTHX_2) 5807 __attribute__nonnull__(pTHX_3); 5808 #define PERL_ARGS_ASSERT_XMLDUMP_ATTR \ 5809 assert(file); assert(pat) 5810 5811 # endif 5812 #endif 5813 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) 5814 PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) 5815 __attribute__nonnull__(pTHX_1); 5816 #define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ 5817 assert(hv) 5818 5819 #endif 5820 #if defined(PERL_IN_GV_C) 5821 STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, svtype sv_type) 5822 __attribute__nonnull__(pTHX_1) 5823 __attribute__nonnull__(pTHX_2); 5824 #define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ 5825 assert(stash); assert(name) 5826 5827 STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type) 5828 __attribute__nonnull__(pTHX_1); 5829 #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ 5830 assert(gv) 5831 5832 STATIC bool S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8) 5833 __attribute__nonnull__(pTHX_1); 5834 #define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ 5835 assert(name) 5836 5837 STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, bool addmg, svtype sv_type) 5838 __attribute__nonnull__(pTHX_1) 5839 __attribute__nonnull__(pTHX_2) 5840 __attribute__nonnull__(pTHX_3); 5841 #define PERL_ARGS_ASSERT_GV_MAGICALIZE \ 5842 assert(gv); assert(stash); assert(name) 5843 5844 STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) 5845 __attribute__nonnull__(pTHX_1); 5846 #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ 5847 assert(gv) 5848 5849 STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) 5850 __attribute__nonnull__(pTHX_1) 5851 __attribute__nonnull__(pTHX_2); 5852 #define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ 5853 assert(gv); assert(name) 5854 5855 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) 5856 __attribute__nonnull__(pTHX_1) 5857 __attribute__nonnull__(pTHX_2) 5858 __attribute__nonnull__(pTHX_3) 5859 __attribute__nonnull__(pTHX_4) 5860 __attribute__nonnull__(pTHX_5); 5861 #define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ 5862 assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) 5863 5864 STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags) 5865 __attribute__nonnull__(pTHX_1) 5866 __attribute__nonnull__(pTHX_2) 5867 __attribute__nonnull__(pTHX_3) 5868 __attribute__nonnull__(pTHX_4); 5869 #define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ 5870 assert(gv); assert(varpv); assert(namesv); assert(methpv) 5871 5872 #endif 5873 #if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C) 5874 PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv) 5875 __attribute__nonnull__(pTHX_1) 5876 __attribute__nonnull__(pTHX_2); 5877 #define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ 5878 assert(tsv); assert(sv) 5879 5880 #endif 5881 #if defined(PERL_IN_HV_C) 5882 STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items) 5883 __attribute__nonnull__(pTHX_1); 5884 #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ 5885 assert(hv) 5886 5887 STATIC void S_hfreeentries(pTHX_ HV *hv) 5888 __attribute__nonnull__(pTHX_1); 5889 #define PERL_ARGS_ASSERT_HFREEENTRIES \ 5890 assert(hv) 5891 5892 STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize) 5893 __attribute__nonnull__(pTHX_1); 5894 #define PERL_ARGS_ASSERT_HSPLIT \ 5895 assert(hv) 5896 5897 STATIC struct xpvhv_aux* S_hv_auxinit(pTHX_ HV *hv) 5898 __attribute__nonnull__(pTHX_1); 5899 #define PERL_ARGS_ASSERT_HV_AUXINIT \ 5900 assert(hv) 5901 5902 STATIC struct xpvhv_aux* S_hv_auxinit_internal(struct xpvhv_aux *iter) 5903 __attribute__nonnull__(1); 5904 #define PERL_ARGS_ASSERT_HV_AUXINIT_INTERNAL \ 5905 assert(iter) 5906 5907 STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); 5908 STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry) 5909 __attribute__nonnull__(pTHX_1) 5910 __attribute__nonnull__(pTHX_2); 5911 #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ 5912 assert(hv); assert(entry) 5913 5914 STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) 5915 __attribute__nonnull__(1) 5916 __attribute__nonnull__(2) 5917 __attribute__nonnull__(3); 5918 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ 5919 assert(hv); assert(needs_copy); assert(needs_store) 5920 5921 PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) 5922 __attribute__noreturn__ 5923 __attribute__nonnull__(pTHX_2) 5924 __attribute__nonnull__(pTHX_4); 5925 #define PERL_ARGS_ASSERT_HV_NOTALLOWED \ 5926 assert(key); assert(msg) 5927 5928 STATIC HE* S_new_he(pTHX) 5929 __attribute__malloc__ 5930 __attribute__warn_unused_result__; 5931 5932 PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); 5933 STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) 5934 __attribute__nonnull__(pTHX_1); 5935 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ 5936 assert(he) 5937 5938 STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) 5939 __attribute__malloc__ 5940 __attribute__warn_unused_result__ 5941 __attribute__nonnull__(1); 5942 #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ 5943 assert(str) 5944 5945 STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags) 5946 __attribute__warn_unused_result__ 5947 __attribute__nonnull__(pTHX_1); 5948 #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ 5949 assert(str) 5950 5951 STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); 5952 #endif 5953 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) 5954 PERL_CALLCONV void Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av) 5955 __attribute__nonnull__(pTHX_1); 5956 #define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ 5957 assert(sv) 5958 5959 #endif 5960 #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) 5961 PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) 5962 __attribute__nonnull__(pTHX_1) 5963 __attribute__nonnull__(pTHX_2); 5964 #define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ 5965 assert(hv); assert(indexp) 5966 5967 #endif 5968 #if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE) 5969 STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category); 5970 STATIC char* S_stdize_locale(pTHX_ char* locs) 5971 __attribute__nonnull__(pTHX_1); 5972 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ 5973 assert(locs) 5974 5975 #endif 5976 #if defined(PERL_IN_MALLOC_C) 5977 STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p) 5978 __attribute__nonnull__(1); 5979 #define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ 5980 assert(nbytes_p) 5981 5982 #endif 5983 #if defined(PERL_IN_MG_C) 5984 STATIC void S_fixup_errno_string(pTHX_ SV* sv) 5985 __attribute__nonnull__(pTHX_1); 5986 #define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ 5987 assert(sv) 5988 5989 STATIC SV* S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val) 5990 __attribute__nonnull__(pTHX_1) 5991 __attribute__nonnull__(pTHX_2) 5992 __attribute__nonnull__(pTHX_3); 5993 #define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ 5994 assert(sv); assert(mg); assert(meth) 5995 5996 STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth) 5997 __attribute__nonnull__(pTHX_1) 5998 __attribute__nonnull__(pTHX_2) 5999 __attribute__nonnull__(pTHX_3); 6000 #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ 6001 assert(sv); assert(mg); assert(meth) 6002 6003 STATIC void S_restore_magic(pTHX_ const void *p); 6004 STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags) 6005 __attribute__nonnull__(pTHX_2); 6006 #define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ 6007 assert(sv) 6008 6009 STATIC void S_unwind_handler_stack(pTHX_ const void *p); 6010 #endif 6011 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) 6012 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) 6013 __attribute__nonnull__(pTHX_6) 6014 __attribute__nonnull__(pTHX_7); 6015 #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ 6016 assert(posp); assert(lenp) 6017 6018 #endif 6019 #if defined(PERL_IN_MRO_C) 6020 STATIC void S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags) 6021 __attribute__nonnull__(pTHX_1) 6022 __attribute__nonnull__(pTHX_2); 6023 #define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ 6024 assert(isa); assert(name) 6025 6026 STATIC void S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv) 6027 __attribute__nonnull__(pTHX_1) 6028 __attribute__nonnull__(pTHX_2) 6029 __attribute__nonnull__(pTHX_5); 6030 #define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ 6031 assert(stashes); assert(seen_stashes); assert(namesv) 6032 6033 STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level) 6034 __attribute__nonnull__(pTHX_1); 6035 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ 6036 assert(stash) 6037 6038 #endif 6039 #if defined(PERL_IN_NUMERIC_C) 6040 STATIC NV S_mulexp10(NV value, I32 exponent); 6041 #endif 6042 #if defined(PERL_IN_OP_C) 6043 PERL_STATIC_INLINE bool S_aassign_common_vars(pTHX_ OP* o); 6044 STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs) 6045 __attribute__nonnull__(pTHX_1) 6046 __attribute__nonnull__(pTHX_2); 6047 #define PERL_ARGS_ASSERT_APPLY_ATTRS \ 6048 assert(stash); assert(target) 6049 6050 STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) 6051 __attribute__nonnull__(pTHX_1) 6052 __attribute__nonnull__(pTHX_2) 6053 __attribute__nonnull__(pTHX_4); 6054 #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ 6055 assert(stash); assert(target); assert(imopsp) 6056 6057 STATIC void S_bad_type_gv(pTHX_ I32 n, const char *t, GV *gv, U32 flags, const OP *kid) 6058 __attribute__nonnull__(pTHX_2) 6059 __attribute__nonnull__(pTHX_3) 6060 __attribute__nonnull__(pTHX_5); 6061 #define PERL_ARGS_ASSERT_BAD_TYPE_GV \ 6062 assert(t); assert(gv); assert(kid) 6063 6064 STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flags, const OP *kid) 6065 __attribute__nonnull__(pTHX_2) 6066 __attribute__nonnull__(pTHX_3) 6067 __attribute__nonnull__(pTHX_5); 6068 #define PERL_ARGS_ASSERT_BAD_TYPE_PV \ 6069 assert(t); assert(name); assert(kid) 6070 6071 STATIC void S_cop_free(pTHX_ COP *cop) 6072 __attribute__nonnull__(pTHX_1); 6073 #define PERL_ARGS_ASSERT_COP_FREE \ 6074 assert(cop) 6075 6076 STATIC OP * S_dup_attrlist(pTHX_ OP *o) 6077 __attribute__nonnull__(pTHX_1); 6078 #define PERL_ARGS_ASSERT_DUP_ATTRLIST \ 6079 assert(o) 6080 6081 STATIC void S_finalize_op(pTHX_ OP* o) 6082 __attribute__nonnull__(pTHX_1); 6083 #define PERL_ARGS_ASSERT_FINALIZE_OP \ 6084 assert(o) 6085 6086 STATIC void S_find_and_forget_pmops(pTHX_ OP *o) 6087 __attribute__nonnull__(pTHX_1); 6088 #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ 6089 assert(o) 6090 6091 STATIC OP* S_fold_constants(pTHX_ OP *o) 6092 __attribute__nonnull__(pTHX_1); 6093 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ 6094 assert(o) 6095 6096 STATIC OP* S_force_list(pTHX_ OP* arg); 6097 STATIC void S_forget_pmop(pTHX_ PMOP *const o) 6098 __attribute__nonnull__(pTHX_1); 6099 #define PERL_ARGS_ASSERT_FORGET_PMOP \ 6100 assert(o) 6101 6102 STATIC OP* S_gen_constant_list(pTHX_ OP* o); 6103 STATIC SV* S_gv_ename(pTHX_ GV *gv) 6104 __attribute__nonnull__(pTHX_1); 6105 #define PERL_ARGS_ASSERT_GV_ENAME \ 6106 assert(gv) 6107 6108 STATIC void S_inplace_aassign(pTHX_ OP* o) 6109 __attribute__nonnull__(pTHX_1); 6110 #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ 6111 assert(o) 6112 6113 STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) 6114 __attribute__warn_unused_result__ 6115 __attribute__nonnull__(1); 6116 #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ 6117 assert(o) 6118 6119 STATIC I32 S_is_list_assignment(pTHX_ const OP *o) 6120 __attribute__warn_unused_result__; 6121 6122 STATIC OP* S_listkids(pTHX_ OP* o); 6123 STATIC bool S_looks_like_bool(pTHX_ const OP* o) 6124 __attribute__nonnull__(pTHX_1); 6125 #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ 6126 assert(o) 6127 6128 STATIC OP* S_modkids(pTHX_ OP *o, I32 type); 6129 STATIC void S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name) 6130 __attribute__nonnull__(pTHX_1) 6131 __attribute__nonnull__(pTHX_2) 6132 __attribute__nonnull__(pTHX_3); 6133 #define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ 6134 assert(proto); assert(attrs); assert(name) 6135 6136 STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) 6137 __attribute__nonnull__(pTHX_3); 6138 #define PERL_ARGS_ASSERT_MY_KID \ 6139 assert(imopsp) 6140 6141 STATIC OP* S_newDEFSVOP(pTHX) 6142 __attribute__warn_unused_result__; 6143 6144 STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) 6145 __attribute__nonnull__(pTHX_2); 6146 #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ 6147 assert(block) 6148 6149 STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) 6150 __attribute__warn_unused_result__ 6151 __attribute__nonnull__(pTHX_3) 6152 __attribute__nonnull__(pTHX_4); 6153 #define PERL_ARGS_ASSERT_NEW_LOGOP \ 6154 assert(firstp); assert(otherp) 6155 6156 STATIC void S_no_bareword_allowed(pTHX_ OP *o) 6157 __attribute__nonnull__(pTHX_1); 6158 #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ 6159 assert(o) 6160 6161 STATIC OP* S_no_fh_allowed(pTHX_ OP *o) 6162 __attribute__warn_unused_result__ 6163 __attribute__nonnull__(pTHX_1); 6164 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ 6165 assert(o) 6166 6167 STATIC void S_null_listop_in_list_context(pTHX_ OP* o) 6168 __attribute__nonnull__(pTHX_1); 6169 #define PERL_ARGS_ASSERT_NULL_LISTOP_IN_LIST_CONTEXT \ 6170 assert(o) 6171 6172 PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o) 6173 __attribute__nonnull__(pTHX_1); 6174 #define PERL_ARGS_ASSERT_OP_INTEGERIZE \ 6175 assert(o) 6176 6177 PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o) 6178 __attribute__nonnull__(pTHX_1); 6179 #define PERL_ARGS_ASSERT_OP_STD_INIT \ 6180 assert(o) 6181 6182 STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) 6183 __attribute__nonnull__(pTHX_1) 6184 __attribute__nonnull__(pTHX_2) 6185 __attribute__nonnull__(pTHX_3); 6186 #define PERL_ARGS_ASSERT_PMTRANS \ 6187 assert(o); assert(expr); assert(repl) 6188 6189 STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv) 6190 __attribute__nonnull__(pTHX_2) 6191 __attribute__nonnull__(pTHX_3) 6192 __attribute__nonnull__(pTHX_4); 6193 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ 6194 assert(fullname); assert(gv); assert(cv) 6195 6196 STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); 6197 STATIC OP* S_refkids(pTHX_ OP* o, I32 type); 6198 STATIC bool S_scalar_mod_type(const OP *o, I32 type) 6199 __attribute__warn_unused_result__; 6200 6201 STATIC OP* S_scalarboolean(pTHX_ OP *o) 6202 __attribute__nonnull__(pTHX_1); 6203 #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ 6204 assert(o) 6205 6206 STATIC OP* S_scalarkids(pTHX_ OP* o); 6207 STATIC OP* S_scalarseq(pTHX_ OP* o); 6208 STATIC OP* S_search_const(pTHX_ OP *o) 6209 __attribute__warn_unused_result__ 6210 __attribute__nonnull__(pTHX_1); 6211 #define PERL_ARGS_ASSERT_SEARCH_CONST \ 6212 assert(o) 6213 6214 STATIC void S_simplify_sort(pTHX_ OP *o) 6215 __attribute__nonnull__(pTHX_1); 6216 #define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ 6217 assert(o) 6218 6219 STATIC OP* S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 6220 __attribute__warn_unused_result__ 6221 __attribute__nonnull__(pTHX_1) 6222 __attribute__nonnull__(pTHX_2); 6223 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ 6224 assert(o); assert(name) 6225 6226 STATIC OP* S_too_few_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) 6227 __attribute__warn_unused_result__ 6228 __attribute__nonnull__(pTHX_1) 6229 __attribute__nonnull__(pTHX_2); 6230 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_SV \ 6231 assert(o); assert(namesv) 6232 6233 STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 6234 __attribute__nonnull__(pTHX_1) 6235 __attribute__nonnull__(pTHX_2); 6236 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ 6237 assert(o); assert(name) 6238 6239 STATIC OP* S_too_many_arguments_sv(pTHX_ OP *o, SV* namesv, U32 flags) 6240 __attribute__warn_unused_result__ 6241 __attribute__nonnull__(pTHX_1) 6242 __attribute__nonnull__(pTHX_2); 6243 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_SV \ 6244 assert(o); assert(namesv) 6245 6246 #endif 6247 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) 6248 PERL_CALLCONV void Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) 6249 __attribute__nonnull__(pTHX_1) 6250 __attribute__nonnull__(pTHX_2); 6251 #define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ 6252 assert(name); assert(old_cv) 6253 6254 #endif 6255 #if defined(PERL_IN_PAD_C) 6256 STATIC PADOFFSET S_pad_alloc_name(pTHX_ SV *namesv, U32 flags, HV *typestash, HV *ourstash) 6257 __attribute__nonnull__(pTHX_1); 6258 #define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ 6259 assert(namesv) 6260 6261 STATIC void S_pad_check_dup(pTHX_ SV *name, U32 flags, const HV *ourstash) 6262 __attribute__nonnull__(pTHX_1); 6263 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ 6264 assert(name) 6265 6266 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) 6267 __attribute__nonnull__(pTHX_1) 6268 __attribute__nonnull__(pTHX_4) 6269 __attribute__nonnull__(pTHX_8) 6270 __attribute__nonnull__(pTHX_9); 6271 #define PERL_ARGS_ASSERT_PAD_FINDLEX \ 6272 assert(namepv); assert(cv); assert(out_name_sv); assert(out_flags) 6273 6274 STATIC void S_pad_reset(pTHX); 6275 #endif 6276 #if defined(PERL_IN_PERL_C) 6277 STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp) 6278 __attribute__nonnull__(pTHX_1) 6279 __attribute__nonnull__(pTHX_2); 6280 #define PERL_ARGS_ASSERT_FIND_BEGINNING \ 6281 assert(linestr_sv); assert(rsfp) 6282 6283 STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); 6284 STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags) 6285 __attribute__nonnull__(pTHX_1); 6286 #define PERL_ARGS_ASSERT_INCPUSH \ 6287 assert(dir) 6288 6289 STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) 6290 __attribute__nonnull__(pTHX_1); 6291 #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ 6292 assert(p) 6293 6294 STATIC void S_init_ids(pTHX); 6295 STATIC void S_init_interp(pTHX); 6296 STATIC void S_init_main_stash(pTHX); 6297 STATIC void S_init_perllib(pTHX); 6298 STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) 6299 __attribute__nonnull__(pTHX_2); 6300 #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ 6301 assert(argv) 6302 6303 STATIC void S_init_predump_symbols(pTHX); 6304 STATIC SV* S_mayberelocate(pTHX_ const char *const dir, STRLEN len, U32 flags) 6305 __attribute__nonnull__(pTHX_1); 6306 #define PERL_ARGS_ASSERT_MAYBERELOCATE \ 6307 assert(dir) 6308 6309 PERL_STATIC_NO_RET void S_minus_v(pTHX) 6310 __attribute__noreturn__; 6311 6312 PERL_STATIC_NO_RET void S_my_exit_jump(pTHX) 6313 __attribute__noreturn__; 6314 6315 STATIC void S_nuke_stacks(pTHX); 6316 STATIC PerlIO * S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript) 6317 __attribute__nonnull__(pTHX_1) 6318 __attribute__nonnull__(pTHX_3); 6319 #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ 6320 assert(scriptname); assert(suidscript) 6321 6322 STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); 6323 PERL_STATIC_NO_RET void S_run_body(pTHX_ I32 oldscope) 6324 __attribute__noreturn__; 6325 6326 PERL_STATIC_NO_RET void S_usage(pTHX) 6327 __attribute__noreturn__; 6328 6329 #endif 6330 #if defined(PERL_IN_PP_C) 6331 STATIC void S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping) 6332 __attribute__nonnull__(pTHX_1) 6333 __attribute__nonnull__(pTHX_2); 6334 #define PERL_ARGS_ASSERT_DO_CHOMP \ 6335 assert(retval); assert(sv) 6336 6337 STATIC OP* S_do_delete_local(pTHX); 6338 STATIC SV* S_refto(pTHX_ SV* sv) 6339 __attribute__warn_unused_result__ 6340 __attribute__nonnull__(pTHX_1); 6341 #define PERL_ARGS_ASSERT_REFTO \ 6342 assert(sv) 6343 6344 #endif 6345 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) 6346 PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) 6347 __attribute__warn_unused_result__ 6348 __attribute__nonnull__(pTHX_1) 6349 __attribute__nonnull__(pTHX_2) 6350 __attribute__nonnull__(pTHX_4); 6351 #define PERL_ARGS_ASSERT_SOFTREF2XV \ 6352 assert(sv); assert(what); assert(spp) 6353 6354 #endif 6355 #if defined(PERL_IN_PP_CTL_C) 6356 STATIC SV ** S_adjust_stack_on_leave(pTHX_ SV **newsp, SV **sp, SV **mark, I32 gimme, U32 flags, bool lvalue) 6357 __attribute__nonnull__(pTHX_1) 6358 __attribute__nonnull__(pTHX_2) 6359 __attribute__nonnull__(pTHX_3); 6360 #define PERL_ARGS_ASSERT_ADJUST_STACK_ON_LEAVE \ 6361 assert(newsp); assert(sp); assert(mark) 6362 6363 STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) 6364 __attribute__warn_unused_result__ 6365 __attribute__nonnull__(pTHX_1); 6366 #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ 6367 assert(name) 6368 6369 STATIC void S_destroy_matcher(pTHX_ PMOP* matcher) 6370 __attribute__nonnull__(pTHX_1); 6371 #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ 6372 assert(matcher) 6373 6374 STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); 6375 STATIC OP* S_docatch(pTHX_ OP *o) 6376 __attribute__warn_unused_result__; 6377 6378 STATIC bool S_doeval(pTHX_ int gimme, CV* outside, U32 seq, HV* hh); 6379 STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) 6380 __attribute__warn_unused_result__ 6381 __attribute__nonnull__(pTHX_1) 6382 __attribute__nonnull__(pTHX_2) 6383 __attribute__nonnull__(pTHX_5) 6384 __attribute__nonnull__(pTHX_6); 6385 #define PERL_ARGS_ASSERT_DOFINDLABEL \ 6386 assert(o); assert(label); assert(opstack); assert(oplimit) 6387 6388 STATIC MAGIC * S_doparseform(pTHX_ SV *sv) 6389 __attribute__nonnull__(pTHX_1); 6390 #define PERL_ARGS_ASSERT_DOPARSEFORM \ 6391 assert(sv) 6392 6393 STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) 6394 __attribute__warn_unused_result__; 6395 6396 STATIC I32 S_dopoptogiven(pTHX_ I32 startingblock) 6397 __attribute__warn_unused_result__; 6398 6399 STATIC I32 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) 6400 __attribute__warn_unused_result__ 6401 __attribute__nonnull__(pTHX_1); 6402 #define PERL_ARGS_ASSERT_DOPOPTOLABEL \ 6403 assert(label) 6404 6405 STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) 6406 __attribute__warn_unused_result__; 6407 6408 STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) 6409 __attribute__warn_unused_result__ 6410 __attribute__nonnull__(pTHX_1); 6411 #define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ 6412 assert(cxstk) 6413 6414 STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) 6415 __attribute__warn_unused_result__; 6416 6417 STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) 6418 __attribute__warn_unused_result__ 6419 __attribute__nonnull__(pTHX_1); 6420 #define PERL_ARGS_ASSERT_MAKE_MATCHER \ 6421 assert(re) 6422 6423 STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) 6424 __attribute__warn_unused_result__ 6425 __attribute__nonnull__(pTHX_1) 6426 __attribute__nonnull__(pTHX_2); 6427 #define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ 6428 assert(matcher); assert(sv) 6429 6430 STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) 6431 __attribute__warn_unused_result__; 6432 6433 PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) 6434 __attribute__warn_unused_result__ 6435 __attribute__nonnull__(1); 6436 #define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ 6437 assert(name) 6438 6439 STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) 6440 __attribute__warn_unused_result__ 6441 __attribute__nonnull__(pTHX_2); 6442 #define PERL_ARGS_ASSERT_RUN_USER_FILTER \ 6443 assert(buf_sv) 6444 6445 STATIC void S_rxres_free(pTHX_ void** rsp) 6446 __attribute__nonnull__(pTHX_1); 6447 #define PERL_ARGS_ASSERT_RXRES_FREE \ 6448 assert(rsp) 6449 6450 STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) 6451 __attribute__nonnull__(pTHX_1) 6452 __attribute__nonnull__(pTHX_2); 6453 #define PERL_ARGS_ASSERT_RXRES_RESTORE \ 6454 assert(rsp); assert(rx) 6455 6456 STATIC void S_save_lines(pTHX_ AV *array, SV *sv) 6457 __attribute__nonnull__(pTHX_2); 6458 #define PERL_ARGS_ASSERT_SAVE_LINES \ 6459 assert(sv) 6460 6461 #endif 6462 #if defined(PERL_IN_PP_HOT_C) 6463 STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey) 6464 __attribute__nonnull__(pTHX_1) 6465 __attribute__nonnull__(pTHX_2); 6466 #define PERL_ARGS_ASSERT_DO_ODDBALL \ 6467 assert(oddkey); assert(firstkey) 6468 6469 STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp) 6470 __attribute__warn_unused_result__ 6471 __attribute__nonnull__(pTHX_1); 6472 #define PERL_ARGS_ASSERT_METHOD_COMMON \ 6473 assert(meth) 6474 6475 #endif 6476 #if defined(PERL_IN_PP_PACK_C) 6477 STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest, const bool needs_swap) 6478 __attribute__warn_unused_result__ 6479 __attribute__nonnull__(1) 6480 __attribute__nonnull__(3); 6481 #define PERL_ARGS_ASSERT_BYTES_TO_UNI \ 6482 assert(start); assert(dest) 6483 6484 STATIC int S_div128(pTHX_ SV *pnum, bool *done) 6485 __attribute__nonnull__(pTHX_1) 6486 __attribute__nonnull__(pTHX_2); 6487 #define PERL_ARGS_ASSERT_DIV128 \ 6488 assert(pnum); assert(done) 6489 6490 STATIC char S_first_symbol(const char *pat, const char *patend) 6491 __attribute__nonnull__(1) 6492 __attribute__nonnull__(2); 6493 #define PERL_ARGS_ASSERT_FIRST_SYMBOL \ 6494 assert(pat); assert(patend) 6495 6496 STATIC const char * S_get_num(pTHX_ const char *patptr, I32 *lenptr) 6497 __attribute__warn_unused_result__ 6498 __attribute__nonnull__(pTHX_1) 6499 __attribute__nonnull__(pTHX_2); 6500 #define PERL_ARGS_ASSERT_GET_NUM \ 6501 assert(patptr); assert(lenptr) 6502 6503 STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender) 6504 __attribute__nonnull__(pTHX_1) 6505 __attribute__nonnull__(pTHX_2); 6506 #define PERL_ARGS_ASSERT_GROUP_END \ 6507 assert(patptr); assert(patend) 6508 6509 STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l) 6510 __attribute__warn_unused_result__ 6511 __attribute__nonnull__(pTHX_1); 6512 #define PERL_ARGS_ASSERT_IS_AN_INT \ 6513 assert(s) 6514 6515 STATIC I32 S_measure_struct(pTHX_ struct tempsym* symptr) 6516 __attribute__nonnull__(pTHX_1); 6517 #define PERL_ARGS_ASSERT_MEASURE_STRUCT \ 6518 assert(symptr) 6519 6520 STATIC SV* S_mul128(pTHX_ SV *sv, U8 m) 6521 __attribute__nonnull__(pTHX_1); 6522 #define PERL_ARGS_ASSERT_MUL128 \ 6523 assert(sv) 6524 6525 STATIC bool S_need_utf8(const char *pat, const char *patend) 6526 __attribute__nonnull__(1) 6527 __attribute__nonnull__(2); 6528 #define PERL_ARGS_ASSERT_NEED_UTF8 \ 6529 assert(pat); assert(patend) 6530 6531 STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr) 6532 __attribute__nonnull__(pTHX_1); 6533 #define PERL_ARGS_ASSERT_NEXT_SYMBOL \ 6534 assert(symptr) 6535 6536 STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym* symptr, SV **beglist, SV **endlist) 6537 __attribute__nonnull__(pTHX_1) 6538 __attribute__nonnull__(pTHX_2) 6539 __attribute__nonnull__(pTHX_3) 6540 __attribute__nonnull__(pTHX_4); 6541 #define PERL_ARGS_ASSERT_PACK_REC \ 6542 assert(cat); assert(symptr); assert(beglist); assert(endlist) 6543 6544 STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) 6545 __attribute__warn_unused_result__ 6546 __attribute__nonnull__(pTHX_1); 6547 #define PERL_ARGS_ASSERT_SV_EXP_GROW \ 6548 assert(sv) 6549 6550 STATIC I32 S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) 6551 __attribute__nonnull__(pTHX_1) 6552 __attribute__nonnull__(pTHX_2) 6553 __attribute__nonnull__(pTHX_3) 6554 __attribute__nonnull__(pTHX_4); 6555 #define PERL_ARGS_ASSERT_UNPACK_REC \ 6556 assert(symptr); assert(s); assert(strbeg); assert(strend) 6557 6558 #endif 6559 #if defined(PERL_IN_PP_SORT_C) 6560 STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) 6561 __attribute__nonnull__(pTHX_1) 6562 __attribute__nonnull__(pTHX_2); 6563 #define PERL_ARGS_ASSERT_AMAGIC_CMP \ 6564 assert(str1); assert(str2) 6565 6566 STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) 6567 __attribute__nonnull__(pTHX_1) 6568 __attribute__nonnull__(pTHX_2); 6569 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ 6570 assert(str1); assert(str2) 6571 6572 STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) 6573 __attribute__nonnull__(pTHX_1) 6574 __attribute__nonnull__(pTHX_2); 6575 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ 6576 assert(a); assert(b) 6577 6578 STATIC I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b) 6579 __attribute__nonnull__(pTHX_1) 6580 __attribute__nonnull__(pTHX_2); 6581 #define PERL_ARGS_ASSERT_AMAGIC_NCMP \ 6582 assert(a); assert(b) 6583 6584 STATIC void S_qsortsvu(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t compare) 6585 __attribute__nonnull__(pTHX_3); 6586 #define PERL_ARGS_ASSERT_QSORTSVU \ 6587 assert(compare) 6588 6589 STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b) 6590 __attribute__nonnull__(pTHX_1) 6591 __attribute__nonnull__(pTHX_2); 6592 #define PERL_ARGS_ASSERT_SORTCV \ 6593 assert(a); assert(b) 6594 6595 STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b) 6596 __attribute__nonnull__(pTHX_1) 6597 __attribute__nonnull__(pTHX_2); 6598 #define PERL_ARGS_ASSERT_SORTCV_STACKED \ 6599 assert(a); assert(b) 6600 6601 STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b) 6602 __attribute__nonnull__(pTHX_1) 6603 __attribute__nonnull__(pTHX_2); 6604 #define PERL_ARGS_ASSERT_SORTCV_XSUB \ 6605 assert(a); assert(b) 6606 6607 STATIC I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b) 6608 __attribute__nonnull__(pTHX_1) 6609 __attribute__nonnull__(pTHX_2); 6610 #define PERL_ARGS_ASSERT_SV_I_NCMP \ 6611 assert(a); assert(b) 6612 6613 STATIC I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) 6614 __attribute__nonnull__(pTHX_1) 6615 __attribute__nonnull__(pTHX_2); 6616 #define PERL_ARGS_ASSERT_SV_NCMP \ 6617 assert(a); assert(b) 6618 6619 #endif 6620 #if defined(PERL_IN_PP_SYS_C) 6621 STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop) 6622 __attribute__nonnull__(pTHX_1) 6623 __attribute__nonnull__(pTHX_2); 6624 #define PERL_ARGS_ASSERT_DOFORM \ 6625 assert(cv); assert(gv) 6626 6627 STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array) 6628 __attribute__nonnull__(pTHX_1); 6629 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL \ 6630 assert(array) 6631 6632 #endif 6633 #if defined(PERL_IN_REGCOMP_C) 6634 STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end) 6635 __attribute__nonnull__(pTHX_1); 6636 #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ 6637 assert(invlist) 6638 6639 PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0) 6640 __attribute__warn_unused_result__ 6641 __attribute__nonnull__(pTHX_1); 6642 #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ 6643 assert(invlist) 6644 6645 PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) 6646 __attribute__warn_unused_result__; 6647 6648 STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n) 6649 __attribute__warn_unused_result__ 6650 __attribute__nonnull__(1) 6651 __attribute__nonnull__(2); 6652 #define PERL_ARGS_ASSERT_ADD_DATA \ 6653 assert(pRExC_state); assert(s) 6654 6655 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) 6656 __attribute__nonnull__(pTHX_1) 6657 __attribute__nonnull__(pTHX_2) 6658 __attribute__nonnull__(pTHX_3); 6659 #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \ 6660 assert(pRExC_state); assert(node); assert(flagp) 6661 6662 PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state) 6663 __attribute__nonnull__(pTHX_1); 6664 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ 6665 assert(pRExC_state) 6666 6667 STATIC bool S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state) 6668 __attribute__nonnull__(pTHX_1); 6669 #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \ 6670 assert(pRExC_state) 6671 6672 STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node) 6673 __attribute__nonnull__(pTHX_1) 6674 __attribute__nonnull__(pTHX_2); 6675 #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ 6676 assert(pRExC_state); assert(node) 6677 6678 PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(pTHX_ SV* invlist) 6679 __attribute__warn_unused_result__ 6680 __attribute__nonnull__(pTHX_1); 6681 #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ 6682 assert(invlist) 6683 6684 PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist) 6685 __attribute__warn_unused_result__ 6686 __attribute__nonnull__(pTHX_1); 6687 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ 6688 assert(invlist) 6689 6690 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) 6691 __attribute__nonnull__(pTHX_1) 6692 __attribute__nonnull__(pTHX_4); 6693 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \ 6694 assert(pRExC_state); assert(flagp) 6695 6696 STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse) 6697 __attribute__nonnull__(pTHX_1) 6698 __attribute__nonnull__(pTHX_3) 6699 __attribute__nonnull__(pTHX_5); 6700 #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ 6701 assert(pRExC_state); assert(flagp); assert(oregcomp_parse) 6702 6703 PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist) 6704 __attribute__warn_unused_result__ 6705 __attribute__nonnull__(pTHX_1); 6706 #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ 6707 assert(invlist) 6708 6709 PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist) 6710 __attribute__warn_unused_result__ 6711 __attribute__nonnull__(pTHX_1); 6712 #define PERL_ARGS_ASSERT_INVLIST_CLONE \ 6713 assert(invlist) 6714 6715 STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len) 6716 __attribute__nonnull__(pTHX_1); 6717 #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ 6718 assert(invlist) 6719 6720 PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist) 6721 __attribute__warn_unused_result__ 6722 __attribute__nonnull__(pTHX_1); 6723 #define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ 6724 assert(invlist) 6725 6726 PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist) 6727 __attribute__warn_unused_result__ 6728 __attribute__nonnull__(pTHX_1); 6729 #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ 6730 assert(invlist) 6731 6732 PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist) 6733 __attribute__nonnull__(pTHX_1); 6734 #define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ 6735 assert(invlist) 6736 6737 PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist) 6738 __attribute__nonnull__(pTHX_1); 6739 #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ 6740 assert(invlist) 6741 6742 STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end) 6743 __attribute__warn_unused_result__ 6744 __attribute__nonnull__(pTHX_1) 6745 __attribute__nonnull__(pTHX_2) 6746 __attribute__nonnull__(pTHX_3); 6747 #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ 6748 assert(invlist); assert(start); assert(end) 6749 6750 PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist) 6751 __attribute__warn_unused_result__ 6752 __attribute__nonnull__(pTHX_1); 6753 #define PERL_ARGS_ASSERT_INVLIST_MAX \ 6754 assert(invlist) 6755 6756 PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist) 6757 __attribute__warn_unused_result__ 6758 __attribute__nonnull__(pTHX_1); 6759 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ 6760 assert(invlist) 6761 6762 PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset) 6763 __attribute__nonnull__(pTHX_1); 6764 #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ 6765 assert(invlist) 6766 6767 PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index) 6768 __attribute__nonnull__(pTHX_1); 6769 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ 6770 assert(invlist) 6771 6772 PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist) 6773 __attribute__nonnull__(pTHX_1); 6774 #define PERL_ARGS_ASSERT_INVLIST_TRIM \ 6775 assert(invlist) 6776 6777 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) 6778 __attribute__nonnull__(pTHX_1) 6779 __attribute__nonnull__(pTHX_2) 6780 __attribute__nonnull__(pTHX_3) 6781 __attribute__nonnull__(pTHX_4); 6782 #define PERL_ARGS_ASSERT_JOIN_EXACT \ 6783 assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char) 6784 6785 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) 6786 __attribute__nonnull__(pTHX_1) 6787 __attribute__nonnull__(pTHX_2) 6788 __attribute__nonnull__(pTHX_3) 6789 __attribute__nonnull__(pTHX_4) 6790 __attribute__nonnull__(pTHX_5); 6791 #define PERL_ARGS_ASSERT_MAKE_TRIE \ 6792 assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) 6793 6794 STATIC void S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth) 6795 __attribute__nonnull__(pTHX_1) 6796 __attribute__nonnull__(pTHX_2) 6797 __attribute__nonnull__(pTHX_3); 6798 #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \ 6799 assert(pRExC_state); assert(source); assert(stclass) 6800 6801 STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state) 6802 __attribute__nonnull__(pTHX_1); 6803 #define PERL_ARGS_ASSERT_NEXTCHAR \ 6804 assert(pRExC_state) 6805 6806 STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state) 6807 __attribute__nonnull__(pTHX_1); 6808 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ 6809 assert(pRExC_state) 6810 6811 STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr) 6812 __attribute__nonnull__(pTHX_1) 6813 __attribute__nonnull__(pTHX_2); 6814 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \ 6815 assert(node); assert(invlist_ptr) 6816 6817 PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...) 6818 __attribute__noreturn__ 6819 __attribute__nonnull__(pTHX_2) 6820 __attribute__nonnull__(pTHX_3); 6821 #define PERL_ARGS_ASSERT_RE_CROAK2 \ 6822 assert(pat1); assert(pat2) 6823 6824 STATIC regnode* S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) 6825 __attribute__nonnull__(pTHX_1) 6826 __attribute__nonnull__(pTHX_3); 6827 #define PERL_ARGS_ASSERT_REG \ 6828 assert(pRExC_state); assert(flagp) 6829 6830 STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op) 6831 __attribute__nonnull__(pTHX_1); 6832 #define PERL_ARGS_ASSERT_REG_NODE \ 6833 assert(pRExC_state) 6834 6835 STATIC UV S_reg_recode(pTHX_ const char value, SV **encp) 6836 __attribute__nonnull__(pTHX_2); 6837 #define PERL_ARGS_ASSERT_REG_RECODE \ 6838 assert(encp) 6839 6840 STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) 6841 __attribute__nonnull__(pTHX_1); 6842 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ 6843 assert(pRExC_state) 6844 6845 STATIC bool S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state) 6846 __attribute__nonnull__(pTHX_1); 6847 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ 6848 assert(pRExC_state) 6849 6850 STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg) 6851 __attribute__nonnull__(pTHX_1); 6852 #define PERL_ARGS_ASSERT_REGANODE \ 6853 assert(pRExC_state) 6854 6855 STATIC regnode* S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 6856 __attribute__nonnull__(pTHX_1) 6857 __attribute__nonnull__(pTHX_2); 6858 #define PERL_ARGS_ASSERT_REGATOM \ 6859 assert(pRExC_state); assert(flagp) 6860 6861 STATIC regnode* S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) 6862 __attribute__nonnull__(pTHX_1) 6863 __attribute__nonnull__(pTHX_2); 6864 #define PERL_ARGS_ASSERT_REGBRANCH \ 6865 assert(pRExC_state); assert(flagp) 6866 6867 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) 6868 __attribute__nonnull__(pTHX_1) 6869 __attribute__nonnull__(pTHX_2); 6870 #define PERL_ARGS_ASSERT_REGCLASS \ 6871 assert(pRExC_state); assert(flagp) 6872 6873 STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth) 6874 __attribute__nonnull__(pTHX_1) 6875 __attribute__nonnull__(pTHX_3); 6876 #define PERL_ARGS_ASSERT_REGINSERT \ 6877 assert(pRExC_state); assert(opnd) 6878 6879 STATIC char * S_regpatws(RExC_state_t *pRExC_state, char *p, const bool recognize_comment) 6880 __attribute__warn_unused_result__ 6881 __attribute__nonnull__(1) 6882 __attribute__nonnull__(2); 6883 #define PERL_ARGS_ASSERT_REGPATWS \ 6884 assert(pRExC_state); assert(p) 6885 6886 STATIC regnode* S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 6887 __attribute__nonnull__(pTHX_1) 6888 __attribute__nonnull__(pTHX_2); 6889 #define PERL_ARGS_ASSERT_REGPIECE \ 6890 assert(pRExC_state); assert(flagp) 6891 6892 PERL_STATIC_INLINE I32 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value, const bool strict) 6893 __attribute__nonnull__(pTHX_1); 6894 #define PERL_ARGS_ASSERT_REGPPOSIXCC \ 6895 assert(pRExC_state) 6896 6897 STATIC void S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 6898 __attribute__nonnull__(pTHX_1) 6899 __attribute__nonnull__(pTHX_2) 6900 __attribute__nonnull__(pTHX_3); 6901 #define PERL_ARGS_ASSERT_REGTAIL \ 6902 assert(pRExC_state); assert(p); assert(val) 6903 6904 PERL_STATIC_INLINE STRLEN S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char *s) 6905 __attribute__nonnull__(pTHX_1) 6906 __attribute__nonnull__(pTHX_3); 6907 #define PERL_ARGS_ASSERT_REGUNI \ 6908 assert(pRExC_state); assert(s) 6909 6910 STATIC char * S_regwhite(RExC_state_t *pRExC_state, char *p) 6911 __attribute__warn_unused_result__ 6912 __attribute__nonnull__(1) 6913 __attribute__nonnull__(2); 6914 #define PERL_ARGS_ASSERT_REGWHITE \ 6915 assert(pRExC_state); assert(p) 6916 6917 STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) 6918 __attribute__nonnull__(pTHX_1) 6919 __attribute__nonnull__(pTHX_2) 6920 __attribute__nonnull__(pTHX_3); 6921 #define PERL_ARGS_ASSERT_SCAN_COMMIT \ 6922 assert(pRExC_state); assert(data); assert(minlenp) 6923 6924 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) 6925 __attribute__nonnull__(pTHX_1) 6926 __attribute__nonnull__(pTHX_2); 6927 #define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ 6928 assert(pRExC_state); assert(node) 6929 6930 PERL_STATIC_INLINE void S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end) 6931 __attribute__nonnull__(pTHX_1); 6932 #define PERL_ARGS_ASSERT_SSC_ADD_RANGE \ 6933 assert(ssc) 6934 6935 STATIC void S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with) 6936 __attribute__nonnull__(pTHX_1) 6937 __attribute__nonnull__(pTHX_2) 6938 __attribute__nonnull__(pTHX_3); 6939 #define PERL_ARGS_ASSERT_SSC_AND \ 6940 assert(pRExC_state); assert(ssc); assert(and_with) 6941 6942 STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc) 6943 __attribute__nonnull__(pTHX_1); 6944 #define PERL_ARGS_ASSERT_SSC_ANYTHING \ 6945 assert(ssc) 6946 6947 PERL_STATIC_INLINE void S_ssc_clear_locale(pTHX_ regnode_ssc *ssc) 6948 __attribute__nonnull__(pTHX_1); 6949 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ 6950 assert(ssc) 6951 6952 PERL_STATIC_INLINE void S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp) 6953 __attribute__nonnull__(pTHX_1); 6954 #define PERL_ARGS_ASSERT_SSC_CP_AND \ 6955 assert(ssc) 6956 6957 STATIC void S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc) 6958 __attribute__nonnull__(pTHX_1) 6959 __attribute__nonnull__(pTHX_2); 6960 #define PERL_ARGS_ASSERT_SSC_FINALIZE \ 6961 assert(pRExC_state); assert(ssc) 6962 6963 STATIC void S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc) 6964 __attribute__nonnull__(pTHX_1) 6965 __attribute__nonnull__(pTHX_2); 6966 #define PERL_ARGS_ASSERT_SSC_INIT \ 6967 assert(pRExC_state); assert(ssc) 6968 6969 PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd) 6970 __attribute__nonnull__(pTHX_1) 6971 __attribute__nonnull__(pTHX_2); 6972 #define PERL_ARGS_ASSERT_SSC_INTERSECTION \ 6973 assert(ssc); assert(invlist) 6974 6975 STATIC int S_ssc_is_anything(pTHX_ const regnode_ssc *ssc) 6976 __attribute__warn_unused_result__ 6977 __attribute__nonnull__(pTHX_1); 6978 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ 6979 assert(ssc) 6980 6981 STATIC int S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state, const regnode_ssc *ssc) 6982 __attribute__warn_unused_result__ 6983 __attribute__nonnull__(pTHX_1) 6984 __attribute__nonnull__(pTHX_2); 6985 #define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ 6986 assert(pRExC_state); assert(ssc) 6987 6988 STATIC void S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with) 6989 __attribute__nonnull__(pTHX_1) 6990 __attribute__nonnull__(pTHX_2) 6991 __attribute__nonnull__(pTHX_3); 6992 #define PERL_ARGS_ASSERT_SSC_OR \ 6993 assert(pRExC_state); assert(ssc); assert(or_with) 6994 6995 PERL_STATIC_INLINE void S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd) 6996 __attribute__nonnull__(pTHX_1) 6997 __attribute__nonnull__(pTHX_2); 6998 #define PERL_ARGS_ASSERT_SSC_UNION \ 6999 assert(ssc); assert(invlist) 7000 7001 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) 7002 __attribute__nonnull__(pTHX_1) 7003 __attribute__nonnull__(pTHX_2) 7004 __attribute__nonnull__(pTHX_3) 7005 __attribute__nonnull__(pTHX_4) 7006 __attribute__nonnull__(pTHX_5); 7007 #define PERL_ARGS_ASSERT_STUDY_CHUNK \ 7008 assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) 7009 7010 #endif 7011 #if defined(PERL_IN_REGCOMP_C) || defined (PERL_IN_DUMP_C) 7012 PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* const indent, SV* const invlist) 7013 __attribute__nonnull__(pTHX_1) 7014 __attribute__nonnull__(pTHX_3) 7015 __attribute__nonnull__(pTHX_4); 7016 #define PERL_ARGS_ASSERT__INVLIST_DUMP \ 7017 assert(file); assert(indent); assert(invlist) 7018 7019 #endif 7020 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C) 7021 PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list) 7022 __attribute__warn_unused_result__ 7023 __attribute__nonnull__(pTHX_1); 7024 #define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ 7025 assert(list) 7026 7027 #endif 7028 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 7029 PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale) 7030 __attribute__nonnull__(pTHX_2); 7031 #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \ 7032 assert(node) 7033 7034 #endif 7035 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) 7036 PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) 7037 __attribute__warn_unused_result__ 7038 __attribute__nonnull__(pTHX_1); 7039 #define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ 7040 assert(swash) 7041 7042 PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp) 7043 __attribute__warn_unused_result__ 7044 __attribute__nonnull__(pTHX_1); 7045 #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ 7046 assert(invlist) 7047 7048 PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) 7049 __attribute__warn_unused_result__ 7050 __attribute__nonnull__(pTHX_1); 7051 #define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ 7052 assert(invlist) 7053 7054 PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist) 7055 __attribute__warn_unused_result__ 7056 __attribute__nonnull__(pTHX_1); 7057 #define PERL_ARGS_ASSERT__INVLIST_LEN \ 7058 assert(invlist) 7059 7060 PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp) 7061 __attribute__warn_unused_result__ 7062 __attribute__nonnull__(pTHX_1); 7063 #define PERL_ARGS_ASSERT__INVLIST_SEARCH \ 7064 assert(invlist) 7065 7066 PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) 7067 __attribute__warn_unused_result__ 7068 __attribute__nonnull__(pTHX_1); 7069 #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ 7070 assert(swash) 7071 7072 PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(pTHX_ SV* invlist) 7073 __attribute__warn_unused_result__ 7074 __attribute__nonnull__(pTHX_1); 7075 #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ 7076 assert(invlist) 7077 7078 #endif 7079 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) 7080 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) 7081 __attribute__nonnull__(pTHX_1) 7082 __attribute__nonnull__(pTHX_2) 7083 __attribute__nonnull__(pTHX_3); 7084 #define PERL_ARGS_ASSERT__CORE_SWASH_INIT \ 7085 assert(pkg); assert(name); assert(listsv) 7086 7087 #endif 7088 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) 7089 STATIC char* S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len) 7090 __attribute__warn_unused_result__ 7091 __attribute__pure__ 7092 __attribute__nonnull__(pTHX_1); 7093 #define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \ 7094 assert(s) 7095 7096 STATIC char S_grok_bslash_c(pTHX_ const char source, const bool output_warning) 7097 __attribute__warn_unused_result__; 7098 7099 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) 7100 __attribute__warn_unused_result__ 7101 __attribute__nonnull__(pTHX_1) 7102 __attribute__nonnull__(pTHX_2) 7103 __attribute__nonnull__(pTHX_3); 7104 #define PERL_ARGS_ASSERT_GROK_BSLASH_O \ 7105 assert(s); assert(uv); assert(error_msg) 7106 7107 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) 7108 __attribute__warn_unused_result__ 7109 __attribute__nonnull__(pTHX_1) 7110 __attribute__nonnull__(pTHX_2) 7111 __attribute__nonnull__(pTHX_3); 7112 #define PERL_ARGS_ASSERT_GROK_BSLASH_X \ 7113 assert(s); assert(uv); assert(error_msg) 7114 7115 PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped) 7116 __attribute__warn_unused_result__ 7117 __attribute__pure__ 7118 __attribute__nonnull__(pTHX_1); 7119 #define PERL_ARGS_ASSERT_REGCURLY \ 7120 assert(s) 7121 7122 #endif 7123 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) 7124 PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, const UV start, const UV end) 7125 __attribute__warn_unused_result__; 7126 7127 /* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i) 7128 __attribute__nonnull__(pTHX_1) 7129 __attribute__nonnull__(pTHX_2) 7130 __attribute__nonnull__(pTHX_3); */ 7131 7132 PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i) 7133 __attribute__nonnull__(pTHX_2) 7134 __attribute__nonnull__(pTHX_4); 7135 #define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ 7136 assert(b); assert(i) 7137 7138 PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist) 7139 __attribute__nonnull__(pTHX_1); 7140 #define PERL_ARGS_ASSERT__INVLIST_INVERT \ 7141 assert(invlist) 7142 7143 PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch) 7144 __attribute__nonnull__(pTHX_1) 7145 __attribute__nonnull__(pTHX_4); 7146 #define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \ 7147 assert(invlist); assert(swatch) 7148 7149 /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result) 7150 __attribute__nonnull__(pTHX_1) 7151 __attribute__nonnull__(pTHX_2) 7152 __attribute__nonnull__(pTHX_3); */ 7153 7154 /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output) 7155 __attribute__nonnull__(pTHX_2) 7156 __attribute__nonnull__(pTHX_3); */ 7157 7158 PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output) 7159 __attribute__nonnull__(pTHX_2) 7160 __attribute__nonnull__(pTHX_4); 7161 #define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ 7162 assert(b); assert(output) 7163 7164 PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) 7165 __attribute__warn_unused_result__; 7166 7167 PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) 7168 __attribute__warn_unused_result__ 7169 __attribute__nonnull__(pTHX_3); 7170 #define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ 7171 assert(other_elements_ptr) 7172 7173 PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) 7174 __attribute__warn_unused_result__ 7175 __attribute__nonnull__(pTHX_1); 7176 #define PERL_ARGS_ASSERT__SWASH_TO_INVLIST \ 7177 assert(swash) 7178 7179 #endif 7180 #if defined(PERL_IN_REGEXEC_C) 7181 STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) 7182 __attribute__warn_unused_result__ 7183 __attribute__nonnull__(pTHX_1) 7184 __attribute__nonnull__(pTHX_2) 7185 __attribute__nonnull__(pTHX_3) 7186 __attribute__nonnull__(pTHX_4); 7187 #define PERL_ARGS_ASSERT_FIND_BYCLASS \ 7188 assert(prog); assert(c); assert(s); assert(strend) 7189 7190 STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) 7191 __attribute__warn_unused_result__; 7192 7193 STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) 7194 __attribute__warn_unused_result__ 7195 __attribute__nonnull__(pTHX_2); 7196 #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ 7197 assert(character) 7198 7199 STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) 7200 __attribute__warn_unused_result__ 7201 __attribute__nonnull__(pTHX_1) 7202 __attribute__nonnull__(pTHX_2); 7203 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ 7204 assert(rex); assert(scan) 7205 7206 STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p) 7207 __attribute__nonnull__(pTHX_1) 7208 __attribute__nonnull__(pTHX_2); 7209 #define PERL_ARGS_ASSERT_REGCPPOP \ 7210 assert(rex); assert(maxopenparen_p) 7211 7212 STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen) 7213 __attribute__nonnull__(pTHX_1); 7214 #define PERL_ARGS_ASSERT_REGCPPUSH \ 7215 assert(rex) 7216 7217 STATIC U8* S_reghop3(U8 *s, SSize_t off, const U8 *lim) 7218 __attribute__warn_unused_result__ 7219 __attribute__nonnull__(1) 7220 __attribute__nonnull__(3); 7221 #define PERL_ARGS_ASSERT_REGHOP3 \ 7222 assert(s); assert(lim) 7223 7224 STATIC U8* S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim) 7225 __attribute__warn_unused_result__ 7226 __attribute__nonnull__(1) 7227 __attribute__nonnull__(3) 7228 __attribute__nonnull__(4); 7229 #define PERL_ARGS_ASSERT_REGHOP4 \ 7230 assert(s); assert(llim); assert(rlim) 7231 7232 STATIC U8* S_reghopmaybe3(U8 *s, SSize_t off, const U8 *lim) 7233 __attribute__warn_unused_result__ 7234 __attribute__nonnull__(1) 7235 __attribute__nonnull__(3); 7236 #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ 7237 assert(s); assert(lim) 7238 7239 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) 7240 __attribute__warn_unused_result__ 7241 __attribute__nonnull__(pTHX_2) 7242 __attribute__nonnull__(pTHX_3) 7243 __attribute__nonnull__(pTHX_4); 7244 #define PERL_ARGS_ASSERT_REGINCLASS \ 7245 assert(n); assert(p); assert(p_end) 7246 7247 STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) 7248 __attribute__warn_unused_result__ 7249 __attribute__nonnull__(pTHX_1) 7250 __attribute__nonnull__(pTHX_2) 7251 __attribute__nonnull__(pTHX_3); 7252 #define PERL_ARGS_ASSERT_REGMATCH \ 7253 assert(reginfo); assert(startpos); assert(prog) 7254 7255 STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth) 7256 __attribute__warn_unused_result__ 7257 __attribute__nonnull__(pTHX_1) 7258 __attribute__nonnull__(pTHX_2) 7259 __attribute__nonnull__(pTHX_3) 7260 __attribute__nonnull__(pTHX_4); 7261 #define PERL_ARGS_ASSERT_REGREPEAT \ 7262 assert(prog); assert(startposp); assert(p); assert(reginfo) 7263 7264 STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) 7265 __attribute__warn_unused_result__ 7266 __attribute__nonnull__(pTHX_1) 7267 __attribute__nonnull__(pTHX_2); 7268 #define PERL_ARGS_ASSERT_REGTRY \ 7269 assert(reginfo); assert(startposp) 7270 7271 STATIC bool S_to_byte_substr(pTHX_ regexp * prog) 7272 __attribute__nonnull__(pTHX_1); 7273 #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ 7274 assert(prog) 7275 7276 STATIC void S_to_utf8_substr(pTHX_ regexp * prog) 7277 __attribute__nonnull__(pTHX_1); 7278 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ 7279 assert(prog) 7280 7281 #endif 7282 #if defined(PERL_IN_SCOPE_C) 7283 STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); 7284 STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) 7285 __attribute__nonnull__(pTHX_1); 7286 #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ 7287 assert(sptr) 7288 7289 #endif 7290 #if defined(PERL_IN_SV_C) 7291 STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len) 7292 __attribute__nonnull__(2) 7293 __attribute__nonnull__(3); 7294 #define PERL_ARGS_ASSERT_F0CONVERT \ 7295 assert(endbuf); assert(len) 7296 7297 STATIC void S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv) 7298 __attribute__nonnull__(pTHX_1) 7299 __attribute__nonnull__(pTHX_2); 7300 #define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ 7301 assert(gv); assert(cv) 7302 7303 STATIC void S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN from_cache, STRLEN real, SV *const sv) 7304 __attribute__nonnull__(pTHX_1) 7305 __attribute__nonnull__(pTHX_4); 7306 #define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ 7307 assert(func); assert(sv) 7308 7309 STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt) 7310 __attribute__nonnull__(pTHX_1); 7311 #define PERL_ARGS_ASSERT_CURSE \ 7312 assert(sv) 7313 7314 STATIC I32 S_expect_number(pTHX_ char **const pattern) 7315 __attribute__warn_unused_result__ 7316 __attribute__nonnull__(pTHX_1); 7317 #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ 7318 assert(pattern) 7319 7320 STATIC I32 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val) 7321 __attribute__nonnull__(pTHX_2); 7322 #define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ 7323 assert(val) 7324 7325 STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val) 7326 __attribute__nonnull__(pTHX_2); 7327 #define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ 7328 assert(val) 7329 7330 STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top); 7331 STATIC bool S_glob_2number(pTHX_ GV* const gv) 7332 __attribute__nonnull__(pTHX_1); 7333 #define PERL_ARGS_ASSERT_GLOB_2NUMBER \ 7334 assert(gv) 7335 7336 STATIC void S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype) 7337 __attribute__nonnull__(pTHX_1) 7338 __attribute__nonnull__(pTHX_2); 7339 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ 7340 assert(dstr); assert(sstr) 7341 7342 STATIC void S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr) 7343 __attribute__nonnull__(pTHX_1) 7344 __attribute__nonnull__(pTHX_2); 7345 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \ 7346 assert(dstr); assert(sstr) 7347 7348 STATIC SV * S_more_sv(pTHX); 7349 STATIC void S_not_a_number(pTHX_ SV *const sv) 7350 __attribute__nonnull__(pTHX_1); 7351 #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ 7352 assert(sv) 7353 7354 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) 7355 __attribute__warn_unused_result__ 7356 __attribute__nonnull__(1); 7357 #define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ 7358 assert(tbl) 7359 7360 STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv) 7361 __attribute__nonnull__(pTHX_1); 7362 #define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ 7363 assert(sv) 7364 7365 STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags) 7366 __attribute__nonnull__(pTHX_1); 7367 #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ 7368 assert(ptr) 7369 7370 STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu) 7371 __attribute__nonnull__(pTHX_1) 7372 __attribute__nonnull__(pTHX_2) 7373 __attribute__nonnull__(pTHX_3); 7374 #define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ 7375 assert(s); assert(target); assert(end) 7376 7377 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) 7378 __attribute__nonnull__(pTHX_1) 7379 __attribute__nonnull__(pTHX_2) 7380 __attribute__nonnull__(pTHX_3) 7381 __attribute__nonnull__(pTHX_4); 7382 #define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ 7383 assert(sv); assert(mgp); assert(start); assert(send) 7384 7385 STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STRLEN *const uoffset, bool *const at_end) 7386 __attribute__nonnull__(1) 7387 __attribute__nonnull__(2) 7388 __attribute__nonnull__(3) 7389 __attribute__nonnull__(4); 7390 #define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ 7391 assert(start); assert(send); assert(uoffset); assert(at_end) 7392 7393 STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, const STRLEN uend) 7394 __attribute__nonnull__(1) 7395 __attribute__nonnull__(2); 7396 #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ 7397 assert(start); assert(send) 7398 7399 PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags) 7400 __attribute__nonnull__(pTHX_1); 7401 #define PERL_ARGS_ASSERT_SV_UNGLOB \ 7402 assert(sv) 7403 7404 STATIC char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) 7405 __attribute__warn_unused_result__ 7406 __attribute__nonnull__(1) 7407 __attribute__nonnull__(5); 7408 #define PERL_ARGS_ASSERT_UIV_2BUF \ 7409 assert(buf); assert(peob) 7410 7411 STATIC void S_utf8_mg_len_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN ulen) 7412 __attribute__nonnull__(pTHX_1) 7413 __attribute__nonnull__(pTHX_2); 7414 #define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ 7415 assert(sv); assert(mgp) 7416 7417 STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) 7418 __attribute__nonnull__(pTHX_1) 7419 __attribute__nonnull__(pTHX_2); 7420 #define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ 7421 assert(sv); assert(mgp) 7422 7423 STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) 7424 __attribute__nonnull__(pTHX_1); 7425 #define PERL_ARGS_ASSERT_VISIT \ 7426 assert(f) 7427 7428 # if defined(PERL_OLD_COPY_ON_WRITE) 7429 STATIC void S_sv_release_COW(pTHX_ SV *sv, const char *pvx, SV *after) 7430 __attribute__nonnull__(pTHX_1) 7431 __attribute__nonnull__(pTHX_2) 7432 __attribute__nonnull__(pTHX_3); 7433 #define PERL_ARGS_ASSERT_SV_RELEASE_COW \ 7434 assert(sv); assert(pvx); assert(after) 7435 7436 # endif 7437 # if defined(USE_ITHREADS) 7438 STATIC SV* S_sv_dup_common(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 7439 __attribute__warn_unused_result__ 7440 __attribute__nonnull__(pTHX_1) 7441 __attribute__nonnull__(pTHX_2); 7442 #define PERL_ARGS_ASSERT_SV_DUP_COMMON \ 7443 assert(sstr); assert(param) 7444 7445 STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param) 7446 __attribute__nonnull__(pTHX_1) 7447 __attribute__nonnull__(pTHX_2) 7448 __attribute__nonnull__(pTHX_4); 7449 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ 7450 assert(source); assert(dest); assert(param) 7451 7452 STATIC void S_unreferenced_to_tmp_stack(pTHX_ AV *const unreferenced) 7453 __attribute__nonnull__(pTHX_1); 7454 #define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ 7455 assert(unreferenced) 7456 7457 # endif 7458 #endif 7459 #if defined(PERL_IN_SV_C) || defined (PERL_IN_OP_C) 7460 PERL_CALLCONV SV * Perl_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, I32 aindex, int subscript_type) 7461 __attribute__warn_unused_result__; 7462 7463 #endif 7464 #if defined(PERL_IN_TOKE_C) 7465 STATIC int S_ao(pTHX_ int toketype); 7466 STATIC void S_check_uni(pTHX); 7467 STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what) 7468 __attribute__nonnull__(pTHX_1) 7469 __attribute__nonnull__(pTHX_2) 7470 __attribute__nonnull__(pTHX_3); 7471 #define PERL_ARGS_ASSERT_CHECKCOMMA \ 7472 assert(s); assert(name); assert(what) 7473 7474 STATIC int S_deprecate_commaless_var_list(pTHX); 7475 STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) 7476 __attribute__warn_unused_result__ 7477 __attribute__nonnull__(pTHX_1); 7478 #define PERL_ARGS_ASSERT_FILTER_GETS \ 7479 assert(sv) 7480 7481 STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) 7482 __attribute__warn_unused_result__ 7483 __attribute__nonnull__(pTHX_1); 7484 #define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ 7485 assert(pkgname) 7486 7487 STATIC void S_force_ident(pTHX_ const char *s, int kind) 7488 __attribute__nonnull__(pTHX_1); 7489 #define PERL_ARGS_ASSERT_FORCE_IDENT \ 7490 assert(s) 7491 7492 STATIC void S_force_ident_maybe_lex(pTHX_ char pit); 7493 STATIC void S_force_next(pTHX_ I32 type); 7494 STATIC char* S_force_strict_version(pTHX_ char *s) 7495 __attribute__nonnull__(pTHX_1); 7496 #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ 7497 assert(s) 7498 7499 STATIC char* S_force_version(pTHX_ char *s, int guessing) 7500 __attribute__nonnull__(pTHX_1); 7501 #define PERL_ARGS_ASSERT_FORCE_VERSION \ 7502 assert(s) 7503 7504 STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack) 7505 __attribute__nonnull__(pTHX_1); 7506 #define PERL_ARGS_ASSERT_FORCE_WORD \ 7507 assert(start) 7508 7509 PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e) 7510 __attribute__warn_unused_result__ 7511 __attribute__nonnull__(pTHX_1) 7512 __attribute__nonnull__(pTHX_2); 7513 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ 7514 assert(s); assert(e) 7515 7516 STATIC void S_incline(pTHX_ const char *s) 7517 __attribute__nonnull__(pTHX_1); 7518 #define PERL_ARGS_ASSERT_INCLINE \ 7519 assert(s) 7520 7521 STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv) 7522 __attribute__nonnull__(pTHX_1); 7523 #define PERL_ARGS_ASSERT_INTUIT_METHOD \ 7524 assert(s) 7525 7526 STATIC int S_intuit_more(pTHX_ char *s) 7527 __attribute__nonnull__(pTHX_1); 7528 #define PERL_ARGS_ASSERT_INTUIT_MORE \ 7529 assert(s) 7530 7531 STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) 7532 __attribute__nonnull__(pTHX_3); 7533 #define PERL_ARGS_ASSERT_LOP \ 7534 assert(s) 7535 7536 PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s) 7537 __attribute__noreturn__; 7538 7539 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) 7540 __attribute__nonnull__(pTHX_3) 7541 __attribute__nonnull__(pTHX_5); 7542 #define PERL_ARGS_ASSERT_NEW_CONSTANT \ 7543 assert(key); assert(sv) 7544 7545 STATIC void S_no_op(pTHX_ const char *const what, char *s) 7546 __attribute__nonnull__(pTHX_1); 7547 #define PERL_ARGS_ASSERT_NO_OP \ 7548 assert(what) 7549 7550 STATIC void S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8) 7551 __attribute__nonnull__(pTHX_1) 7552 __attribute__nonnull__(pTHX_2) 7553 __attribute__nonnull__(pTHX_3); 7554 #define PERL_ARGS_ASSERT_PARSE_IDENT \ 7555 assert(s); assert(d); assert(e) 7556 7557 STATIC int S_pending_ident(pTHX); 7558 STATIC char* S_scan_const(pTHX_ char *start) 7559 __attribute__warn_unused_result__ 7560 __attribute__nonnull__(pTHX_1); 7561 #define PERL_ARGS_ASSERT_SCAN_CONST \ 7562 assert(start) 7563 7564 STATIC char* S_scan_formline(pTHX_ char *s) 7565 __attribute__warn_unused_result__ 7566 __attribute__nonnull__(pTHX_1); 7567 #define PERL_ARGS_ASSERT_SCAN_FORMLINE \ 7568 assert(s) 7569 7570 STATIC char* S_scan_heredoc(pTHX_ char *s) 7571 __attribute__warn_unused_result__ 7572 __attribute__nonnull__(pTHX_1); 7573 #define PERL_ARGS_ASSERT_SCAN_HEREDOC \ 7574 assert(s) 7575 7576 STATIC char* S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni) 7577 __attribute__nonnull__(pTHX_1) 7578 __attribute__nonnull__(pTHX_2); 7579 #define PERL_ARGS_ASSERT_SCAN_IDENT \ 7580 assert(s); assert(dest) 7581 7582 STATIC char* S_scan_inputsymbol(pTHX_ char *start) 7583 __attribute__warn_unused_result__ 7584 __attribute__nonnull__(pTHX_1); 7585 #define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ 7586 assert(start) 7587 7588 STATIC char* S_scan_pat(pTHX_ char *start, I32 type) 7589 __attribute__warn_unused_result__ 7590 __attribute__nonnull__(pTHX_1); 7591 #define PERL_ARGS_ASSERT_SCAN_PAT \ 7592 assert(start) 7593 7594 STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char **delimp) 7595 __attribute__warn_unused_result__ 7596 __attribute__nonnull__(pTHX_1); 7597 #define PERL_ARGS_ASSERT_SCAN_STR \ 7598 assert(start) 7599 7600 STATIC char* S_scan_subst(pTHX_ char *start) 7601 __attribute__warn_unused_result__ 7602 __attribute__nonnull__(pTHX_1); 7603 #define PERL_ARGS_ASSERT_SCAN_SUBST \ 7604 assert(start) 7605 7606 STATIC char* S_scan_trans(pTHX_ char *start) 7607 __attribute__warn_unused_result__ 7608 __attribute__nonnull__(pTHX_1); 7609 #define PERL_ARGS_ASSERT_SCAN_TRANS \ 7610 assert(start) 7611 7612 STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) 7613 __attribute__nonnull__(pTHX_1) 7614 __attribute__nonnull__(pTHX_2) 7615 __attribute__nonnull__(pTHX_5); 7616 #define PERL_ARGS_ASSERT_SCAN_WORD \ 7617 assert(s); assert(dest); assert(slp) 7618 7619 STATIC char* S_skipspace_flags(pTHX_ char *s, U32 flags) 7620 __attribute__warn_unused_result__ 7621 __attribute__nonnull__(pTHX_1); 7622 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ 7623 assert(s) 7624 7625 STATIC I32 S_sublex_done(pTHX) 7626 __attribute__warn_unused_result__; 7627 7628 STATIC I32 S_sublex_push(pTHX) 7629 __attribute__warn_unused_result__; 7630 7631 STATIC I32 S_sublex_start(pTHX) 7632 __attribute__warn_unused_result__; 7633 7634 STATIC char* S_swallow_bom(pTHX_ U8 *s) 7635 __attribute__warn_unused_result__ 7636 __attribute__nonnull__(pTHX_1); 7637 #define PERL_ARGS_ASSERT_SWALLOW_BOM \ 7638 assert(s) 7639 7640 STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) 7641 __attribute__warn_unused_result__ 7642 __attribute__nonnull__(pTHX_2); 7643 #define PERL_ARGS_ASSERT_TOKENIZE_USE \ 7644 assert(s) 7645 7646 STATIC SV* S_tokeq(pTHX_ SV *sv) 7647 __attribute__nonnull__(pTHX_1); 7648 #define PERL_ARGS_ASSERT_TOKEQ \ 7649 assert(sv) 7650 7651 STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); 7652 STATIC int S_yywarn(pTHX_ const char *const s, U32 flags) 7653 __attribute__nonnull__(pTHX_1); 7654 #define PERL_ARGS_ASSERT_YYWARN \ 7655 assert(s) 7656 7657 # if defined(PERL_MAD) 7658 STATIC void S_curmad(pTHX_ char slot, SV *sv); 7659 STATIC char* S_skipspace0(pTHX_ char *s) 7660 __attribute__nonnull__(pTHX_1); 7661 #define PERL_ARGS_ASSERT_SKIPSPACE0 \ 7662 assert(s) 7663 7664 STATIC char* S_skipspace1(pTHX_ char *s) 7665 __attribute__nonnull__(pTHX_1); 7666 #define PERL_ARGS_ASSERT_SKIPSPACE1 \ 7667 assert(s) 7668 7669 STATIC char* S_skipspace2(pTHX_ char *s, SV **sv) 7670 __attribute__nonnull__(pTHX_1); 7671 #define PERL_ARGS_ASSERT_SKIPSPACE2 \ 7672 assert(s) 7673 7674 STATIC void S_start_force(pTHX_ int where); 7675 # endif 7676 #endif 7677 #if defined(PERL_IN_UNIVERSAL_C) 7678 STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags) 7679 __attribute__nonnull__(pTHX_1) 7680 __attribute__nonnull__(pTHX_2); 7681 #define PERL_ARGS_ASSERT_ISA_LOOKUP \ 7682 assert(stash); assert(name) 7683 7684 #endif 7685 #if defined(PERL_IN_UTF8_C) 7686 STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp) 7687 __attribute__warn_unused_result__ 7688 __attribute__nonnull__(pTHX_1) 7689 __attribute__nonnull__(pTHX_3) 7690 __attribute__nonnull__(pTHX_4); 7691 #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ 7692 assert(p); assert(ustrp); assert(lenp) 7693 7694 PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) 7695 __attribute__warn_unused_result__ 7696 __attribute__nonnull__(1); 7697 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ 7698 assert(s) 7699 7700 PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname, SV* const invlist) 7701 __attribute__warn_unused_result__ 7702 __attribute__nonnull__(pTHX_1) 7703 __attribute__nonnull__(pTHX_2) 7704 __attribute__nonnull__(pTHX_3); 7705 #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ 7706 assert(p); assert(swash); assert(swashname) 7707 7708 STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) 7709 __attribute__warn_unused_result__ 7710 __attribute__nonnull__(pTHX_1); 7711 #define PERL_ARGS_ASSERT_SWATCH_GET \ 7712 assert(swash) 7713 7714 STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp) 7715 __attribute__warn_unused_result__; 7716 7717 #endif 7718 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) 7719 PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) 7720 __attribute__nonnull__(pTHX_2) 7721 __attribute__nonnull__(pTHX_3); 7722 #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ 7723 assert(p); assert(lenp) 7724 7725 #endif 7726 #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) 7727 PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags) 7728 __attribute__nonnull__(pTHX_2) 7729 __attribute__nonnull__(pTHX_3); 7730 #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ 7731 assert(p); assert(lenp) 7732 7733 #endif 7734 #if defined(PERL_IN_UTIL_C) 7735 STATIC bool S_ckwarn_common(pTHX_ U32 w); 7736 STATIC bool S_invoke_exception_hook(pTHX_ SV *ex, bool warn); 7737 STATIC SV* S_mess_alloc(pTHX); 7738 STATIC SV * S_with_queued_errors(pTHX_ SV *ex) 7739 __attribute__nonnull__(pTHX_1); 7740 #define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ 7741 assert(ex) 7742 7743 # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) 7744 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) 7745 __attribute__nonnull__(4) 7746 __attribute__nonnull__(8) 7747 __attribute__nonnull__(10); 7748 #define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ 7749 assert(type_name); assert(filename); assert(funcname) 7750 7751 # endif 7752 #endif 7753 #if defined(PERL_MAD) 7754 PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot); 7755 PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot); 7756 PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o) 7757 __attribute__nonnull__(pTHX_2); 7758 #define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \ 7759 assert(file) 7760 7761 PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) 7762 __attribute__nonnull__(pTHX_2); 7763 #define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \ 7764 assert(file) 7765 7766 PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp); 7767 PERL_CALLCONV int Perl_madlex(pTHX); 7768 PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype); 7769 PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 7770 PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen); 7771 PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) 7772 __attribute__nonnull__(pTHX_2); 7773 #define PERL_ARGS_ASSERT_NEWMADSV \ 7774 assert(sv) 7775 7776 PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); 7777 PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); 7778 PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); 7779 PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o) 7780 __attribute__nonnull__(pTHX_1); 7781 #define PERL_ARGS_ASSERT_OP_XMLDUMP \ 7782 assert(o) 7783 7784 PERL_CALLCONV OP* Perl_package(pTHX_ OP* o) 7785 __attribute__nonnull__(pTHX_1); 7786 #define PERL_ARGS_ASSERT_PACKAGE \ 7787 assert(o) 7788 7789 PERL_CALLCONV void Perl_pad_peg(const char* s) 7790 __attribute__nonnull__(1); 7791 #define PERL_ARGS_ASSERT_PAD_PEG \ 7792 assert(s) 7793 7794 PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm); 7795 PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot); 7796 PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8) 7797 __attribute__nonnull__(pTHX_1) 7798 __attribute__nonnull__(pTHX_2); 7799 #define PERL_ARGS_ASSERT_SV_CATXMLPV \ 7800 assert(dsv); assert(pv) 7801 7802 PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8) 7803 __attribute__nonnull__(pTHX_1) 7804 __attribute__nonnull__(pTHX_2); 7805 #define PERL_ARGS_ASSERT_SV_CATXMLPVN \ 7806 assert(dsv); assert(pv) 7807 7808 PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv) 7809 __attribute__nonnull__(pTHX_1) 7810 __attribute__nonnull__(pTHX_2); 7811 #define PERL_ARGS_ASSERT_SV_CATXMLSV \ 7812 assert(dsv); assert(ssv) 7813 7814 PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv) 7815 __attribute__nonnull__(pTHX_1); 7816 #define PERL_ARGS_ASSERT_SV_XMLPEEK \ 7817 assert(sv) 7818 7819 PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk) 7820 __attribute__nonnull__(pTHX_1); 7821 #define PERL_ARGS_ASSERT_TOKEN_FREE \ 7822 assert(tk) 7823 7824 PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot) 7825 __attribute__nonnull__(pTHX_1); 7826 #define PERL_ARGS_ASSERT_TOKEN_GETMAD \ 7827 assert(tk) 7828 7829 PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 7830 __attribute__nonnull__(pTHX_4); 7831 #define PERL_ARGS_ASSERT_UTILIZE \ 7832 assert(idop) 7833 7834 PERL_CALLCONV void Perl_xmldump_all(pTHX); 7835 PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl); 7836 PERL_CALLCONV void Perl_xmldump_eval(pTHX); 7837 PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv) 7838 __attribute__nonnull__(pTHX_1); 7839 #define PERL_ARGS_ASSERT_XMLDUMP_FORM \ 7840 assert(gv) 7841 7842 PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 7843 __attribute__format__(__printf__,pTHX_3,pTHX_4) 7844 __attribute__nonnull__(pTHX_2) 7845 __attribute__nonnull__(pTHX_3); 7846 #define PERL_ARGS_ASSERT_XMLDUMP_INDENT \ 7847 assert(file); assert(pat) 7848 7849 PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash) 7850 __attribute__nonnull__(pTHX_1); 7851 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \ 7852 assert(stash) 7853 7854 PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl) 7855 __attribute__nonnull__(pTHX_1); 7856 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \ 7857 assert(stash) 7858 7859 PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv) 7860 __attribute__nonnull__(pTHX_1); 7861 #define PERL_ARGS_ASSERT_XMLDUMP_SUB \ 7862 assert(gv) 7863 7864 PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl) 7865 __attribute__nonnull__(pTHX_1); 7866 #define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \ 7867 assert(gv) 7868 7869 PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) 7870 __attribute__nonnull__(pTHX_2) 7871 __attribute__nonnull__(pTHX_3); 7872 #define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \ 7873 assert(file); assert(pat) 7874 7875 #endif 7876 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) 7877 STATIC void S_pidgone(pTHX_ Pid_t pid, int status); 7878 #endif 7879 #if defined(UNLINK_ALL_VERSIONS) 7880 PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) 7881 __attribute__nonnull__(pTHX_1); 7882 #define PERL_ARGS_ASSERT_UNLNK \ 7883 assert(f) 7884 7885 #endif 7886 #if defined(USE_ITHREADS) 7887 PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv) 7888 __attribute__nonnull__(pTHX_1); 7889 #define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ 7890 assert(hv) 7891 7892 PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) 7893 __attribute__warn_unused_result__ 7894 __attribute__nonnull__(pTHX_2); 7895 #define PERL_ARGS_ASSERT_ANY_DUP \ 7896 assert(proto_perl) 7897 7898 PERL_CALLCONV void Perl_clone_params_del(CLONE_PARAMS *param) 7899 __attribute__nonnull__(1); 7900 #define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ 7901 assert(param) 7902 7903 PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter *const from, PerlInterpreter *const to) 7904 __attribute__malloc__ 7905 __attribute__warn_unused_result__ 7906 __attribute__nonnull__(1) 7907 __attribute__nonnull__(2); 7908 #define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ 7909 assert(from); assert(to) 7910 7911 PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param) 7912 __attribute__warn_unused_result__ 7913 __attribute__nonnull__(pTHX_4); 7914 #define PERL_ARGS_ASSERT_CX_DUP \ 7915 assert(param) 7916 7917 PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp, CLONE_PARAMS *const param) 7918 __attribute__warn_unused_result__ 7919 __attribute__nonnull__(pTHX_2); 7920 #define PERL_ARGS_ASSERT_DIRP_DUP \ 7921 assert(param) 7922 7923 PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param) 7924 __attribute__nonnull__(pTHX_3); 7925 #define PERL_ARGS_ASSERT_FP_DUP \ 7926 assert(param) 7927 7928 PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param) 7929 __attribute__warn_unused_result__ 7930 __attribute__nonnull__(pTHX_2); 7931 #define PERL_ARGS_ASSERT_GP_DUP \ 7932 assert(param) 7933 7934 PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param) 7935 __attribute__warn_unused_result__ 7936 __attribute__nonnull__(pTHX_3); 7937 #define PERL_ARGS_ASSERT_HE_DUP \ 7938 assert(param) 7939 7940 PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param) 7941 __attribute__warn_unused_result__ 7942 __attribute__nonnull__(pTHX_2); 7943 #define PERL_ARGS_ASSERT_HEK_DUP \ 7944 assert(param) 7945 7946 PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param) 7947 __attribute__warn_unused_result__ 7948 __attribute__nonnull__(pTHX_2); 7949 #define PERL_ARGS_ASSERT_MG_DUP \ 7950 assert(param) 7951 7952 PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param) 7953 __attribute__nonnull__(pTHX_1) 7954 __attribute__nonnull__(pTHX_2); 7955 #define PERL_ARGS_ASSERT_MRO_META_DUP \ 7956 assert(smeta); assert(param) 7957 7958 PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) 7959 __attribute__malloc__ 7960 __attribute__warn_unused_result__ 7961 __attribute__nonnull__(pTHX_3); 7962 #define PERL_ARGS_ASSERT_NEWPADOP \ 7963 assert(sv) 7964 7965 PERL_CALLCONV PADLIST * Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) 7966 __attribute__warn_unused_result__ 7967 __attribute__nonnull__(pTHX_2); 7968 #define PERL_ARGS_ASSERT_PADLIST_DUP \ 7969 assert(param) 7970 7971 PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param) 7972 __attribute__nonnull__(pTHX_2); 7973 #define PERL_ARGS_ASSERT_PARSER_DUP \ 7974 assert(param) 7975 7976 PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags) 7977 __attribute__nonnull__(1); 7978 #define PERL_ARGS_ASSERT_PERL_CLONE \ 7979 assert(proto_perl) 7980 7981 PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS* param) 7982 __attribute__nonnull__(pTHX_1) 7983 __attribute__nonnull__(pTHX_2) 7984 __attribute__nonnull__(pTHX_3); 7985 #define PERL_ARGS_ASSERT_RE_DUP_GUTS \ 7986 assert(sstr); assert(dstr); assert(param) 7987 7988 PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param) 7989 __attribute__nonnull__(pTHX_1) 7990 __attribute__nonnull__(pTHX_2); 7991 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ 7992 assert(r); assert(param) 7993 7994 PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param) 7995 __attribute__nonnull__(pTHX_1) 7996 __attribute__nonnull__(pTHX_2) 7997 __attribute__nonnull__(pTHX_3); 7998 #define PERL_ARGS_ASSERT_RVPV_DUP \ 7999 assert(dstr); assert(sstr); assert(param) 8000 8001 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param) 8002 __attribute__warn_unused_result__ 8003 __attribute__nonnull__(pTHX_2); 8004 #define PERL_ARGS_ASSERT_SI_DUP \ 8005 assert(param) 8006 8007 PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param) 8008 __attribute__malloc__ 8009 __attribute__warn_unused_result__ 8010 __attribute__nonnull__(pTHX_1) 8011 __attribute__nonnull__(pTHX_2); 8012 #define PERL_ARGS_ASSERT_SS_DUP \ 8013 assert(proto_perl); assert(param) 8014 8015 PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 8016 __attribute__warn_unused_result__ 8017 __attribute__nonnull__(pTHX_2); 8018 #define PERL_ARGS_ASSERT_SV_DUP \ 8019 assert(param) 8020 8021 PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 8022 __attribute__warn_unused_result__ 8023 __attribute__nonnull__(pTHX_2); 8024 #define PERL_ARGS_ASSERT_SV_DUP_INC \ 8025 assert(param) 8026 8027 #endif 8028 #if defined(USE_LOCALE_COLLATE) 8029 PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg) 8030 __attribute__nonnull__(pTHX_1) 8031 __attribute__nonnull__(pTHX_2); 8032 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ 8033 assert(sv); assert(mg) 8034 8035 PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen) 8036 __attribute__nonnull__(pTHX_1) 8037 __attribute__nonnull__(pTHX_3); 8038 #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ 8039 assert(s); assert(xlen) 8040 8041 /* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp) 8042 __attribute__nonnull__(pTHX_1) 8043 __attribute__nonnull__(pTHX_2); */ 8044 8045 PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags) 8046 __attribute__nonnull__(pTHX_1) 8047 __attribute__nonnull__(pTHX_2); 8048 #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ 8049 assert(sv); assert(nxp) 8050 8051 #endif 8052 #if defined(USE_PERLIO) 8053 PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); 8054 PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); 8055 PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); 8056 PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); 8057 PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); 8058 PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); 8059 PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); 8060 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); 8061 PERL_CALLCONV SSize_t Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) 8062 __attribute__warn_unused_result__; 8063 8064 PERL_CALLCONV SSize_t Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) 8065 __attribute__warn_unused_result__; 8066 8067 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); 8068 PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) 8069 __attribute__nonnull__(pTHX_2); 8070 #define PERL_ARGS_ASSERT_PERLIO_READ \ 8071 assert(vbuf) 8072 8073 PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); 8074 PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); 8075 PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); 8076 PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); 8077 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) 8078 __attribute__warn_unused_result__; 8079 8080 PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) 8081 __attribute__warn_unused_result__; 8082 8083 PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) 8084 __attribute__warn_unused_result__; 8085 8086 PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); 8087 PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 8088 __attribute__nonnull__(pTHX_2); 8089 #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ 8090 assert(vbuf) 8091 8092 PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 8093 __attribute__nonnull__(pTHX_2); 8094 #define PERL_ARGS_ASSERT_PERLIO_WRITE \ 8095 assert(vbuf) 8096 8097 #endif 8098 #if defined(WIN32) 8099 PERL_CALLCONV char* Perl_my_setlocale(pTHX_ int category, const char* locale) 8100 __attribute__pure__; 8101 8102 PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname) 8103 __attribute__noreturn__ 8104 __attribute__nonnull__(1); 8105 #define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ 8106 assert(fname) 8107 8108 #endif 8109 #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) 8110 PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp) 8111 __attribute__nonnull__(pTHX_2) 8112 __attribute__nonnull__(pTHX_3); 8113 #define PERL_ARGS_ASSERT_DO_ASPAWN \ 8114 assert(mark); assert(sp) 8115 8116 PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd) 8117 __attribute__nonnull__(pTHX_1); 8118 #define PERL_ARGS_ASSERT_DO_SPAWN \ 8119 assert(cmd) 8120 8121 PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) 8122 __attribute__nonnull__(pTHX_1); 8123 #define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ 8124 assert(cmd) 8125 8126 #endif 8127 #if defined(_MSC_VER) 8128 PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 8129 __attribute__nonnull__(pTHX_1) 8130 __attribute__nonnull__(pTHX_2); 8131 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 8132 assert(sv); assert(mg) 8133 8134 #endif 8135 #ifdef PERL_CORE 8136 # include "pp_proto.h" 8137 #endif 8138 END_EXTERN_C 8139 8140 /* ex: set ro: */ 8141