1 /* -*- mode: C; 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, 2010, 2011, 2012, 2013, 7 * 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 8 * by Larry Wall and others 9 * 10 * You may distribute under the terms of either the GNU General Public 11 * License or the Artistic License, as specified in the README file. 12 * 13 * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! 14 * This file is built by regen/embed.pl from embed.fnc, intrpvar.h, 15 * perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and 16 * regen/HeaderParser.pm. 17 * Any changes made here will be lost! 18 * 19 * Edit those files and run 'make regen_headers' to effect changes. 20 */ 21 22 START_EXTERN_C 23 PERL_CALLCONV int 24 Perl_Gv_AMupdate(pTHX_ HV *stash, bool destructing); 25 #define PERL_ARGS_ASSERT_GV_AMUPDATE \ 26 assert(stash) 27 28 PERL_CALLCONV const char * 29 Perl_PerlIO_context_layers(pTHX_ const char *mode); 30 #define PERL_ARGS_ASSERT_PERLIO_CONTEXT_LAYERS 31 32 PERL_CALLCONV int 33 Perl_PerlLIO_dup2_cloexec(pTHX_ int oldfd, int newfd) 34 __attribute__visibility__("hidden"); 35 #define PERL_ARGS_ASSERT_PERLLIO_DUP2_CLOEXEC 36 37 PERL_CALLCONV int 38 Perl_PerlLIO_dup_cloexec(pTHX_ int oldfd) 39 __attribute__warn_unused_result__ 40 __attribute__visibility__("hidden"); 41 #define PERL_ARGS_ASSERT_PERLLIO_DUP_CLOEXEC 42 43 PERL_CALLCONV int 44 Perl_PerlLIO_open3_cloexec(pTHX_ const char *file, int flag, int perm) 45 __attribute__warn_unused_result__ 46 __attribute__visibility__("hidden"); 47 #define PERL_ARGS_ASSERT_PERLLIO_OPEN3_CLOEXEC \ 48 assert(file) 49 50 PERL_CALLCONV int 51 Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) 52 __attribute__warn_unused_result__ 53 __attribute__visibility__("hidden"); 54 #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ 55 assert(file) 56 57 /* PERL_CALLCONV const XOP * 58 Perl_custom_op_xop(pTHX_ const OP *o); */ 59 60 PERL_CALLCONV const char * 61 Perl_langinfo(const nl_item item); 62 #define PERL_ARGS_ASSERT_PERL_LANGINFO 63 64 PERL_CALLCONV const char * 65 Perl_langinfo8(const nl_item item, utf8ness_t *utf8ness); 66 #define PERL_ARGS_ASSERT_PERL_LANGINFO8 \ 67 assert(utf8ness) 68 69 PERL_CALLCONV HV * 70 Perl_localeconv(pTHX); 71 #define PERL_ARGS_ASSERT_PERL_LOCALECONV 72 73 PERL_CALLCONV const char * 74 Perl_setlocale(const int category, const char *locale); 75 #define PERL_ARGS_ASSERT_PERL_SETLOCALE 76 77 PERL_CALLCONV void * 78 Perl_Slab_Alloc(pTHX_ size_t sz) 79 __attribute__warn_unused_result__; 80 #define PERL_ARGS_ASSERT_SLAB_ALLOC 81 82 PERL_CALLCONV void 83 Perl_Slab_Free(pTHX_ void *op); 84 #define PERL_ARGS_ASSERT_SLAB_FREE \ 85 assert(op) 86 87 /* PERL_CALLCONV void 88 SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ 89 90 PERL_CALLCONV const char * 91 Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format); 92 #define PERL_ARGS_ASSERT__BYTE_DUMP_STRING 93 94 PERL_CALLCONV void 95 Perl__force_out_malformed_utf8_message(pTHX_ const U8 * const p, const U8 * const e, const U32 flags, const bool die_here); 96 #define PERL_ARGS_ASSERT__FORCE_OUT_MALFORMED_UTF8_MESSAGE \ 97 assert(p); assert(e) 98 99 PERL_CALLCONV Size_t 100 Perl__inverse_folds(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) 101 __attribute__warn_unused_result__; 102 #define PERL_ARGS_ASSERT__INVERSE_FOLDS \ 103 assert(first_folds_to); assert(remaining_folds_to) 104 105 PERL_CALLCONV bool 106 Perl__is_in_locale_category(pTHX_ const bool compiling, const int category); 107 #define PERL_ARGS_ASSERT__IS_IN_LOCALE_CATEGORY 108 109 PERL_CALLCONV bool 110 Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) 111 __attribute__warn_unused_result__; 112 #define PERL_ARGS_ASSERT__IS_UNI_FOO 113 114 PERL_CALLCONV bool 115 Perl__is_uni_perl_idcont(pTHX_ UV c) 116 __attribute__warn_unused_result__; 117 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT 118 119 PERL_CALLCONV bool 120 Perl__is_uni_perl_idstart(pTHX_ UV c) 121 __attribute__warn_unused_result__; 122 #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART 123 124 PERL_CALLCONV bool 125 Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) 126 __attribute__warn_unused_result__; 127 #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ 128 assert(p); assert(e) 129 130 PERL_CALLCONV bool 131 Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) 132 __attribute__warn_unused_result__; 133 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ 134 assert(p); assert(e) 135 136 PERL_CALLCONV bool 137 Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) 138 __attribute__warn_unused_result__; 139 #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ 140 assert(p); assert(e) 141 142 PERL_CALLCONV UV 143 Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); 144 #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ 145 assert(p); assert(lenp) 146 147 PERL_CALLCONV UV 148 Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); 149 #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ 150 assert(p); assert(ustrp) 151 152 PERL_CALLCONV UV 153 Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); 154 #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ 155 assert(p); assert(ustrp) 156 157 PERL_CALLCONV UV 158 Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); 159 #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ 160 assert(p); assert(ustrp) 161 162 PERL_CALLCONV UV 163 Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); 164 #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ 165 assert(p); assert(ustrp) 166 167 PERL_CALLCONV UV 168 Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs); 169 #define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER \ 170 assert(s) 171 172 PERL_CALLCONV_NO_RET void 173 Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) 174 __attribute__noreturn__ 175 __attribute__visibility__("hidden"); 176 #define PERL_ARGS_ASSERT_ABORT_EXECUTION \ 177 assert(name) 178 179 PERL_CALLCONV LOGOP * 180 Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other) 181 __attribute__visibility__("hidden"); 182 #define PERL_ARGS_ASSERT_ALLOC_LOGOP 183 184 PERL_CALLCONV PADOFFSET 185 Perl_allocmy(pTHX_ const char * const name, const STRLEN len, const U32 flags) 186 __attribute__visibility__("hidden"); 187 #define PERL_ARGS_ASSERT_ALLOCMY \ 188 assert(name) 189 190 PERL_CALLCONV bool 191 Perl_amagic_applies(pTHX_ SV *sv, int method, int flags); 192 #define PERL_ARGS_ASSERT_AMAGIC_APPLIES \ 193 assert(sv) 194 195 PERL_CALLCONV SV * 196 Perl_amagic_call(pTHX_ SV *left, SV *right, int method, int dir); 197 #define PERL_ARGS_ASSERT_AMAGIC_CALL \ 198 assert(left); assert(right) 199 200 PERL_CALLCONV SV * 201 Perl_amagic_deref_call(pTHX_ SV *ref, int method); 202 #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ 203 assert(ref) 204 205 PERL_CALLCONV bool 206 Perl_amagic_is_enabled(pTHX_ int method) 207 __attribute__visibility__("hidden"); 208 #define PERL_ARGS_ASSERT_AMAGIC_IS_ENABLED 209 210 PERL_CALLCONV SSize_t 211 Perl_apply(pTHX_ I32 type, SV **mark, SV **sp) 212 __attribute__visibility__("hidden"); 213 #define PERL_ARGS_ASSERT_APPLY \ 214 assert(mark); assert(sp) 215 216 PERL_CALLCONV void 217 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len); 218 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ 219 assert(stashpv); assert(cv); assert(attrstr) 220 221 PERL_CALLCONV OP * 222 Perl_apply_builtin_cv_attributes(pTHX_ CV *cv, OP *attrlist); 223 #define PERL_ARGS_ASSERT_APPLY_BUILTIN_CV_ATTRIBUTES \ 224 assert(cv) 225 226 PERL_CALLCONV void 227 Perl_atfork_lock(void); 228 #define PERL_ARGS_ASSERT_ATFORK_LOCK 229 230 PERL_CALLCONV void 231 Perl_atfork_unlock(void); 232 #define PERL_ARGS_ASSERT_ATFORK_UNLOCK 233 234 PERL_CALLCONV SV ** 235 Perl_av_arylen_p(pTHX_ AV *av); 236 #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ 237 assert(av) 238 239 PERL_CALLCONV void 240 Perl_av_clear(pTHX_ AV *av); 241 #define PERL_ARGS_ASSERT_AV_CLEAR \ 242 assert(av) 243 244 PERL_CALLCONV void 245 Perl_av_create_and_push(pTHX_ AV ** const avp, SV * const val); 246 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ 247 assert(avp); assert(val) 248 249 PERL_CALLCONV SV ** 250 Perl_av_create_and_unshift_one(pTHX_ AV ** const avp, SV * const val); 251 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ 252 assert(avp); assert(val) 253 254 PERL_CALLCONV SV * 255 Perl_av_delete(pTHX_ AV *av, SSize_t key, I32 flags); 256 #define PERL_ARGS_ASSERT_AV_DELETE \ 257 assert(av) 258 259 PERL_CALLCONV void 260 Perl_av_dump(pTHX_ AV *av); 261 #define PERL_ARGS_ASSERT_AV_DUMP 262 263 PERL_CALLCONV bool 264 Perl_av_exists(pTHX_ AV *av, SSize_t key) 265 __attribute__warn_unused_result__; 266 #define PERL_ARGS_ASSERT_AV_EXISTS \ 267 assert(av) 268 269 PERL_CALLCONV void 270 Perl_av_extend(pTHX_ AV *av, SSize_t key); 271 #define PERL_ARGS_ASSERT_AV_EXTEND \ 272 assert(av) 273 274 PERL_CALLCONV void 275 Perl_av_extend_guts(pTHX_ AV *av, SSize_t key, SSize_t *maxp, SV ***allocp, SV ***arrayp) 276 __attribute__visibility__("hidden"); 277 #define PERL_ARGS_ASSERT_AV_EXTEND_GUTS \ 278 assert(maxp); assert(allocp); assert(arrayp) 279 280 PERL_CALLCONV SV ** 281 Perl_av_fetch(pTHX_ AV *av, SSize_t key, I32 lval) 282 __attribute__warn_unused_result__; 283 #define PERL_ARGS_ASSERT_AV_FETCH \ 284 assert(av) 285 286 PERL_CALLCONV void 287 Perl_av_fill(pTHX_ AV *av, SSize_t fill); 288 #define PERL_ARGS_ASSERT_AV_FILL \ 289 assert(av) 290 291 PERL_CALLCONV IV * 292 Perl_av_iter_p(pTHX_ AV *av); 293 #define PERL_ARGS_ASSERT_AV_ITER_P \ 294 assert(av) 295 296 PERL_CALLCONV SSize_t 297 Perl_av_len(pTHX_ AV *av) 298 __attribute__warn_unused_result__; 299 #define PERL_ARGS_ASSERT_AV_LEN \ 300 assert(av) 301 302 PERL_CALLCONV AV * 303 Perl_av_make(pTHX_ SSize_t size, SV **strp) 304 __attribute__warn_unused_result__; 305 #define PERL_ARGS_ASSERT_AV_MAKE \ 306 assert(strp) 307 308 PERL_CALLCONV SV * 309 Perl_av_nonelem(pTHX_ AV *av, SSize_t ix) 310 __attribute__visibility__("hidden"); 311 #define PERL_ARGS_ASSERT_AV_NONELEM \ 312 assert(av) 313 314 PERL_CALLCONV SV * 315 Perl_av_pop(pTHX_ AV *av); 316 #define PERL_ARGS_ASSERT_AV_POP \ 317 assert(av) 318 319 PERL_CALLCONV void 320 Perl_av_push(pTHX_ AV *av, SV *val); 321 #define PERL_ARGS_ASSERT_AV_PUSH \ 322 assert(av); assert(val) 323 324 PERL_CALLCONV void 325 Perl_av_reify(pTHX_ AV *av); 326 #define PERL_ARGS_ASSERT_AV_REIFY \ 327 assert(av) 328 329 PERL_CALLCONV SV * 330 Perl_av_shift(pTHX_ AV *av) 331 __attribute__warn_unused_result__; 332 #define PERL_ARGS_ASSERT_AV_SHIFT \ 333 assert(av) 334 335 PERL_CALLCONV SV ** 336 Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); 337 #define PERL_ARGS_ASSERT_AV_STORE \ 338 assert(av) 339 340 /* PERL_CALLCONV SSize_t 341 av_tindex(pTHX_ AV *av) 342 __attribute__warn_unused_result__; */ 343 344 /* PERL_CALLCONV SSize_t 345 av_top_index(pTHX_ AV *av) 346 __attribute__warn_unused_result__; */ 347 348 PERL_CALLCONV void 349 Perl_av_undef(pTHX_ AV *av); 350 #define PERL_ARGS_ASSERT_AV_UNDEF \ 351 assert(av) 352 353 PERL_CALLCONV void 354 Perl_av_unshift(pTHX_ AV *av, SSize_t num); 355 #define PERL_ARGS_ASSERT_AV_UNSHIFT \ 356 assert(av) 357 358 PERL_CALLCONV OP * 359 Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) 360 __attribute__warn_unused_result__ 361 __attribute__visibility__("hidden"); 362 #define PERL_ARGS_ASSERT_BIND_MATCH \ 363 assert(left); assert(right) 364 365 PERL_CALLCONV OP * 366 Perl_block_end(pTHX_ I32 floor, OP *seq) 367 __attribute__warn_unused_result__; 368 #define PERL_ARGS_ASSERT_BLOCK_END 369 370 PERL_CALLCONV U8 371 Perl_block_gimme(pTHX) 372 __attribute__warn_unused_result__; 373 #define PERL_ARGS_ASSERT_BLOCK_GIMME 374 375 PERL_CALLCONV int 376 Perl_block_start(pTHX_ int full) 377 __attribute__warn_unused_result__; 378 #define PERL_ARGS_ASSERT_BLOCK_START 379 380 PERL_CALLCONV void 381 Perl_blockhook_register(pTHX_ BHK *hk); 382 #define PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER \ 383 assert(hk) 384 385 PERL_CALLCONV void 386 Perl_boot_core_PerlIO(pTHX) 387 __attribute__visibility__("hidden"); 388 #define PERL_ARGS_ASSERT_BOOT_CORE_PERLIO 389 390 PERL_CALLCONV void 391 Perl_boot_core_UNIVERSAL(pTHX) 392 __attribute__visibility__("hidden"); 393 #define PERL_ARGS_ASSERT_BOOT_CORE_UNIVERSAL 394 395 PERL_CALLCONV void 396 Perl_boot_core_builtin(pTHX) 397 __attribute__visibility__("hidden"); 398 #define PERL_ARGS_ASSERT_BOOT_CORE_BUILTIN 399 400 PERL_CALLCONV void 401 Perl_boot_core_mro(pTHX) 402 __attribute__visibility__("hidden"); 403 #define PERL_ARGS_ASSERT_BOOT_CORE_MRO 404 405 PERL_CALLCONV OP * 406 Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) 407 __attribute__visibility__("hidden"); 408 #define PERL_ARGS_ASSERT_BUILD_INFIX_PLUGIN \ 409 assert(lhs); assert(rhs); assert(tokendata) 410 411 PERL_CALLCONV int 412 Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); 413 #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ 414 assert(b); assert(u) 415 416 PERL_CALLCONV U8 * 417 Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p); 418 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ 419 assert(s); assert(lenp); assert(is_utf8p) 420 421 PERL_CALLCONV U8 * 422 Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8 **first_unconverted); 423 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8_LOC \ 424 assert(s); assert(lenp); assert(is_utf8p) 425 426 PERL_CALLCONV U8 * 427 Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp); 428 #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ 429 assert(s); assert(lenp) 430 431 PERL_CALLCONV SSize_t 432 Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv); 433 #define PERL_ARGS_ASSERT_CALL_ARGV \ 434 assert(sub_name); assert(argv) 435 436 PERL_CALLCONV void 437 Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); 438 #define PERL_ARGS_ASSERT_CALL_ATEXIT 439 440 PERL_CALLCONV void 441 Perl_call_list(pTHX_ I32 oldscope, AV *paramList); 442 #define PERL_ARGS_ASSERT_CALL_LIST \ 443 assert(paramList) 444 445 PERL_CALLCONV SSize_t 446 Perl_call_method(pTHX_ const char *methname, I32 flags); 447 #define PERL_ARGS_ASSERT_CALL_METHOD \ 448 assert(methname) 449 450 PERL_CALLCONV SSize_t 451 Perl_call_pv(pTHX_ const char *sub_name, I32 flags); 452 #define PERL_ARGS_ASSERT_CALL_PV \ 453 assert(sub_name) 454 455 PERL_CALLCONV SSize_t 456 Perl_call_sv(pTHX_ SV *sv, I32 flags); 457 #define PERL_ARGS_ASSERT_CALL_SV \ 458 assert(sv) 459 460 PERL_CALLCONV const PERL_CONTEXT * 461 Perl_caller_cx(pTHX_ I32 level, const PERL_CONTEXT **dbcxp); 462 #define PERL_ARGS_ASSERT_CALLER_CX 463 464 PERL_CALLCONV Malloc_t 465 Perl_calloc(MEM_SIZE elements, MEM_SIZE size) 466 __attribute__malloc__ 467 __attribute__warn_unused_result__; 468 #define PERL_ARGS_ASSERT_CALLOC 469 470 PERL_CALLCONV bool 471 Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t *statbufp) 472 __attribute__warn_unused_result__ 473 __attribute__visibility__("hidden"); 474 #define PERL_ARGS_ASSERT_CANDO \ 475 assert(statbufp) 476 477 PERL_CALLCONV I32 478 Perl_cast_i32(NV f) 479 __attribute__warn_unused_result__; 480 #define PERL_ARGS_ASSERT_CAST_I32 481 482 PERL_CALLCONV IV 483 Perl_cast_iv(NV f) 484 __attribute__warn_unused_result__; 485 #define PERL_ARGS_ASSERT_CAST_IV 486 487 PERL_CALLCONV U32 488 Perl_cast_ulong(NV f) 489 __attribute__warn_unused_result__; 490 #define PERL_ARGS_ASSERT_CAST_ULONG 491 492 PERL_CALLCONV UV 493 Perl_cast_uv(NV f) 494 __attribute__warn_unused_result__; 495 #define PERL_ARGS_ASSERT_CAST_UV 496 497 PERL_CALLCONV bool 498 Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) 499 __attribute__visibility__("hidden"); 500 #define PERL_ARGS_ASSERT_CHECK_UTF8_PRINT \ 501 assert(s) 502 503 PERL_CALLCONV OP * 504 Perl_ck_entersub_args_core(pTHX_ OP *entersubop, GV *namegv, SV *protosv) 505 __attribute__visibility__("hidden"); 506 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_CORE \ 507 assert(entersubop); assert(namegv); assert(protosv) 508 509 PERL_CALLCONV OP * 510 Perl_ck_entersub_args_list(pTHX_ OP *entersubop); 511 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_LIST \ 512 assert(entersubop) 513 514 PERL_CALLCONV OP * 515 Perl_ck_entersub_args_proto(pTHX_ OP *entersubop, GV *namegv, SV *protosv); 516 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO \ 517 assert(entersubop); assert(namegv); assert(protosv) 518 519 PERL_CALLCONV OP * 520 Perl_ck_entersub_args_proto_or_list(pTHX_ OP *entersubop, GV *namegv, SV *protosv); 521 #define PERL_ARGS_ASSERT_CK_ENTERSUB_ARGS_PROTO_OR_LIST \ 522 assert(entersubop); assert(namegv); assert(protosv) 523 524 PERL_CALLCONV void 525 Perl_ck_warner(pTHX_ U32 err, const char *pat, ...) 526 __attribute__format__(__printf__,pTHX_2,pTHX_3); 527 #define PERL_ARGS_ASSERT_CK_WARNER \ 528 assert(pat) 529 530 PERL_CALLCONV void 531 Perl_ck_warner_d(pTHX_ U32 err, const char *pat, ...) 532 __attribute__format__(__printf__,pTHX_2,pTHX_3); 533 #define PERL_ARGS_ASSERT_CK_WARNER_D \ 534 assert(pat) 535 536 PERL_CALLCONV bool 537 Perl_ckwarn(pTHX_ U32 w) 538 __attribute__warn_unused_result__ 539 __attribute__pure__; 540 #define PERL_ARGS_ASSERT_CKWARN 541 542 PERL_CALLCONV bool 543 Perl_ckwarn_d(pTHX_ U32 w) 544 __attribute__warn_unused_result__ 545 __attribute__pure__; 546 #define PERL_ARGS_ASSERT_CKWARN_D 547 548 PERL_CALLCONV void 549 Perl_clear_defarray(pTHX_ AV *av, bool abandon); 550 #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ 551 assert(av) 552 553 PERL_CALLCONV const COP * 554 Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext) 555 __attribute__visibility__("hidden"); 556 #define PERL_ARGS_ASSERT_CLOSEST_COP \ 557 assert(cop) 558 559 PERL_CALLCONV OP * 560 Perl_cmpchain_extend(pTHX_ I32 type, OP *ch, OP *right) 561 __attribute__warn_unused_result__ 562 __attribute__visibility__("hidden"); 563 #define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND \ 564 assert(ch) 565 566 PERL_CALLCONV OP * 567 Perl_cmpchain_finish(pTHX_ OP *ch) 568 __attribute__warn_unused_result__ 569 __attribute__visibility__("hidden"); 570 #define PERL_ARGS_ASSERT_CMPCHAIN_FINISH \ 571 assert(ch) 572 573 PERL_CALLCONV OP * 574 Perl_cmpchain_start(pTHX_ I32 type, OP *left, OP *right) 575 __attribute__warn_unused_result__ 576 __attribute__visibility__("hidden"); 577 #define PERL_ARGS_ASSERT_CMPCHAIN_START 578 579 PERL_CALLCONV const char * 580 Perl_cntrl_to_mnemonic(const U8 c) 581 __attribute__warn_unused_result__; 582 #define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC 583 584 PERL_CALLCONV const char * 585 Perl_cop_fetch_label(pTHX_ COP * const cop, STRLEN *len, U32 *flags); 586 #define PERL_ARGS_ASSERT_COP_FETCH_LABEL \ 587 assert(cop) 588 589 PERL_CALLCONV void 590 Perl_cop_store_label(pTHX_ COP * const cop, const char *label, STRLEN len, U32 flags); 591 #define PERL_ARGS_ASSERT_COP_STORE_LABEL \ 592 assert(cop); assert(label) 593 594 PERL_CALLCONV SV * 595 Perl_core_prototype(pTHX_ SV *sv, const char *name, const int code, int * const opnum) 596 __attribute__visibility__("hidden"); 597 #define PERL_ARGS_ASSERT_CORE_PROTOTYPE \ 598 assert(name) 599 600 PERL_CALLCONV OP * 601 Perl_coresub_op(pTHX_ SV * const coreargssv, const int code, const int opnum) 602 __attribute__visibility__("hidden"); 603 #define PERL_ARGS_ASSERT_CORESUB_OP \ 604 assert(coreargssv) 605 606 PERL_CALLCONV void 607 Perl_create_eval_scope(pTHX_ OP *retop, SV **sp, U32 flags) 608 __attribute__visibility__("hidden"); 609 #define PERL_ARGS_ASSERT_CREATE_EVAL_SCOPE \ 610 assert(sp) 611 612 PERL_CALLCONV_NO_RET void 613 Perl_croak(pTHX_ const char *pat, ...) 614 __attribute__noreturn__ 615 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 616 #define PERL_ARGS_ASSERT_CROAK 617 618 PERL_CALLCONV_NO_RET void 619 Perl_croak_caller(const char *pat, ...) 620 __attribute__noreturn__ 621 __attribute__visibility__("hidden") 622 __attribute__format__null_ok__(__printf__,1,2); 623 #define PERL_ARGS_ASSERT_CROAK_CALLER 624 625 PERL_STATIC_NO_RET void 626 Perl_croak_memory_wrap(void) 627 __attribute__noreturn__; 628 #define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP 629 630 PERL_CALLCONV_NO_RET void 631 Perl_croak_no_mem(void) 632 __attribute__noreturn__ 633 __attribute__visibility__("hidden"); 634 #define PERL_ARGS_ASSERT_CROAK_NO_MEM 635 636 PERL_CALLCONV_NO_RET void 637 Perl_croak_no_mem_ext(const char *context, STRLEN len) 638 __attribute__noreturn__ 639 __attribute__visibility__("hidden"); 640 #define PERL_ARGS_ASSERT_CROAK_NO_MEM_EXT \ 641 assert(context) 642 643 PERL_CALLCONV_NO_RET void 644 Perl_croak_no_modify(void) 645 __attribute__noreturn__; 646 #define PERL_ARGS_ASSERT_CROAK_NO_MODIFY 647 648 PERL_CALLCONV_NO_RET void 649 Perl_croak_popstack(void) 650 __attribute__noreturn__; 651 #define PERL_ARGS_ASSERT_CROAK_POPSTACK 652 653 PERL_CALLCONV_NO_RET void 654 Perl_croak_sv(pTHX_ SV *baseex) 655 __attribute__noreturn__; 656 #define PERL_ARGS_ASSERT_CROAK_SV \ 657 assert(baseex) 658 659 PERL_CALLCONV_NO_RET void 660 Perl_croak_xs_usage(const CV * const cv, const char * const params) 661 __attribute__noreturn__; 662 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ 663 assert(cv); assert(params) 664 665 PERL_CALLCONV Signal_t 666 Perl_csighandler1(int sig); 667 #define PERL_ARGS_ASSERT_CSIGHANDLER1 668 669 PERL_CALLCONV Signal_t 670 Perl_csighandler3(int sig, Siginfo_t *info, void *uap); 671 #define PERL_ARGS_ASSERT_CSIGHANDLER3 672 673 PERL_CALLCONV regexp_engine const * 674 Perl_current_re_engine(pTHX); 675 #define PERL_ARGS_ASSERT_CURRENT_RE_ENGINE 676 677 PERL_CALLCONV XOPRETANY 678 Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) 679 __attribute__warn_unused_result__; 680 #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ 681 assert(o) 682 683 PERL_CALLCONV void 684 Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); 685 #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ 686 assert(ppaddr); assert(xop) 687 688 PERL_CALLCONV void 689 Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p, const STRLEN len, const U32 flags); 690 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ 691 assert(cv) 692 693 PERL_CALLCONV CV * 694 Perl_cv_clone(pTHX_ CV *proto); 695 #define PERL_ARGS_ASSERT_CV_CLONE \ 696 assert(proto) 697 698 PERL_CALLCONV CV * 699 Perl_cv_clone_into(pTHX_ CV *proto, CV *target) 700 __attribute__visibility__("hidden"); 701 #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ 702 assert(proto); assert(target) 703 704 PERL_CALLCONV SV * 705 Perl_cv_const_sv(const CV * const cv) 706 __attribute__warn_unused_result__; 707 #define PERL_ARGS_ASSERT_CV_CONST_SV 708 709 PERL_CALLCONV SV * 710 Perl_cv_const_sv_or_av(const CV * const cv) 711 __attribute__warn_unused_result__ 712 __attribute__visibility__("hidden"); 713 #define PERL_ARGS_ASSERT_CV_CONST_SV_OR_AV 714 715 PERL_CALLCONV void 716 Perl_cv_forget_slab(pTHX_ CV *cv) 717 __attribute__visibility__("hidden"); 718 #define PERL_ARGS_ASSERT_CV_FORGET_SLAB 719 720 PERL_CALLCONV void 721 Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p); 722 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ 723 assert(cv); assert(ckfun_p); assert(ckobj_p) 724 725 PERL_CALLCONV void 726 Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags, Perl_call_checker *ckfun_p, SV **ckobj_p, U32 *ckflags_p); 727 #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER_FLAGS \ 728 assert(cv); assert(ckfun_p); assert(ckobj_p); assert(ckflags_p) 729 730 PERL_CALLCONV SV * 731 Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags); 732 #define PERL_ARGS_ASSERT_CV_NAME \ 733 assert(cv) 734 735 PERL_CALLCONV void 736 Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj); 737 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER \ 738 assert(cv); assert(ckfun); assert(ckobj) 739 740 PERL_CALLCONV void 741 Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj, U32 ckflags); 742 #define PERL_ARGS_ASSERT_CV_SET_CALL_CHECKER_FLAGS \ 743 assert(cv); assert(ckfun); assert(ckobj) 744 745 PERL_CALLCONV void 746 Perl_cv_undef(pTHX_ CV *cv); 747 #define PERL_ARGS_ASSERT_CV_UNDEF \ 748 assert(cv) 749 750 PERL_CALLCONV void 751 Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags) 752 __attribute__visibility__("hidden"); 753 #define PERL_ARGS_ASSERT_CV_UNDEF_FLAGS \ 754 assert(cv) 755 756 PERL_CALLCONV GV * 757 Perl_cvgv_from_hek(pTHX_ CV *cv); 758 #define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ 759 assert(cv) 760 761 PERL_CALLCONV void 762 Perl_cvgv_set(pTHX_ CV *cv, GV *gv); 763 #define PERL_ARGS_ASSERT_CVGV_SET \ 764 assert(cv) 765 766 PERL_CALLCONV void 767 Perl_cvstash_set(pTHX_ CV *cv, HV *stash); 768 #define PERL_ARGS_ASSERT_CVSTASH_SET \ 769 assert(cv) 770 771 PERL_CALLCONV void 772 Perl_cx_dump(pTHX_ PERL_CONTEXT *cx); 773 #define PERL_ARGS_ASSERT_CX_DUMP \ 774 assert(cx) 775 776 PERL_CALLCONV I32 777 Perl_cxinc(pTHX) 778 __attribute__warn_unused_result__; 779 #define PERL_ARGS_ASSERT_CXINC 780 781 PERL_CALLCONV void 782 Perl_deb(pTHX_ const char *pat, ...) 783 __attribute__format__(__printf__,pTHX_1,pTHX_2); 784 #define PERL_ARGS_ASSERT_DEB \ 785 assert(pat) 786 787 PERL_CALLCONV void 788 Perl_deb_stack_all(pTHX) 789 __attribute__visibility__("hidden"); 790 #define PERL_ARGS_ASSERT_DEB_STACK_ALL 791 792 PERL_CALLCONV I32 793 Perl_debop(pTHX_ const OP *o); 794 #define PERL_ARGS_ASSERT_DEBOP \ 795 assert(o) 796 797 PERL_CALLCONV void 798 Perl_debprofdump(pTHX); 799 #define PERL_ARGS_ASSERT_DEBPROFDUMP 800 801 PERL_CALLCONV I32 802 Perl_debstack(pTHX); 803 #define PERL_ARGS_ASSERT_DEBSTACK 804 805 PERL_CALLCONV I32 806 Perl_debstackptrs(pTHX); 807 #define PERL_ARGS_ASSERT_DEBSTACKPTRS 808 809 PERL_CALLCONV void 810 Perl_debug_hash_seed(pTHX_ bool via_debug_h) 811 __attribute__visibility__("hidden"); 812 #define PERL_ARGS_ASSERT_DEBUG_HASH_SEED 813 814 PERL_CALLCONV SV * 815 Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg) 816 __attribute__warn_unused_result__ 817 __attribute__visibility__("hidden"); 818 #define PERL_ARGS_ASSERT_DEFELEM_TARGET \ 819 assert(sv) 820 821 PERL_CALLCONV void 822 Perl_delete_eval_scope(pTHX) 823 __attribute__visibility__("hidden"); 824 #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE 825 826 PERL_CALLCONV char * 827 Perl_delimcpy(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); 828 #define PERL_ARGS_ASSERT_DELIMCPY \ 829 assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen) 830 831 PERL_CALLCONV char * 832 Perl_delimcpy_no_escape(char *to, const char *to_end, const char *from, const char *from_end, const int delim, I32 *retlen); 833 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE \ 834 assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen) 835 836 PERL_CALLCONV void 837 Perl_despatch_signals(pTHX); 838 #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS 839 840 PERL_CALLCONV_NO_RET OP * 841 Perl_die(pTHX_ const char *pat, ...) 842 __attribute__noreturn__ 843 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 844 #define PERL_ARGS_ASSERT_DIE 845 846 PERL_CALLCONV_NO_RET OP * 847 Perl_die_sv(pTHX_ SV *baseex) 848 __attribute__noreturn__; 849 #define PERL_ARGS_ASSERT_DIE_SV \ 850 assert(baseex) 851 852 PERL_CALLCONV_NO_RET void 853 Perl_die_unwind(pTHX_ SV *msv) 854 __attribute__noreturn__ 855 __attribute__visibility__("hidden"); 856 #define PERL_ARGS_ASSERT_DIE_UNWIND \ 857 assert(msv) 858 859 PERL_CALLCONV bool 860 Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) 861 __attribute__visibility__("hidden"); 862 #define PERL_ARGS_ASSERT_DO_AEXEC5 \ 863 assert(mark); assert(sp) 864 865 PERL_CALLCONV bool 866 Perl_do_close(pTHX_ GV *gv, bool is_explicit); 867 #define PERL_ARGS_ASSERT_DO_CLOSE 868 869 PERL_CALLCONV void 870 Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) 871 __attribute__visibility__("hidden"); 872 #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ 873 assert(file) 874 875 PERL_CALLCONV bool 876 Perl_do_eof(pTHX_ GV *gv) 877 __attribute__visibility__("hidden"); 878 #define PERL_ARGS_ASSERT_DO_EOF \ 879 assert(gv) 880 881 PERL_CALLCONV void 882 Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); 883 #define PERL_ARGS_ASSERT_DO_GV_DUMP \ 884 assert(file); assert(name) 885 886 PERL_CALLCONV void 887 Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv); 888 #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ 889 assert(file); assert(name) 890 891 PERL_CALLCONV void 892 Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv); 893 #define PERL_ARGS_ASSERT_DO_HV_DUMP \ 894 assert(file); assert(name) 895 896 PERL_CALLCONV void 897 Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp); 898 #define PERL_ARGS_ASSERT_DO_JOIN \ 899 assert(sv); assert(delim); assert(mark); assert(sp) 900 901 PERL_CALLCONV void 902 Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); 903 #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ 904 assert(file) 905 906 PERL_CALLCONV I32 907 Perl_do_ncmp(pTHX_ SV * const left, SV * const right) 908 __attribute__warn_unused_result__ 909 __attribute__visibility__("hidden"); 910 #define PERL_ARGS_ASSERT_DO_NCMP \ 911 assert(left); assert(right) 912 913 PERL_CALLCONV void 914 Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); 915 #define PERL_ARGS_ASSERT_DO_OP_DUMP \ 916 assert(file) 917 918 PERL_CALLCONV bool 919 Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) 920 __attribute__visibility__("hidden"); 921 #define PERL_ARGS_ASSERT_DO_OPEN6 \ 922 assert(gv); assert(oname) 923 924 PERL_CALLCONV bool 925 Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp) 926 __attribute__visibility__("hidden"); 927 #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ 928 assert(gv); assert(oname) 929 930 PERL_CALLCONV bool 931 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); 932 #define PERL_ARGS_ASSERT_DO_OPENN \ 933 assert(gv); assert(oname) 934 935 PERL_CALLCONV void 936 Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm); 937 #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ 938 assert(file) 939 940 PERL_CALLCONV bool 941 Perl_do_print(pTHX_ SV *sv, PerlIO *fp) 942 __attribute__visibility__("hidden"); 943 #define PERL_ARGS_ASSERT_DO_PRINT \ 944 assert(fp) 945 946 PERL_CALLCONV OP * 947 Perl_do_readline(pTHX) 948 __attribute__warn_unused_result__ 949 __attribute__visibility__("hidden"); 950 #define PERL_ARGS_ASSERT_DO_READLINE 951 952 PERL_CALLCONV bool 953 Perl_do_seek(pTHX_ GV *gv, Off_t pos, int whence) 954 __attribute__visibility__("hidden"); 955 #define PERL_ARGS_ASSERT_DO_SEEK 956 957 PERL_CALLCONV void 958 Perl_do_sprintf(pTHX_ SV *sv, SSize_t len, SV **sarg); 959 #define PERL_ARGS_ASSERT_DO_SPRINTF \ 960 assert(sv); assert(sarg) 961 962 PERL_CALLCONV void 963 Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); 964 #define PERL_ARGS_ASSERT_DO_SV_DUMP \ 965 assert(file) 966 967 PERL_CALLCONV Off_t 968 Perl_do_sysseek(pTHX_ GV *gv, Off_t pos, int whence) 969 __attribute__visibility__("hidden"); 970 #define PERL_ARGS_ASSERT_DO_SYSSEEK \ 971 assert(gv) 972 973 PERL_CALLCONV Off_t 974 Perl_do_tell(pTHX_ GV *gv) 975 __attribute__warn_unused_result__ 976 __attribute__visibility__("hidden"); 977 #define PERL_ARGS_ASSERT_DO_TELL \ 978 assert(gv) 979 980 PERL_CALLCONV Size_t 981 Perl_do_trans(pTHX_ SV *sv) 982 __attribute__visibility__("hidden"); 983 #define PERL_ARGS_ASSERT_DO_TRANS \ 984 assert(sv) 985 986 PERL_CALLCONV I16 987 Perl_do_uniprop_match(const char * const key, const U16 key_len) 988 __attribute__warn_unused_result__; 989 #define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH \ 990 assert(key) 991 992 PERL_CALLCONV UV 993 Perl_do_vecget(pTHX_ SV *sv, STRLEN offset, int size) 994 __attribute__visibility__("hidden"); 995 #define PERL_ARGS_ASSERT_DO_VECGET \ 996 assert(sv) 997 998 PERL_CALLCONV void 999 Perl_do_vecset(pTHX_ SV *sv) 1000 __attribute__visibility__("hidden"); 1001 #define PERL_ARGS_ASSERT_DO_VECSET \ 1002 assert(sv) 1003 1004 PERL_CALLCONV void 1005 Perl_do_vop(pTHX_ I32 optype, SV *sv, SV *left, SV *right) 1006 __attribute__visibility__("hidden"); 1007 #define PERL_ARGS_ASSERT_DO_VOP \ 1008 assert(sv); assert(left); assert(right) 1009 1010 PERL_CALLCONV OP * 1011 Perl_dofile(pTHX_ OP *term, I32 force_builtin) 1012 __attribute__visibility__("hidden"); 1013 #define PERL_ARGS_ASSERT_DOFILE \ 1014 assert(term) 1015 1016 PERL_CALLCONV bool 1017 Perl_doing_taint(int argc, char **argv, char **env) 1018 __attribute__warn_unused_result__; 1019 #define PERL_ARGS_ASSERT_DOING_TAINT 1020 1021 PERL_CALLCONV OP * 1022 Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref); 1023 #define PERL_ARGS_ASSERT_DOREF \ 1024 assert(o) 1025 1026 PERL_CALLCONV void 1027 Perl_dounwind(pTHX_ I32 cxix); 1028 #define PERL_ARGS_ASSERT_DOUNWIND 1029 1030 PERL_CALLCONV U8 1031 Perl_dowantarray(pTHX) 1032 __attribute__deprecated__ 1033 __attribute__warn_unused_result__; 1034 #define PERL_ARGS_ASSERT_DOWANTARRAY 1035 1036 PERL_CALLCONV void 1037 Perl_drand48_init_r(perl_drand48_t *random_state, U32 seed); 1038 #define PERL_ARGS_ASSERT_DRAND48_INIT_R \ 1039 assert(random_state) 1040 1041 PERL_CALLCONV double 1042 Perl_drand48_r(perl_drand48_t *random_state); 1043 #define PERL_ARGS_ASSERT_DRAND48_R \ 1044 assert(random_state) 1045 1046 PERL_CALLCONV void 1047 Perl_dump_all(pTHX); 1048 #define PERL_ARGS_ASSERT_DUMP_ALL 1049 1050 PERL_CALLCONV void 1051 Perl_dump_all_perl(pTHX_ bool justperl) 1052 __attribute__visibility__("hidden"); 1053 #define PERL_ARGS_ASSERT_DUMP_ALL_PERL 1054 1055 PERL_CALLCONV void 1056 Perl_dump_eval(pTHX); 1057 #define PERL_ARGS_ASSERT_DUMP_EVAL 1058 1059 PERL_CALLCONV void 1060 Perl_dump_form(pTHX_ const GV *gv); 1061 #define PERL_ARGS_ASSERT_DUMP_FORM \ 1062 assert(gv) 1063 1064 PERL_CALLCONV void 1065 Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char *pat, ...) 1066 __attribute__format__(__printf__,pTHX_3,pTHX_4); 1067 #define PERL_ARGS_ASSERT_DUMP_INDENT \ 1068 assert(file); assert(pat) 1069 1070 PERL_CALLCONV void 1071 Perl_dump_packsubs(pTHX_ const HV *stash); 1072 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ 1073 assert(stash) 1074 1075 PERL_CALLCONV void 1076 Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl) 1077 __attribute__visibility__("hidden"); 1078 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ 1079 assert(stash) 1080 1081 PERL_CALLCONV void 1082 Perl_dump_sub(pTHX_ const GV *gv); 1083 #define PERL_ARGS_ASSERT_DUMP_SUB \ 1084 assert(gv) 1085 1086 PERL_CALLCONV void 1087 Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl) 1088 __attribute__visibility__("hidden"); 1089 #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ 1090 assert(gv) 1091 1092 PERL_CALLCONV void 1093 Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char *pat, va_list *args); 1094 #define PERL_ARGS_ASSERT_DUMP_VINDENT \ 1095 assert(file); assert(pat) 1096 1097 PERL_CALLCONV char * 1098 Perl_dup_warnings(pTHX_ char *warnings); 1099 #define PERL_ARGS_ASSERT_DUP_WARNINGS 1100 1101 PERL_CALLCONV void 1102 Perl_emulate_cop_io(pTHX_ const COP * const c, SV * const sv); 1103 #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ 1104 assert(c); assert(sv) 1105 1106 PERL_CALLCONV SV * 1107 Perl_eval_pv(pTHX_ const char *p, I32 croak_on_error); 1108 #define PERL_ARGS_ASSERT_EVAL_PV \ 1109 assert(p) 1110 1111 PERL_CALLCONV SSize_t 1112 Perl_eval_sv(pTHX_ SV *sv, I32 flags); 1113 #define PERL_ARGS_ASSERT_EVAL_SV \ 1114 assert(sv) 1115 1116 PERL_CALLCONV void 1117 Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) 1118 __attribute__format__(__printf__,pTHX_2,pTHX_3); 1119 #define PERL_ARGS_ASSERT_FATAL_WARNER \ 1120 assert(pat) 1121 1122 PERL_CALLCONV void 1123 Perl_fbm_compile(pTHX_ SV *sv, U32 flags); 1124 #define PERL_ARGS_ASSERT_FBM_COMPILE \ 1125 assert(sv) 1126 1127 PERL_CALLCONV char * 1128 Perl_fbm_instr(pTHX_ unsigned char *big, unsigned char *bigend, SV *littlestr, U32 flags) 1129 __attribute__warn_unused_result__; 1130 #define PERL_ARGS_ASSERT_FBM_INSTR \ 1131 assert(big); assert(bigend); assert(littlestr) 1132 1133 PERL_CALLCONV SV * 1134 Perl_filter_add(pTHX_ filter_t funcp, SV *datasv); 1135 #define PERL_ARGS_ASSERT_FILTER_ADD 1136 1137 PERL_CALLCONV void 1138 Perl_filter_del(pTHX_ filter_t funcp); 1139 #define PERL_ARGS_ASSERT_FILTER_DEL \ 1140 assert(funcp) 1141 1142 PERL_CALLCONV I32 1143 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) 1144 __attribute__warn_unused_result__; 1145 #define PERL_ARGS_ASSERT_FILTER_READ \ 1146 assert(buf_sv) 1147 1148 PERL_CALLCONV CV * 1149 Perl_find_lexical_cv(pTHX_ PADOFFSET off) 1150 __attribute__visibility__("hidden"); 1151 #define PERL_ARGS_ASSERT_FIND_LEXICAL_CV 1152 1153 PERL_CALLCONV CV * 1154 Perl_find_runcv(pTHX_ U32 *db_seqp) 1155 __attribute__warn_unused_result__; 1156 #define PERL_ARGS_ASSERT_FIND_RUNCV 1157 1158 PERL_CALLCONV CV * 1159 Perl_find_runcv_where(pTHX_ U8 cond, IV arg, U32 *db_seqp) 1160 __attribute__warn_unused_result__ 1161 __attribute__visibility__("hidden"); 1162 #define PERL_ARGS_ASSERT_FIND_RUNCV_WHERE 1163 1164 PERL_CALLCONV SV * 1165 Perl_find_rundefsv(pTHX); 1166 #define PERL_ARGS_ASSERT_FIND_RUNDEFSV 1167 1168 PERL_CALLCONV char * 1169 Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const * const search_ext, I32 flags) 1170 __attribute__visibility__("hidden"); 1171 #define PERL_ARGS_ASSERT_FIND_SCRIPT \ 1172 assert(scriptname) 1173 1174 /* PERL_CALLCONV I32 1175 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ 1176 1177 PERL_CALLCONV I32 1178 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); 1179 #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ 1180 assert(s1); assert(s2) 1181 1182 PERL_CALLCONV void 1183 Perl_forbid_outofblock_ops(pTHX_ OP *o, const char *blockname); 1184 #define PERL_ARGS_ASSERT_FORBID_OUTOFBLOCK_OPS \ 1185 assert(o); assert(blockname) 1186 1187 PERL_CALLCONV void 1188 Perl_force_locale_unlock(pTHX) 1189 __attribute__visibility__("hidden"); 1190 #define PERL_ARGS_ASSERT_FORCE_LOCALE_UNLOCK 1191 1192 PERL_CALLCONV char * 1193 Perl_form(pTHX_ const char *pat, ...) 1194 __attribute__format__(__printf__,pTHX_1,pTHX_2); 1195 #define PERL_ARGS_ASSERT_FORM \ 1196 assert(pat) 1197 1198 PERL_CALLCONV void 1199 Perl_free_tied_hv_pool(pTHX) 1200 __attribute__visibility__("hidden"); 1201 #define PERL_ARGS_ASSERT_FREE_TIED_HV_POOL 1202 1203 PERL_CALLCONV void 1204 Perl_free_tmps(pTHX); 1205 #define PERL_ARGS_ASSERT_FREE_TMPS 1206 1207 PERL_CALLCONV SV * 1208 Perl_get_and_check_backslash_N_name(pTHX_ const char *s, const char *e, const bool is_utf8, const char **error_msg) 1209 __attribute__warn_unused_result__; 1210 #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ 1211 assert(s); assert(e); assert(error_msg) 1212 1213 PERL_CALLCONV AV * 1214 Perl_get_av(pTHX_ const char *name, I32 flags); 1215 #define PERL_ARGS_ASSERT_GET_AV \ 1216 assert(name) 1217 1218 PERL_CALLCONV CV * 1219 Perl_get_cv(pTHX_ const char *name, I32 flags); 1220 #define PERL_ARGS_ASSERT_GET_CV \ 1221 assert(name) 1222 1223 PERL_CALLCONV CV * 1224 Perl_get_cvn_flags(pTHX_ const char *name, STRLEN len, I32 flags); 1225 #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ 1226 assert(name) 1227 1228 PERL_CALLCONV void 1229 Perl_get_db_sub(pTHX_ SV **svp, CV *cv); 1230 #define PERL_ARGS_ASSERT_GET_DB_SUB \ 1231 assert(cv) 1232 1233 PERL_CALLCONV const char * 1234 Perl_get_deprecated_property_msg(const Size_t warning_offset) 1235 __attribute__warn_unused_result__; 1236 #define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG 1237 1238 PERL_CALLCONV int 1239 Perl_get_extended_os_errno(void) 1240 __attribute__visibility__("hidden"); 1241 #define PERL_ARGS_ASSERT_GET_EXTENDED_OS_ERRNO 1242 1243 PERL_CALLCONV void 1244 Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer) 1245 __attribute__visibility__("hidden"); 1246 #define PERL_ARGS_ASSERT_GET_HASH_SEED \ 1247 assert(seed_buffer) 1248 1249 PERL_CALLCONV HV * 1250 Perl_get_hv(pTHX_ const char *name, I32 flags); 1251 #define PERL_ARGS_ASSERT_GET_HV \ 1252 assert(name) 1253 1254 PERL_CALLCONV const char * 1255 Perl_get_no_modify(pTHX) 1256 __attribute__deprecated__ 1257 __attribute__warn_unused_result__ 1258 __attribute__pure__ 1259 __attribute__visibility__("hidden"); 1260 #define PERL_ARGS_ASSERT_GET_NO_MODIFY 1261 1262 PERL_CALLCONV char ** 1263 Perl_get_op_descs(pTHX) 1264 __attribute__deprecated__ 1265 __attribute__warn_unused_result__ 1266 __attribute__pure__; 1267 #define PERL_ARGS_ASSERT_GET_OP_DESCS 1268 1269 PERL_CALLCONV char ** 1270 Perl_get_op_names(pTHX) 1271 __attribute__deprecated__ 1272 __attribute__warn_unused_result__ 1273 __attribute__pure__; 1274 #define PERL_ARGS_ASSERT_GET_OP_NAMES 1275 1276 PERL_CALLCONV U32 * 1277 Perl_get_opargs(pTHX) 1278 __attribute__deprecated__ 1279 __attribute__warn_unused_result__ 1280 __attribute__pure__ 1281 __attribute__visibility__("hidden"); 1282 #define PERL_ARGS_ASSERT_GET_OPARGS 1283 1284 PERL_CALLCONV PPADDR_t * 1285 Perl_get_ppaddr(pTHX) 1286 __attribute__deprecated__ 1287 __attribute__warn_unused_result__ 1288 __attribute__pure__; 1289 #define PERL_ARGS_ASSERT_GET_PPADDR 1290 1291 PERL_CALLCONV SV * 1292 Perl_get_prop_definition(pTHX_ const int table_index) 1293 __attribute__warn_unused_result__; 1294 #define PERL_ARGS_ASSERT_GET_PROP_DEFINITION 1295 1296 PERL_CALLCONV const char * const * 1297 Perl_get_prop_values(const int table_index) 1298 __attribute__warn_unused_result__; 1299 #define PERL_ARGS_ASSERT_GET_PROP_VALUES 1300 1301 PERL_CALLCONV REGEXP * 1302 Perl_get_re_arg(pTHX_ SV *sv); 1303 #define PERL_ARGS_ASSERT_GET_RE_ARG 1304 1305 PERL_CALLCONV SV * 1306 Perl_get_sv(pTHX_ const char *name, I32 flags); 1307 #define PERL_ARGS_ASSERT_GET_SV \ 1308 assert(name) 1309 1310 PERL_CALLCONV int 1311 Perl_getcwd_sv(pTHX_ SV *sv); 1312 #define PERL_ARGS_ASSERT_GETCWD_SV \ 1313 assert(sv) 1314 1315 PERL_CALLCONV void 1316 Perl_gp_free(pTHX_ GV *gv); 1317 #define PERL_ARGS_ASSERT_GP_FREE 1318 1319 PERL_CALLCONV GP * 1320 Perl_gp_ref(pTHX_ GP *gp); 1321 #define PERL_ARGS_ASSERT_GP_REF 1322 1323 PERL_CALLCONV bool 1324 Perl_grok_atoUV(const char *pv, UV *valptr, const char **endptr); 1325 #define PERL_ARGS_ASSERT_GROK_ATOUV \ 1326 assert(pv); assert(valptr) 1327 1328 PERL_CALLCONV UV 1329 Perl_grok_bin(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); 1330 #define PERL_ARGS_ASSERT_GROK_BIN \ 1331 assert(start); assert(len_p); assert(flags) 1332 1333 PERL_CALLCONV UV 1334 Perl_grok_bin_oct_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result, const unsigned shift, const U8 lookup_bit, const char prefix); 1335 #define PERL_ARGS_ASSERT_GROK_BIN_OCT_HEX \ 1336 assert(start); assert(len_p); assert(flags) 1337 1338 PERL_CALLCONV UV 1339 Perl_grok_hex(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); 1340 #define PERL_ARGS_ASSERT_GROK_HEX \ 1341 assert(start); assert(len_p); assert(flags) 1342 1343 PERL_CALLCONV int 1344 Perl_grok_infnan(pTHX_ const char **sp, const char *send); 1345 #define PERL_ARGS_ASSERT_GROK_INFNAN \ 1346 assert(sp); assert(send) 1347 1348 PERL_CALLCONV int 1349 Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep); 1350 #define PERL_ARGS_ASSERT_GROK_NUMBER \ 1351 assert(pv) 1352 1353 PERL_CALLCONV int 1354 Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags); 1355 #define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ 1356 assert(pv) 1357 1358 PERL_CALLCONV bool 1359 Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) 1360 __attribute__warn_unused_result__; 1361 #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ 1362 assert(sp); assert(send) 1363 1364 PERL_CALLCONV UV 1365 Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); 1366 #define PERL_ARGS_ASSERT_GROK_OCT \ 1367 assert(start); assert(len_p); assert(flags) 1368 1369 PERL_CALLCONV GV * 1370 Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); 1371 #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE 1372 1373 /* PERL_CALLCONV GV * 1374 gv_autoload4(pTHX_ HV *stash, const char *name, STRLEN len, I32 method) 1375 __attribute__warn_unused_result__; */ 1376 1377 PERL_CALLCONV GV * 1378 Perl_gv_autoload_pv(pTHX_ HV *stash, const char *namepv, U32 flags) 1379 __attribute__warn_unused_result__; 1380 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PV \ 1381 assert(namepv) 1382 1383 PERL_CALLCONV GV * 1384 Perl_gv_autoload_pvn(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags) 1385 __attribute__warn_unused_result__; 1386 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_PVN \ 1387 assert(name) 1388 1389 PERL_CALLCONV GV * 1390 Perl_gv_autoload_sv(pTHX_ HV *stash, SV *namesv, U32 flags) 1391 __attribute__warn_unused_result__; 1392 #define PERL_ARGS_ASSERT_GV_AUTOLOAD_SV \ 1393 assert(namesv) 1394 1395 PERL_CALLCONV void 1396 Perl_gv_check(pTHX_ HV *stash); 1397 #define PERL_ARGS_ASSERT_GV_CHECK \ 1398 assert(stash) 1399 1400 PERL_CALLCONV SV * 1401 Perl_gv_const_sv(pTHX_ GV *gv) 1402 __attribute__warn_unused_result__; 1403 #define PERL_ARGS_ASSERT_GV_CONST_SV \ 1404 assert(gv) 1405 1406 PERL_CALLCONV void 1407 Perl_gv_dump(pTHX_ GV *gv); 1408 #define PERL_ARGS_ASSERT_GV_DUMP 1409 1410 PERL_CALLCONV void 1411 Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); 1412 #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ 1413 assert(sv); assert(gv) 1414 1415 PERL_CALLCONV GV * 1416 Perl_gv_fetchfile(pTHX_ const char *name); 1417 #define PERL_ARGS_ASSERT_GV_FETCHFILE \ 1418 assert(name) 1419 1420 PERL_CALLCONV GV * 1421 Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U32 flags); 1422 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ 1423 assert(name) 1424 1425 /* PERL_CALLCONV GV * 1426 gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ 1427 1428 /* PERL_CALLCONV GV * 1429 gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ 1430 1431 PERL_CALLCONV GV * 1432 Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags); 1433 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ 1434 assert(name) 1435 1436 PERL_CALLCONV GV * 1437 Perl_gv_fetchmeth_pv_autoload(pTHX_ HV *stash, const char *name, I32 level, U32 flags); 1438 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV_AUTOLOAD \ 1439 assert(name) 1440 1441 PERL_CALLCONV GV * 1442 Perl_gv_fetchmeth_pvn(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); 1443 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN \ 1444 assert(name) 1445 1446 PERL_CALLCONV GV * 1447 Perl_gv_fetchmeth_pvn_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level, U32 flags); 1448 #define PERL_ARGS_ASSERT_GV_FETCHMETH_PVN_AUTOLOAD \ 1449 assert(name) 1450 1451 PERL_CALLCONV GV * 1452 Perl_gv_fetchmeth_sv(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); 1453 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV \ 1454 assert(namesv) 1455 1456 PERL_CALLCONV GV * 1457 Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags); 1458 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ 1459 assert(namesv) 1460 1461 PERL_CALLCONV GV * 1462 Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); 1463 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ 1464 assert(stash); assert(name) 1465 1466 PERL_CALLCONV GV * 1467 Perl_gv_fetchmethod_pv_flags(pTHX_ HV *stash, const char *name, U32 flags); 1468 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PV_FLAGS \ 1469 assert(stash); assert(name) 1470 1471 PERL_CALLCONV GV * 1472 Perl_gv_fetchmethod_pvn_flags(pTHX_ HV *stash, const char *name, const STRLEN len, U32 flags); 1473 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_PVN_FLAGS \ 1474 assert(stash); assert(name) 1475 1476 PERL_CALLCONV GV * 1477 Perl_gv_fetchmethod_sv_flags(pTHX_ HV *stash, SV *namesv, U32 flags); 1478 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS \ 1479 assert(stash); assert(namesv) 1480 1481 PERL_CALLCONV GV * 1482 Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type); 1483 #define PERL_ARGS_ASSERT_GV_FETCHPV \ 1484 assert(nambeg) 1485 1486 PERL_CALLCONV GV * 1487 Perl_gv_fetchpvn_flags(pTHX_ const char *name, STRLEN len, I32 flags, const svtype sv_type); 1488 #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ 1489 assert(name) 1490 1491 PERL_CALLCONV GV * 1492 Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); 1493 #define PERL_ARGS_ASSERT_GV_FETCHSV \ 1494 assert(name) 1495 1496 PERL_CALLCONV void 1497 Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); 1498 #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ 1499 assert(sv); assert(gv) 1500 1501 PERL_CALLCONV CV * 1502 Perl_gv_handler(pTHX_ HV *stash, I32 id) 1503 __attribute__warn_unused_result__; 1504 #define PERL_ARGS_ASSERT_GV_HANDLER 1505 1506 /* PERL_CALLCONV void 1507 gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */ 1508 1509 PERL_CALLCONV void 1510 Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags); 1511 #define PERL_ARGS_ASSERT_GV_INIT_PV \ 1512 assert(gv); assert(name) 1513 1514 PERL_CALLCONV void 1515 Perl_gv_init_pvn(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, U32 flags); 1516 #define PERL_ARGS_ASSERT_GV_INIT_PVN \ 1517 assert(gv); assert(name) 1518 1519 PERL_CALLCONV void 1520 Perl_gv_init_sv(pTHX_ GV *gv, HV *stash, SV *namesv, U32 flags); 1521 #define PERL_ARGS_ASSERT_GV_INIT_SV \ 1522 assert(gv); assert(namesv) 1523 1524 PERL_CALLCONV void 1525 Perl_gv_name_set(pTHX_ GV *gv, const char *name, U32 len, U32 flags); 1526 #define PERL_ARGS_ASSERT_GV_NAME_SET \ 1527 assert(gv); assert(name) 1528 1529 PERL_CALLCONV GV * 1530 Perl_gv_override(pTHX_ const char * const name, const STRLEN len); 1531 #define PERL_ARGS_ASSERT_GV_OVERRIDE \ 1532 assert(name) 1533 1534 PERL_CALLCONV void 1535 Perl_gv_setref(pTHX_ SV * const dsv, SV * const ssv) 1536 __attribute__visibility__("hidden"); 1537 #define PERL_ARGS_ASSERT_GV_SETREF \ 1538 assert(dsv); assert(ssv) 1539 1540 PERL_CALLCONV HV * 1541 Perl_gv_stashpv(pTHX_ const char *name, I32 flags); 1542 #define PERL_ARGS_ASSERT_GV_STASHPV \ 1543 assert(name) 1544 1545 PERL_CALLCONV HV * 1546 Perl_gv_stashpvn(pTHX_ const char *name, U32 namelen, I32 flags); 1547 #define PERL_ARGS_ASSERT_GV_STASHPVN \ 1548 assert(name) 1549 1550 PERL_CALLCONV HV * 1551 Perl_gv_stashsv(pTHX_ SV *sv, I32 flags); 1552 #define PERL_ARGS_ASSERT_GV_STASHSV \ 1553 assert(sv) 1554 1555 PERL_CALLCONV void 1556 Perl_gv_try_downgrade(pTHX_ GV *gv); 1557 #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ 1558 assert(gv) 1559 1560 PERL_CALLCONV struct xpvhv_aux * 1561 Perl_hv_auxalloc(pTHX_ HV *hv) 1562 __attribute__visibility__("hidden"); 1563 #define PERL_ARGS_ASSERT_HV_AUXALLOC \ 1564 assert(hv) 1565 1566 PERL_CALLCONV AV ** 1567 Perl_hv_backreferences_p(pTHX_ HV *hv) 1568 __attribute__visibility__("hidden"); 1569 #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ 1570 assert(hv) 1571 1572 PERL_CALLCONV SV * 1573 Perl_hv_bucket_ratio(pTHX_ HV *hv) 1574 __attribute__warn_unused_result__; 1575 #define PERL_ARGS_ASSERT_HV_BUCKET_RATIO \ 1576 assert(hv) 1577 1578 PERL_CALLCONV void 1579 Perl_hv_clear(pTHX_ HV *hv); 1580 #define PERL_ARGS_ASSERT_HV_CLEAR 1581 1582 PERL_CALLCONV void 1583 Perl_hv_clear_placeholders(pTHX_ HV *hv); 1584 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ 1585 assert(hv) 1586 1587 PERL_CALLCONV void * 1588 Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int flags, int action, SV *val, U32 hash); 1589 #define PERL_ARGS_ASSERT_HV_COMMON 1590 1591 PERL_CALLCONV void * 1592 Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash); 1593 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ 1594 assert(key) 1595 1596 PERL_CALLCONV HV * 1597 Perl_hv_copy_hints_hv(pTHX_ HV * const ohv) 1598 __attribute__warn_unused_result__; 1599 #define PERL_ARGS_ASSERT_HV_COPY_HINTS_HV 1600 1601 PERL_CALLCONV void 1602 Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry); 1603 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT 1604 1605 PERL_CALLCONV void 1606 Perl_hv_dump(pTHX_ HV *hv); 1607 #define PERL_ARGS_ASSERT_HV_DUMP 1608 1609 PERL_CALLCONV HE ** 1610 Perl_hv_eiter_p(pTHX_ HV *hv) 1611 __attribute__warn_unused_result__; 1612 #define PERL_ARGS_ASSERT_HV_EITER_P \ 1613 assert(hv) 1614 1615 PERL_CALLCONV void 1616 Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter); 1617 #define PERL_ARGS_ASSERT_HV_EITER_SET \ 1618 assert(hv) 1619 1620 PERL_CALLCONV void 1621 Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 1622 __attribute__visibility__("hidden"); 1623 #define PERL_ARGS_ASSERT_HV_ENAME_ADD \ 1624 assert(hv); assert(name) 1625 1626 PERL_CALLCONV void 1627 Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 1628 __attribute__visibility__("hidden"); 1629 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ 1630 assert(hv); assert(name) 1631 1632 PERL_CALLCONV STRLEN 1633 Perl_hv_fill(pTHX_ HV * const hv); 1634 #define PERL_ARGS_ASSERT_HV_FILL \ 1635 assert(hv) 1636 1637 PERL_CALLCONV void 1638 Perl_hv_free_ent(pTHX_ HV *notused, HE *entry); 1639 #define PERL_ARGS_ASSERT_HV_FREE_ENT 1640 1641 PERL_CALLCONV I32 1642 Perl_hv_iterinit(pTHX_ HV *hv); 1643 #define PERL_ARGS_ASSERT_HV_ITERINIT \ 1644 assert(hv) 1645 1646 PERL_CALLCONV char * 1647 Perl_hv_iterkey(pTHX_ HE *entry, I32 *retlen) 1648 __attribute__warn_unused_result__; 1649 #define PERL_ARGS_ASSERT_HV_ITERKEY \ 1650 assert(entry); assert(retlen) 1651 1652 PERL_CALLCONV SV * 1653 Perl_hv_iterkeysv(pTHX_ HE *entry) 1654 __attribute__warn_unused_result__; 1655 #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ 1656 assert(entry) 1657 1658 PERL_CALLCONV HE * 1659 Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) 1660 __attribute__warn_unused_result__; 1661 #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ 1662 assert(hv) 1663 1664 PERL_CALLCONV SV * 1665 Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) 1666 __attribute__warn_unused_result__; 1667 #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ 1668 assert(hv); assert(key); assert(retlen) 1669 1670 PERL_CALLCONV SV * 1671 Perl_hv_iterval(pTHX_ HV *hv, HE *entry) 1672 __attribute__warn_unused_result__; 1673 #define PERL_ARGS_ASSERT_HV_ITERVAL \ 1674 assert(hv); assert(entry) 1675 1676 PERL_CALLCONV void 1677 Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); 1678 #define PERL_ARGS_ASSERT_HV_KSPLIT \ 1679 assert(hv) 1680 1681 PERL_CALLCONV void 1682 Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); 1683 #define PERL_ARGS_ASSERT_HV_NAME_SET \ 1684 assert(hv) 1685 1686 PERL_CALLCONV I32 1687 Perl_hv_placeholders_get(pTHX_ const HV *hv) 1688 __attribute__warn_unused_result__; 1689 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ 1690 assert(hv) 1691 1692 PERL_CALLCONV SSize_t * 1693 Perl_hv_placeholders_p(pTHX_ HV *hv) 1694 __attribute__warn_unused_result__; 1695 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ 1696 assert(hv) 1697 1698 PERL_CALLCONV void 1699 Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph); 1700 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ 1701 assert(hv) 1702 1703 PERL_CALLCONV void 1704 Perl_hv_pushkv(pTHX_ HV *hv, U32 flags) 1705 __attribute__visibility__("hidden"); 1706 #define PERL_ARGS_ASSERT_HV_PUSHKV \ 1707 assert(hv) 1708 1709 PERL_CALLCONV void 1710 Perl_hv_rand_set(pTHX_ HV *hv, U32 new_xhv_rand); 1711 #define PERL_ARGS_ASSERT_HV_RAND_SET \ 1712 assert(hv) 1713 1714 PERL_CALLCONV I32 * 1715 Perl_hv_riter_p(pTHX_ HV *hv) 1716 __attribute__warn_unused_result__; 1717 #define PERL_ARGS_ASSERT_HV_RITER_P \ 1718 assert(hv) 1719 1720 PERL_CALLCONV void 1721 Perl_hv_riter_set(pTHX_ HV *hv, I32 riter); 1722 #define PERL_ARGS_ASSERT_HV_RITER_SET \ 1723 assert(hv) 1724 1725 PERL_CALLCONV SV * 1726 Perl_hv_scalar(pTHX_ HV *hv) 1727 __attribute__warn_unused_result__; 1728 #define PERL_ARGS_ASSERT_HV_SCALAR \ 1729 assert(hv) 1730 1731 /* PERL_CALLCONV SV ** 1732 hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ 1733 1734 /* PERL_CALLCONV void 1735 hv_undef(pTHX_ HV *hv); */ 1736 1737 PERL_CALLCONV void 1738 Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); 1739 #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS 1740 1741 /* PERL_CALLCONV I32 1742 ibcmp(pTHX_ const char *a, const char *b, I32 len) 1743 __attribute__warn_unused_result__ 1744 __attribute__pure__; */ 1745 1746 /* PERL_CALLCONV I32 1747 ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) 1748 __attribute__warn_unused_result__ 1749 __attribute__pure__; */ 1750 1751 /* PERL_CALLCONV I32 1752 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ 1753 1754 PERL_CALLCONV STRLEN 1755 Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def); 1756 #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD \ 1757 assert(operator_ptr); assert(def) 1758 1759 PERL_CALLCONV void 1760 Perl_init_argv_symbols(pTHX_ int argc, char **argv) 1761 __attribute__visibility__("hidden"); 1762 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ 1763 assert(argv) 1764 1765 PERL_CALLCONV void 1766 Perl_init_constants(pTHX) 1767 __attribute__visibility__("hidden"); 1768 #define PERL_ARGS_ASSERT_INIT_CONSTANTS 1769 1770 PERL_CALLCONV void 1771 Perl_init_dbargs(pTHX) 1772 __attribute__visibility__("hidden"); 1773 #define PERL_ARGS_ASSERT_INIT_DBARGS 1774 1775 PERL_CALLCONV void 1776 Perl_init_debugger(pTHX) 1777 __attribute__visibility__("hidden"); 1778 #define PERL_ARGS_ASSERT_INIT_DEBUGGER 1779 1780 PERL_CALLCONV int 1781 Perl_init_i18nl10n(pTHX_ int printwarn); 1782 #define PERL_ARGS_ASSERT_INIT_I18NL10N 1783 1784 PERL_CALLCONV void 1785 Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); 1786 #define PERL_ARGS_ASSERT_INIT_NAMED_CV \ 1787 assert(cv); assert(nameop) 1788 1789 PERL_CALLCONV void 1790 Perl_init_stacks(pTHX); 1791 #define PERL_ARGS_ASSERT_INIT_STACKS 1792 1793 PERL_CALLCONV void 1794 Perl_init_tm(pTHX_ struct tm *ptm); 1795 #define PERL_ARGS_ASSERT_INIT_TM \ 1796 assert(ptm) 1797 1798 PERL_CALLCONV void 1799 Perl_init_uniprops(pTHX) 1800 __attribute__visibility__("hidden"); 1801 #define PERL_ARGS_ASSERT_INIT_UNIPROPS 1802 1803 PERL_CALLCONV U32 1804 Perl_intro_my(pTHX); 1805 #define PERL_ARGS_ASSERT_INTRO_MY 1806 1807 PERL_CALLCONV OP * 1808 Perl_invert(pTHX_ OP *cmd) 1809 __attribute__warn_unused_result__ 1810 __attribute__visibility__("hidden"); 1811 #define PERL_ARGS_ASSERT_INVERT 1812 1813 PERL_CALLCONV void 1814 Perl_invmap_dump(pTHX_ SV *invlist, UV *map) 1815 __attribute__visibility__("hidden"); 1816 #define PERL_ARGS_ASSERT_INVMAP_DUMP \ 1817 assert(invlist); assert(map) 1818 1819 PERL_CALLCONV bool 1820 Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail) 1821 __attribute__visibility__("hidden"); 1822 #define PERL_ARGS_ASSERT_IO_CLOSE \ 1823 assert(io) 1824 1825 /* PERL_CALLCONV bool 1826 is_ascii_string(const U8 * const s, STRLEN len) 1827 __attribute__warn_unused_result__ 1828 __attribute__pure__; */ 1829 1830 /* PERL_CALLCONV bool 1831 is_c9strict_utf8_string(const U8 *s, STRLEN len) 1832 __attribute__warn_unused_result__; */ 1833 1834 /* PERL_CALLCONV bool 1835 is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ 1836 1837 /* PERL_CALLCONV bool 1838 is_invariant_string(const U8 * const s, STRLEN len) 1839 __attribute__warn_unused_result__ 1840 __attribute__pure__; */ 1841 1842 PERL_CALLCONV I32 1843 Perl_is_lvalue_sub(pTHX) 1844 __attribute__warn_unused_result__; 1845 #define PERL_ARGS_ASSERT_IS_LVALUE_SUB 1846 1847 /* PERL_CALLCONV bool 1848 is_strict_utf8_string(const U8 *s, STRLEN len) 1849 __attribute__warn_unused_result__; */ 1850 1851 /* PERL_CALLCONV bool 1852 is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ 1853 1854 PERL_CALLCONV Size_t 1855 Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial) 1856 __attribute__warn_unused_result__ 1857 __attribute__pure__; 1858 #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ 1859 assert(s0); assert(e) 1860 1861 PERL_CALLCONV STRLEN 1862 Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) 1863 __attribute__warn_unused_result__ 1864 __attribute__pure__; 1865 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_ \ 1866 assert(s); assert(e) 1867 1868 /* PERL_CALLCONV bool 1869 is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ 1870 1871 /* PERL_CALLCONV bool 1872 is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ 1873 1874 /* PERL_CALLCONV bool 1875 is_utf8_invariant_string(const U8 * const s, STRLEN len) 1876 __attribute__warn_unused_result__; */ 1877 1878 /* PERL_CALLCONV bool 1879 is_utf8_string(const U8 *s, STRLEN len) 1880 __attribute__warn_unused_result__; */ 1881 1882 /* PERL_CALLCONV bool 1883 is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */ 1884 1885 /* PERL_CALLCONV bool 1886 is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) 1887 __attribute__warn_unused_result__ 1888 __attribute__pure__; */ 1889 1890 PERL_CALLCONV bool 1891 Perl_isinfnan(NV nv) 1892 __attribute__warn_unused_result__ 1893 __attribute__pure__; 1894 #define PERL_ARGS_ASSERT_ISINFNAN 1895 1896 PERL_CALLCONV bool 1897 Perl_isinfnansv(pTHX_ SV *sv) 1898 __attribute__visibility__("hidden"); 1899 #define PERL_ARGS_ASSERT_ISINFNANSV \ 1900 assert(sv) 1901 1902 PERL_CALLCONV OP * 1903 Perl_jmaybe(pTHX_ OP *o) 1904 __attribute__visibility__("hidden"); 1905 #define PERL_ARGS_ASSERT_JMAYBE \ 1906 assert(o) 1907 1908 PERL_CALLCONV I32 1909 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) 1910 __attribute__warn_unused_result__ 1911 __attribute__pure__ 1912 __attribute__visibility__("hidden"); 1913 #define PERL_ARGS_ASSERT_KEYWORD \ 1914 assert(name) 1915 1916 PERL_CALLCONV int 1917 Perl_keyword_plugin_standard(pTHX_ char *keyword_ptr, STRLEN keyword_len, OP **op_ptr); 1918 #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ 1919 assert(keyword_ptr); assert(op_ptr) 1920 1921 PERL_CALLCONV void 1922 Perl_leave_adjust_stacks(pTHX_ SV **from_sp, SV **to_sp, U8 gimme, int filter); 1923 #define PERL_ARGS_ASSERT_LEAVE_ADJUST_STACKS \ 1924 assert(from_sp); assert(to_sp) 1925 1926 PERL_CALLCONV void 1927 Perl_leave_scope(pTHX_ I32 base); 1928 #define PERL_ARGS_ASSERT_LEAVE_SCOPE 1929 1930 PERL_CALLCONV bool 1931 Perl_lex_bufutf8(pTHX); 1932 #define PERL_ARGS_ASSERT_LEX_BUFUTF8 1933 1934 PERL_CALLCONV void 1935 Perl_lex_discard_to(pTHX_ char *ptr); 1936 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ 1937 assert(ptr) 1938 1939 PERL_CALLCONV char * 1940 Perl_lex_grow_linestr(pTHX_ STRLEN len); 1941 #define PERL_ARGS_ASSERT_LEX_GROW_LINESTR 1942 1943 PERL_CALLCONV bool 1944 Perl_lex_next_chunk(pTHX_ U32 flags); 1945 #define PERL_ARGS_ASSERT_LEX_NEXT_CHUNK 1946 1947 PERL_CALLCONV I32 1948 Perl_lex_peek_unichar(pTHX_ U32 flags); 1949 #define PERL_ARGS_ASSERT_LEX_PEEK_UNICHAR 1950 1951 PERL_CALLCONV void 1952 Perl_lex_read_space(pTHX_ U32 flags); 1953 #define PERL_ARGS_ASSERT_LEX_READ_SPACE 1954 1955 PERL_CALLCONV void 1956 Perl_lex_read_to(pTHX_ char *ptr); 1957 #define PERL_ARGS_ASSERT_LEX_READ_TO \ 1958 assert(ptr) 1959 1960 PERL_CALLCONV I32 1961 Perl_lex_read_unichar(pTHX_ U32 flags); 1962 #define PERL_ARGS_ASSERT_LEX_READ_UNICHAR 1963 1964 PERL_CALLCONV void 1965 Perl_lex_start(pTHX_ SV *line, PerlIO *rsfp, U32 flags); 1966 #define PERL_ARGS_ASSERT_LEX_START 1967 1968 PERL_CALLCONV void 1969 Perl_lex_stuff_pv(pTHX_ const char *pv, U32 flags); 1970 #define PERL_ARGS_ASSERT_LEX_STUFF_PV \ 1971 assert(pv) 1972 1973 PERL_CALLCONV void 1974 Perl_lex_stuff_pvn(pTHX_ const char *pv, STRLEN len, U32 flags); 1975 #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ 1976 assert(pv) 1977 1978 PERL_CALLCONV void 1979 Perl_lex_stuff_sv(pTHX_ SV *sv, U32 flags); 1980 #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ 1981 assert(sv) 1982 1983 PERL_CALLCONV void 1984 Perl_lex_unstuff(pTHX_ char *ptr); 1985 #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ 1986 assert(ptr) 1987 1988 PERL_CALLCONV OP * 1989 Perl_list(pTHX_ OP *o) 1990 __attribute__visibility__("hidden"); 1991 #define PERL_ARGS_ASSERT_LIST 1992 1993 PERL_CALLCONV HV * 1994 Perl_load_charnames(pTHX_ SV *char_name, const char *context, const STRLEN context_len, const char **error_msg) 1995 __attribute__warn_unused_result__; 1996 #define PERL_ARGS_ASSERT_LOAD_CHARNAMES \ 1997 assert(char_name); assert(context); assert(error_msg) 1998 1999 PERL_CALLCONV void 2000 Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...); 2001 #define PERL_ARGS_ASSERT_LOAD_MODULE \ 2002 assert(name) 2003 2004 PERL_CALLCONV_NO_RET void 2005 Perl_locale_panic(const char *msg, const line_t immediate_caller_line, const char * const higher_caller_file, const line_t higher_caller_line) 2006 __attribute__noreturn__; 2007 #define PERL_ARGS_ASSERT_LOCALE_PANIC \ 2008 assert(msg); assert(higher_caller_file) 2009 2010 PERL_CALLCONV OP * 2011 Perl_localize(pTHX_ OP *o, I32 lex) 2012 __attribute__visibility__("hidden"); 2013 #define PERL_ARGS_ASSERT_LOCALIZE \ 2014 assert(o) 2015 2016 PERL_CALLCONV I32 2017 Perl_looks_like_number(pTHX_ SV * const sv) 2018 __attribute__warn_unused_result__; 2019 #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ 2020 assert(sv) 2021 2022 PERL_CALLCONV int 2023 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg) 2024 __attribute__visibility__("hidden"); 2025 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ 2026 assert(sv); assert(mg) 2027 2028 PERL_CALLCONV int 2029 Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg) 2030 __attribute__visibility__("hidden"); 2031 #define PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P \ 2032 assert(sv); assert(mg) 2033 2034 PERL_CALLCONV int 2035 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg) 2036 __attribute__visibility__("hidden"); 2037 #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ 2038 assert(sv); assert(mg) 2039 2040 PERL_CALLCONV int 2041 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg) 2042 __attribute__visibility__("hidden"); 2043 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ 2044 assert(sv); assert(mg) 2045 2046 PERL_CALLCONV int 2047 Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg) 2048 __attribute__visibility__("hidden"); 2049 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ 2050 assert(sv); assert(mg) 2051 2052 PERL_CALLCONV int 2053 Perl_magic_clearhook(pTHX_ SV *sv, MAGIC *mg) 2054 __attribute__visibility__("hidden"); 2055 #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOK \ 2056 assert(mg) 2057 2058 PERL_CALLCONV int 2059 Perl_magic_clearhookall(pTHX_ SV *sv, MAGIC *mg) 2060 __attribute__visibility__("hidden"); 2061 #define PERL_ARGS_ASSERT_MAGIC_CLEARHOOKALL \ 2062 assert(mg) 2063 2064 PERL_CALLCONV int 2065 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg) 2066 __attribute__visibility__("hidden"); 2067 #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ 2068 assert(mg) 2069 2070 PERL_CALLCONV int 2071 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg) 2072 __attribute__visibility__("hidden"); 2073 #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ 2074 assert(sv); assert(mg) 2075 2076 PERL_CALLCONV int 2077 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg) 2078 __attribute__visibility__("hidden"); 2079 #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ 2080 assert(sv); assert(mg) 2081 2082 PERL_CALLCONV int 2083 Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv, const char *name, I32 namlen) 2084 __attribute__visibility__("hidden"); 2085 #define PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER \ 2086 assert(sv); assert(mg); assert(nsv) 2087 2088 PERL_CALLCONV void 2089 Perl_magic_dump(pTHX_ const MAGIC *mg); 2090 #define PERL_ARGS_ASSERT_MAGIC_DUMP 2091 2092 PERL_CALLCONV int 2093 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg) 2094 __attribute__visibility__("hidden"); 2095 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ 2096 assert(sv); assert(mg) 2097 2098 PERL_CALLCONV int 2099 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg) 2100 __attribute__visibility__("hidden"); 2101 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ 2102 assert(sv); assert(mg) 2103 2104 PERL_CALLCONV int 2105 Perl_magic_freedestruct(pTHX_ SV *sv, MAGIC *mg) 2106 __attribute__visibility__("hidden"); 2107 #define PERL_ARGS_ASSERT_MAGIC_FREEDESTRUCT \ 2108 assert(sv); assert(mg) 2109 2110 PERL_CALLCONV int 2111 Perl_magic_freemglob(pTHX_ SV *sv, MAGIC *mg) 2112 __attribute__visibility__("hidden"); 2113 #define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB \ 2114 assert(sv); assert(mg) 2115 2116 PERL_CALLCONV int 2117 Perl_magic_freeovrld(pTHX_ SV *sv, MAGIC *mg) 2118 __attribute__visibility__("hidden"); 2119 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ 2120 assert(sv); assert(mg) 2121 2122 PERL_CALLCONV int 2123 Perl_magic_freeutf8(pTHX_ SV *sv, MAGIC *mg) 2124 __attribute__visibility__("hidden"); 2125 #define PERL_ARGS_ASSERT_MAGIC_FREEUTF8 \ 2126 assert(sv); assert(mg) 2127 2128 PERL_CALLCONV int 2129 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg) 2130 __attribute__visibility__("hidden"); 2131 #define PERL_ARGS_ASSERT_MAGIC_GET \ 2132 assert(sv); assert(mg) 2133 2134 PERL_CALLCONV int 2135 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg) 2136 __attribute__visibility__("hidden"); 2137 #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ 2138 assert(sv); assert(mg) 2139 2140 PERL_CALLCONV int 2141 Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) 2142 __attribute__visibility__("hidden"); 2143 #define PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR \ 2144 assert(sv); assert(mg) 2145 2146 PERL_CALLCONV int 2147 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg) 2148 __attribute__visibility__("hidden"); 2149 #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ 2150 assert(sv); assert(mg) 2151 2152 PERL_CALLCONV int 2153 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg) 2154 __attribute__visibility__("hidden"); 2155 #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ 2156 assert(sv); assert(mg) 2157 2158 PERL_CALLCONV int 2159 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg) 2160 __attribute__visibility__("hidden"); 2161 #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ 2162 assert(sv); assert(mg) 2163 2164 PERL_CALLCONV int 2165 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg) 2166 __attribute__visibility__("hidden"); 2167 #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ 2168 assert(sv); assert(mg) 2169 2170 PERL_CALLCONV int 2171 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg) 2172 __attribute__visibility__("hidden"); 2173 #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ 2174 assert(sv); assert(mg) 2175 2176 PERL_CALLCONV int 2177 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg) 2178 __attribute__visibility__("hidden"); 2179 #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ 2180 assert(sv); assert(mg) 2181 2182 PERL_CALLCONV int 2183 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg) 2184 __attribute__visibility__("hidden"); 2185 #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ 2186 assert(sv); assert(mg) 2187 2188 PERL_CALLCONV int 2189 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg) 2190 __attribute__visibility__("hidden"); 2191 #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ 2192 assert(sv); assert(mg) 2193 2194 PERL_CALLCONV int 2195 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg) 2196 __attribute__visibility__("hidden"); 2197 #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ 2198 assert(sv); assert(mg) 2199 2200 PERL_CALLCONV int 2201 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) 2202 __attribute__visibility__("hidden"); 2203 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ 2204 assert(sv); assert(mg) 2205 2206 PERL_CALLCONV SV * 2207 Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, U32 argc, ...) 2208 __attribute__visibility__("hidden"); 2209 #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ 2210 assert(sv); assert(mg); assert(meth) 2211 2212 PERL_CALLCONV int 2213 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) 2214 __attribute__visibility__("hidden"); 2215 #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ 2216 assert(sv); assert(mg); assert(key) 2217 2218 PERL_CALLCONV U32 2219 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg) 2220 __attribute__visibility__("hidden"); 2221 #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ 2222 assert(sv); assert(mg) 2223 2224 PERL_CALLCONV int 2225 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg) 2226 __attribute__visibility__("hidden"); 2227 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ 2228 assert(sv); assert(mg) 2229 2230 PERL_CALLCONV SV * 2231 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) 2232 __attribute__visibility__("hidden"); 2233 #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ 2234 assert(hv); assert(mg) 2235 2236 PERL_CALLCONV int 2237 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg) 2238 __attribute__visibility__("hidden"); 2239 #define PERL_ARGS_ASSERT_MAGIC_SET \ 2240 assert(sv); assert(mg) 2241 2242 PERL_CALLCONV int 2243 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg) 2244 __attribute__visibility__("hidden"); 2245 #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ 2246 assert(sv); assert(mg) 2247 2248 PERL_CALLCONV int 2249 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg) 2250 __attribute__visibility__("hidden"); 2251 #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ 2252 assert(sv); assert(mg) 2253 2254 PERL_CALLCONV int 2255 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg) 2256 __attribute__visibility__("hidden"); 2257 #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ 2258 assert(sv); assert(mg) 2259 2260 PERL_CALLCONV int 2261 Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) 2262 __attribute__visibility__("hidden"); 2263 #define PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR \ 2264 assert(sv); assert(mg) 2265 2266 PERL_CALLCONV int 2267 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg) 2268 __attribute__visibility__("hidden"); 2269 #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ 2270 assert(sv); assert(mg) 2271 2272 PERL_CALLCONV int 2273 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg) 2274 __attribute__visibility__("hidden"); 2275 #define PERL_ARGS_ASSERT_MAGIC_SETENV \ 2276 assert(sv); assert(mg) 2277 2278 PERL_CALLCONV int 2279 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg) 2280 __attribute__visibility__("hidden"); 2281 #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ 2282 assert(sv); assert(mg) 2283 2284 PERL_CALLCONV int 2285 Perl_magic_sethook(pTHX_ SV *sv, MAGIC *mg) 2286 __attribute__visibility__("hidden"); 2287 #define PERL_ARGS_ASSERT_MAGIC_SETHOOK \ 2288 assert(mg) 2289 2290 PERL_CALLCONV int 2291 Perl_magic_sethookall(pTHX_ SV *sv, MAGIC *mg) 2292 __attribute__visibility__("hidden"); 2293 #define PERL_ARGS_ASSERT_MAGIC_SETHOOKALL \ 2294 assert(sv); assert(mg) 2295 2296 PERL_CALLCONV int 2297 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg) 2298 __attribute__visibility__("hidden"); 2299 #define PERL_ARGS_ASSERT_MAGIC_SETISA \ 2300 assert(sv); assert(mg) 2301 2302 PERL_CALLCONV int 2303 Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg) 2304 __attribute__visibility__("hidden"); 2305 #define PERL_ARGS_ASSERT_MAGIC_SETLVREF \ 2306 assert(sv); assert(mg) 2307 2308 PERL_CALLCONV int 2309 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg) 2310 __attribute__visibility__("hidden"); 2311 #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ 2312 assert(sv); assert(mg) 2313 2314 PERL_CALLCONV int 2315 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg) 2316 __attribute__visibility__("hidden"); 2317 #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ 2318 assert(sv); assert(mg) 2319 2320 PERL_CALLCONV int 2321 Perl_magic_setnonelem(pTHX_ SV *sv, MAGIC *mg) 2322 __attribute__visibility__("hidden"); 2323 #define PERL_ARGS_ASSERT_MAGIC_SETNONELEM \ 2324 assert(sv); assert(mg) 2325 2326 PERL_CALLCONV int 2327 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg) 2328 __attribute__visibility__("hidden"); 2329 #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ 2330 assert(sv); assert(mg) 2331 2332 PERL_CALLCONV int 2333 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg) 2334 __attribute__visibility__("hidden"); 2335 #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ 2336 assert(sv); assert(mg) 2337 2338 PERL_CALLCONV int 2339 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg) 2340 __attribute__visibility__("hidden"); 2341 #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ 2342 assert(sv); assert(mg) 2343 2344 PERL_CALLCONV int 2345 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg) 2346 __attribute__visibility__("hidden"); 2347 #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ 2348 assert(mg) 2349 2350 PERL_CALLCONV int 2351 Perl_magic_setsigall(pTHX_ SV *sv, MAGIC *mg) 2352 __attribute__visibility__("hidden"); 2353 #define PERL_ARGS_ASSERT_MAGIC_SETSIGALL \ 2354 assert(sv); assert(mg) 2355 2356 PERL_CALLCONV int 2357 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg) 2358 __attribute__visibility__("hidden"); 2359 #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ 2360 assert(sv); assert(mg) 2361 2362 PERL_CALLCONV int 2363 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg) 2364 __attribute__visibility__("hidden"); 2365 #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ 2366 assert(sv); assert(mg) 2367 2368 PERL_CALLCONV int 2369 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg) 2370 __attribute__visibility__("hidden"); 2371 #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ 2372 assert(sv); assert(mg) 2373 2374 PERL_CALLCONV int 2375 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg) 2376 __attribute__visibility__("hidden"); 2377 #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ 2378 assert(sv); assert(mg) 2379 2380 PERL_CALLCONV int 2381 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg) 2382 __attribute__visibility__("hidden"); 2383 #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ 2384 assert(sv); assert(mg) 2385 2386 PERL_CALLCONV U32 2387 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg) 2388 __attribute__visibility__("hidden"); 2389 #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ 2390 assert(sv); assert(mg) 2391 2392 PERL_CALLCONV int 2393 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg) 2394 __attribute__visibility__("hidden"); 2395 #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ 2396 assert(sv); assert(mg) 2397 2398 PERL_CALLCONV Malloc_t 2399 Perl_malloc(MEM_SIZE nbytes) 2400 __attribute__malloc__ 2401 __attribute__warn_unused_result__; 2402 #define PERL_ARGS_ASSERT_MALLOC 2403 2404 PERL_CALLCONV Stack_off_t * 2405 Perl_markstack_grow(pTHX); 2406 #define PERL_ARGS_ASSERT_MARKSTACK_GROW 2407 2408 PERL_CALLCONV int 2409 Perl_mbtowc_(pTHX_ const wchar_t *pwc, const char *s, const Size_t len); 2410 #define PERL_ARGS_ASSERT_MBTOWC_ 2411 2412 PERL_CALLCONV SV * 2413 Perl_mess(pTHX_ const char *pat, ...) 2414 __attribute__format__(__printf__,pTHX_1,pTHX_2); 2415 #define PERL_ARGS_ASSERT_MESS \ 2416 assert(pat) 2417 2418 PERL_CALLCONV SV * 2419 Perl_mess_sv(pTHX_ SV *basemsg, bool consume); 2420 #define PERL_ARGS_ASSERT_MESS_SV \ 2421 assert(basemsg) 2422 2423 PERL_CALLCONV Free_t 2424 Perl_mfree(Malloc_t where); 2425 #define PERL_ARGS_ASSERT_MFREE 2426 2427 PERL_CALLCONV int 2428 Perl_mg_clear(pTHX_ SV *sv); 2429 #define PERL_ARGS_ASSERT_MG_CLEAR \ 2430 assert(sv) 2431 2432 PERL_CALLCONV int 2433 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen); 2434 #define PERL_ARGS_ASSERT_MG_COPY \ 2435 assert(sv); assert(nsv) 2436 2437 PERL_CALLCONV MAGIC * 2438 Perl_mg_find(const SV *sv, int type) 2439 __attribute__warn_unused_result__; 2440 #define PERL_ARGS_ASSERT_MG_FIND 2441 2442 PERL_CALLCONV MAGIC * 2443 Perl_mg_find_mglob(pTHX_ SV *sv) 2444 __attribute__warn_unused_result__; 2445 #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \ 2446 assert(sv) 2447 2448 PERL_CALLCONV MAGIC * 2449 Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl) 2450 __attribute__warn_unused_result__; 2451 #define PERL_ARGS_ASSERT_MG_FINDEXT 2452 2453 PERL_CALLCONV int 2454 Perl_mg_free(pTHX_ SV *sv); 2455 #define PERL_ARGS_ASSERT_MG_FREE \ 2456 assert(sv) 2457 2458 PERL_CALLCONV void 2459 Perl_mg_free_type(pTHX_ SV *sv, int how); 2460 #define PERL_ARGS_ASSERT_MG_FREE_TYPE \ 2461 assert(sv) 2462 2463 PERL_CALLCONV void 2464 Perl_mg_freeext(pTHX_ SV *sv, int how, const MGVTBL *vtbl); 2465 #define PERL_ARGS_ASSERT_MG_FREEEXT \ 2466 assert(sv) 2467 2468 PERL_CALLCONV int 2469 Perl_mg_get(pTHX_ SV *sv); 2470 #define PERL_ARGS_ASSERT_MG_GET \ 2471 assert(sv) 2472 2473 PERL_CALLCONV void 2474 Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic) 2475 __attribute__visibility__("hidden"); 2476 #define PERL_ARGS_ASSERT_MG_LOCALIZE \ 2477 assert(sv); assert(nsv) 2478 2479 PERL_CALLCONV void 2480 Perl_mg_magical(SV *sv); 2481 #define PERL_ARGS_ASSERT_MG_MAGICAL \ 2482 assert(sv) 2483 2484 PERL_CALLCONV int 2485 Perl_mg_set(pTHX_ SV *sv); 2486 #define PERL_ARGS_ASSERT_MG_SET \ 2487 assert(sv) 2488 2489 PERL_CALLCONV I32 2490 Perl_mg_size(pTHX_ SV *sv); 2491 #define PERL_ARGS_ASSERT_MG_SIZE \ 2492 assert(sv) 2493 2494 PERL_CALLCONV void 2495 Perl_mini_mktime(struct tm *ptm); 2496 #define PERL_ARGS_ASSERT_MINI_MKTIME \ 2497 assert(ptm) 2498 2499 PERL_CALLCONV int 2500 Perl_mode_from_discipline(pTHX_ const char *s, STRLEN len) 2501 __attribute__visibility__("hidden"); 2502 #define PERL_ARGS_ASSERT_MODE_FROM_DISCIPLINE 2503 2504 PERL_CALLCONV void * 2505 Perl_more_bodies(pTHX_ const svtype sv_type, const size_t body_size, const size_t arena_size); 2506 #define PERL_ARGS_ASSERT_MORE_BODIES 2507 2508 PERL_CALLCONV const char * 2509 Perl_moreswitches(pTHX_ const char *s); 2510 #define PERL_ARGS_ASSERT_MORESWITCHES \ 2511 assert(s) 2512 2513 PERL_CALLCONV void 2514 Perl_mortal_destructor_sv(pTHX_ SV *coderef, SV *args); 2515 #define PERL_ARGS_ASSERT_MORTAL_DESTRUCTOR_SV \ 2516 assert(coderef) 2517 2518 PERL_CALLCONV void 2519 Perl_mortal_svfunc_x(pTHX_ SVFUNC_t f, SV *p); 2520 #define PERL_ARGS_ASSERT_MORTAL_SVFUNC_X 2521 2522 PERL_CALLCONV const struct mro_alg * 2523 Perl_mro_get_from_name(pTHX_ SV *name); 2524 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ 2525 assert(name) 2526 2527 PERL_CALLCONV AV * 2528 Perl_mro_get_linear_isa(pTHX_ HV *stash); 2529 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ 2530 assert(stash) 2531 2532 PERL_CALLCONV SV * 2533 Perl_mro_get_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which); 2534 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ 2535 assert(smeta); assert(which) 2536 2537 PERL_CALLCONV void 2538 Perl_mro_isa_changed_in(pTHX_ HV *stash) 2539 __attribute__visibility__("hidden"); 2540 #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ 2541 assert(stash) 2542 2543 PERL_CALLCONV struct mro_meta * 2544 Perl_mro_meta_init(pTHX_ HV *stash); 2545 #define PERL_ARGS_ASSERT_MRO_META_INIT \ 2546 assert(stash) 2547 2548 PERL_CALLCONV void 2549 Perl_mro_method_changed_in(pTHX_ HV *stash); 2550 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ 2551 assert(stash) 2552 2553 PERL_CALLCONV void 2554 Perl_mro_package_moved(pTHX_ HV * const stash, HV * const oldstash, const GV * const gv, U32 flags); 2555 #define PERL_ARGS_ASSERT_MRO_PACKAGE_MOVED \ 2556 assert(gv) 2557 2558 PERL_CALLCONV void 2559 Perl_mro_register(pTHX_ const struct mro_alg *mro); 2560 #define PERL_ARGS_ASSERT_MRO_REGISTER \ 2561 assert(mro) 2562 2563 PERL_CALLCONV void 2564 Perl_mro_set_mro(pTHX_ struct mro_meta * const meta, SV * const name); 2565 #define PERL_ARGS_ASSERT_MRO_SET_MRO \ 2566 assert(meta); assert(name) 2567 2568 PERL_CALLCONV SV * 2569 Perl_mro_set_private_data(pTHX_ struct mro_meta * const smeta, const struct mro_alg * const which, SV * const data); 2570 #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ 2571 assert(smeta); assert(which); assert(data) 2572 2573 PERL_CALLCONV SV * 2574 Perl_multiconcat_stringify(pTHX_ const OP *o); 2575 #define PERL_ARGS_ASSERT_MULTICONCAT_STRINGIFY \ 2576 assert(o) 2577 2578 PERL_CALLCONV SV * 2579 Perl_multideref_stringify(pTHX_ const OP *o, CV *cv); 2580 #define PERL_ARGS_ASSERT_MULTIDEREF_STRINGIFY \ 2581 assert(o) 2582 2583 PERL_CALLCONV NV 2584 Perl_my_atof(pTHX_ const char *s); 2585 #define PERL_ARGS_ASSERT_MY_ATOF \ 2586 assert(s) 2587 2588 PERL_CALLCONV char * 2589 Perl_my_atof2(pTHX_ const char *orig, NV *value); 2590 #define PERL_ARGS_ASSERT_MY_ATOF2 \ 2591 assert(orig); assert(value) 2592 2593 PERL_CALLCONV char * 2594 Perl_my_atof3(pTHX_ const char *orig, NV *value, const STRLEN len); 2595 #define PERL_ARGS_ASSERT_MY_ATOF3 \ 2596 assert(orig); assert(value) 2597 2598 PERL_CALLCONV OP * 2599 Perl_my_attrs(pTHX_ OP *o, OP *attrs) 2600 __attribute__visibility__("hidden"); 2601 #define PERL_ARGS_ASSERT_MY_ATTRS \ 2602 assert(o) 2603 2604 PERL_CALLCONV void 2605 Perl_my_clearenv(pTHX); 2606 #define PERL_ARGS_ASSERT_MY_CLEARENV 2607 2608 PERL_CALLCONV int 2609 Perl_my_dirfd(DIR *dir); 2610 #define PERL_ARGS_ASSERT_MY_DIRFD 2611 2612 PERL_CALLCONV_NO_RET void 2613 Perl_my_exit(pTHX_ U32 status) 2614 __attribute__noreturn__; 2615 #define PERL_ARGS_ASSERT_MY_EXIT 2616 2617 PERL_CALLCONV_NO_RET void 2618 Perl_my_failure_exit(pTHX) 2619 __attribute__noreturn__; 2620 #define PERL_ARGS_ASSERT_MY_FAILURE_EXIT 2621 2622 PERL_CALLCONV I32 2623 Perl_my_fflush_all(pTHX); 2624 #define PERL_ARGS_ASSERT_MY_FFLUSH_ALL 2625 2626 PERL_CALLCONV Pid_t 2627 Perl_my_fork(void); 2628 #define PERL_ARGS_ASSERT_MY_FORK 2629 2630 /* PERL_CALLCONV I32 2631 my_lstat(pTHX); */ 2632 2633 PERL_CALLCONV I32 2634 Perl_my_lstat_flags(pTHX_ const U32 flags); 2635 #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS 2636 2637 PERL_CALLCONV int 2638 Perl_my_mkostemp_cloexec(char *templte, int flags) 2639 __attribute__warn_unused_result__ 2640 __attribute__visibility__("hidden"); 2641 #define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ 2642 assert(templte) 2643 2644 PERL_CALLCONV int 2645 Perl_my_mkstemp_cloexec(char *templte) 2646 __attribute__warn_unused_result__ 2647 __attribute__visibility__("hidden"); 2648 #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC \ 2649 assert(templte) 2650 2651 PERL_CALLCONV PerlIO * 2652 Perl_my_popen_list(pTHX_ const char *mode, int n, SV **args); 2653 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ 2654 assert(mode); assert(args) 2655 2656 PERL_CALLCONV void 2657 Perl_my_setenv(pTHX_ const char *nam, const char *val); 2658 #define PERL_ARGS_ASSERT_MY_SETENV 2659 2660 PERL_CALLCONV int 2661 Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) 2662 __attribute__format__(__printf__,3,4); 2663 #define PERL_ARGS_ASSERT_MY_SNPRINTF \ 2664 assert(buffer); assert(format) 2665 2666 PERL_CALLCONV int 2667 Perl_my_socketpair(int family, int type, int protocol, int fd[2]); 2668 #define PERL_ARGS_ASSERT_MY_SOCKETPAIR 2669 2670 /* PERL_CALLCONV I32 2671 my_stat(pTHX); */ 2672 2673 PERL_CALLCONV I32 2674 Perl_my_stat_flags(pTHX_ const U32 flags); 2675 #define PERL_ARGS_ASSERT_MY_STAT_FLAGS 2676 2677 PERL_CALLCONV const char * 2678 Perl_my_strerror(pTHX_ const int errnum, utf8ness_t *utf8ness) 2679 __attribute__visibility__("hidden"); 2680 #define PERL_ARGS_ASSERT_MY_STRERROR \ 2681 assert(utf8ness) 2682 2683 PERL_CALLCONV char * 2684 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) 2685 __attribute__format__(__strftime__,pTHX_1,0); 2686 #define PERL_ARGS_ASSERT_MY_STRFTIME \ 2687 assert(fmt) 2688 2689 PERL_CALLCONV NV 2690 Perl_my_strtod(const char * const s, char **e) 2691 __attribute__warn_unused_result__; 2692 #define PERL_ARGS_ASSERT_MY_STRTOD \ 2693 assert(s) 2694 2695 PERL_CALLCONV void 2696 Perl_my_unexec(pTHX) 2697 __attribute__visibility__("hidden"); 2698 #define PERL_ARGS_ASSERT_MY_UNEXEC 2699 2700 PERL_CALLCONV int 2701 Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap); 2702 #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ 2703 assert(buffer); assert(format) 2704 2705 PERL_CALLCONV OP * 2706 Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); 2707 #define PERL_ARGS_ASSERT_NEWANONATTRSUB 2708 2709 PERL_CALLCONV OP * 2710 Perl_newANONHASH(pTHX_ OP *o) 2711 __attribute__warn_unused_result__; 2712 #define PERL_ARGS_ASSERT_NEWANONHASH 2713 2714 PERL_CALLCONV OP * 2715 Perl_newANONLIST(pTHX_ OP *o) 2716 __attribute__warn_unused_result__; 2717 #define PERL_ARGS_ASSERT_NEWANONLIST 2718 2719 PERL_CALLCONV OP * 2720 Perl_newANONSUB(pTHX_ I32 floor, OP *proto, OP *block); 2721 #define PERL_ARGS_ASSERT_NEWANONSUB 2722 2723 PERL_CALLCONV OP * 2724 Perl_newARGDEFELEMOP(pTHX_ I32 flags, OP *expr, I32 argindex) 2725 __attribute__warn_unused_result__; 2726 #define PERL_ARGS_ASSERT_NEWARGDEFELEMOP \ 2727 assert(expr) 2728 2729 PERL_CALLCONV OP * 2730 Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right) 2731 __attribute__warn_unused_result__; 2732 #define PERL_ARGS_ASSERT_NEWASSIGNOP 2733 2734 /* PERL_CALLCONV CV * 2735 newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ 2736 2737 PERL_CALLCONV CV * 2738 Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); 2739 #define PERL_ARGS_ASSERT_NEWATTRSUB_X 2740 2741 PERL_CALLCONV OP * 2742 Perl_newAVREF(pTHX_ OP *o) 2743 __attribute__warn_unused_result__; 2744 #define PERL_ARGS_ASSERT_NEWAVREF \ 2745 assert(o) 2746 2747 /* PERL_CALLCONV AV * 2748 newAV_alloc_x(pTHX_ SSize_t size) 2749 __attribute__warn_unused_result__; */ 2750 2751 /* PERL_CALLCONV AV * 2752 newAV_alloc_xz(pTHX_ SSize_t size) 2753 __attribute__warn_unused_result__; */ 2754 2755 /* PERL_CALLCONV AV * 2756 newAV_mortal(pTHX) 2757 __attribute__warn_unused_result__; */ 2758 2759 PERL_CALLCONV AV * 2760 Perl_newAVav(pTHX_ AV *oav) 2761 __attribute__warn_unused_result__; 2762 #define PERL_ARGS_ASSERT_NEWAVAV 2763 2764 PERL_CALLCONV AV * 2765 Perl_newAVhv(pTHX_ HV *ohv) 2766 __attribute__warn_unused_result__; 2767 #define PERL_ARGS_ASSERT_NEWAVHV 2768 2769 PERL_CALLCONV OP * 2770 Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) 2771 __attribute__warn_unused_result__; 2772 #define PERL_ARGS_ASSERT_NEWBINOP 2773 2774 PERL_CALLCONV OP * 2775 Perl_newCONDOP(pTHX_ I32 flags, OP *first, OP *trueop, OP *falseop) 2776 __attribute__warn_unused_result__; 2777 #define PERL_ARGS_ASSERT_NEWCONDOP \ 2778 assert(first) 2779 2780 PERL_CALLCONV CV * 2781 Perl_newCONSTSUB(pTHX_ HV *stash, const char *name, SV *sv); 2782 #define PERL_ARGS_ASSERT_NEWCONSTSUB 2783 2784 PERL_CALLCONV CV * 2785 Perl_newCONSTSUB_flags(pTHX_ HV *stash, const char *name, STRLEN len, U32 flags, SV *sv); 2786 #define PERL_ARGS_ASSERT_NEWCONSTSUB_FLAGS 2787 2788 PERL_CALLCONV OP * 2789 Perl_newCVREF(pTHX_ I32 flags, OP *o) 2790 __attribute__warn_unused_result__; 2791 #define PERL_ARGS_ASSERT_NEWCVREF 2792 2793 PERL_CALLCONV OP * 2794 Perl_newDEFEROP(pTHX_ I32 flags, OP *block) 2795 __attribute__warn_unused_result__; 2796 #define PERL_ARGS_ASSERT_NEWDEFEROP \ 2797 assert(block) 2798 2799 PERL_CALLCONV OP * 2800 Perl_newDEFSVOP(pTHX) 2801 __attribute__warn_unused_result__; 2802 #define PERL_ARGS_ASSERT_NEWDEFSVOP 2803 2804 PERL_CALLCONV void 2805 Perl_newFORM(pTHX_ I32 floor, OP *o, OP *block); 2806 #define PERL_ARGS_ASSERT_NEWFORM 2807 2808 PERL_CALLCONV OP * 2809 Perl_newFOROP(pTHX_ I32 flags, OP *sv, OP *expr, OP *block, OP *cont) 2810 __attribute__warn_unused_result__; 2811 #define PERL_ARGS_ASSERT_NEWFOROP \ 2812 assert(expr) 2813 2814 PERL_CALLCONV OP * 2815 Perl_newGIVENOP(pTHX_ OP *cond, OP *block, PADOFFSET defsv_off) 2816 __attribute__warn_unused_result__; 2817 #define PERL_ARGS_ASSERT_NEWGIVENOP \ 2818 assert(cond); assert(block) 2819 2820 PERL_CALLCONV GP * 2821 Perl_newGP(pTHX_ GV * const gv); 2822 #define PERL_ARGS_ASSERT_NEWGP \ 2823 assert(gv) 2824 2825 PERL_CALLCONV OP * 2826 Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv) 2827 __attribute__warn_unused_result__; 2828 #define PERL_ARGS_ASSERT_NEWGVOP \ 2829 assert(gv) 2830 2831 PERL_CALLCONV OP * 2832 Perl_newGVREF(pTHX_ I32 type, OP *o) 2833 __attribute__warn_unused_result__; 2834 #define PERL_ARGS_ASSERT_NEWGVREF 2835 2836 /* PERL_CALLCONV GV * 2837 newGVgen(pTHX_ const char *pack); */ 2838 2839 PERL_CALLCONV GV * 2840 Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) 2841 __attribute__warn_unused_result__; 2842 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ 2843 assert(pack) 2844 2845 PERL_CALLCONV OP * 2846 Perl_newHVREF(pTHX_ OP *o) 2847 __attribute__warn_unused_result__; 2848 #define PERL_ARGS_ASSERT_NEWHVREF \ 2849 assert(o) 2850 2851 PERL_CALLCONV HV * 2852 Perl_newHVhv(pTHX_ HV *hv) 2853 __attribute__warn_unused_result__; 2854 #define PERL_ARGS_ASSERT_NEWHVHV 2855 2856 PERL_CALLCONV OP * 2857 Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) 2858 __attribute__warn_unused_result__; 2859 #define PERL_ARGS_ASSERT_NEWLISTOP 2860 2861 PERL_CALLCONV OP * 2862 Perl_newLISTOPn(pTHX_ I32 type, I32 flags, ...) 2863 __attribute__warn_unused_result__; 2864 #define PERL_ARGS_ASSERT_NEWLISTOPN 2865 2866 PERL_CALLCONV OP * 2867 Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) 2868 __attribute__warn_unused_result__; 2869 #define PERL_ARGS_ASSERT_NEWLOGOP \ 2870 assert(first); assert(other) 2871 2872 PERL_CALLCONV OP * 2873 Perl_newLOOPEX(pTHX_ I32 type, OP *label) 2874 __attribute__warn_unused_result__; 2875 #define PERL_ARGS_ASSERT_NEWLOOPEX \ 2876 assert(label) 2877 2878 PERL_CALLCONV OP * 2879 Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP *expr, OP *block) 2880 __attribute__warn_unused_result__; 2881 #define PERL_ARGS_ASSERT_NEWLOOPOP \ 2882 assert(expr) 2883 2884 PERL_CALLCONV OP * 2885 Perl_newMETHOP(pTHX_ I32 type, I32 flags, OP *dynamic_meth) 2886 __attribute__warn_unused_result__; 2887 #define PERL_ARGS_ASSERT_NEWMETHOP \ 2888 assert(dynamic_meth) 2889 2890 PERL_CALLCONV OP * 2891 Perl_newMETHOP_named(pTHX_ I32 type, I32 flags, SV * const_meth) 2892 __attribute__warn_unused_result__; 2893 #define PERL_ARGS_ASSERT_NEWMETHOP_NAMED \ 2894 assert(const_meth) 2895 2896 PERL_CALLCONV CV * 2897 Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); 2898 #define PERL_ARGS_ASSERT_NEWMYSUB \ 2899 assert(o) 2900 2901 PERL_CALLCONV OP * 2902 Perl_newNULLLIST(pTHX) 2903 __attribute__warn_unused_result__; 2904 #define PERL_ARGS_ASSERT_NEWNULLLIST 2905 2906 PERL_CALLCONV OP * 2907 Perl_newOP(pTHX_ I32 optype, I32 flags) 2908 __attribute__warn_unused_result__; 2909 #define PERL_ARGS_ASSERT_NEWOP 2910 2911 PERL_CALLCONV PADNAMELIST * 2912 Perl_newPADNAMELIST(size_t max) 2913 __attribute__warn_unused_result__; 2914 #define PERL_ARGS_ASSERT_NEWPADNAMELIST 2915 2916 PERL_CALLCONV PADNAME * 2917 Perl_newPADNAMEouter(PADNAME *outer) 2918 __attribute__warn_unused_result__; 2919 #define PERL_ARGS_ASSERT_NEWPADNAMEOUTER \ 2920 assert(outer) 2921 2922 PERL_CALLCONV PADNAME * 2923 Perl_newPADNAMEpvn(const char *s, STRLEN len) 2924 __attribute__warn_unused_result__; 2925 #define PERL_ARGS_ASSERT_NEWPADNAMEPVN \ 2926 assert(s) 2927 2928 PERL_CALLCONV OP * 2929 Perl_newPMOP(pTHX_ I32 type, I32 flags) 2930 __attribute__warn_unused_result__; 2931 #define PERL_ARGS_ASSERT_NEWPMOP 2932 2933 PERL_CALLCONV void 2934 Perl_newPROG(pTHX_ OP *o); 2935 #define PERL_ARGS_ASSERT_NEWPROG \ 2936 assert(o) 2937 2938 PERL_CALLCONV OP * 2939 Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv) 2940 __attribute__warn_unused_result__; 2941 #define PERL_ARGS_ASSERT_NEWPVOP 2942 2943 PERL_CALLCONV OP * 2944 Perl_newRANGE(pTHX_ I32 flags, OP *left, OP *right) 2945 __attribute__warn_unused_result__; 2946 #define PERL_ARGS_ASSERT_NEWRANGE \ 2947 assert(left); assert(right) 2948 2949 PERL_CALLCONV SV * 2950 Perl_newRV(pTHX_ SV * const sv) 2951 __attribute__warn_unused_result__; 2952 #define PERL_ARGS_ASSERT_NEWRV \ 2953 assert(sv) 2954 2955 PERL_CALLCONV OP * 2956 Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listop) 2957 __attribute__warn_unused_result__; 2958 #define PERL_ARGS_ASSERT_NEWSLICEOP 2959 2960 PERL_CALLCONV OP * 2961 Perl_newSTATEOP(pTHX_ I32 flags, char *label, OP *o) 2962 __attribute__warn_unused_result__; 2963 #define PERL_ARGS_ASSERT_NEWSTATEOP 2964 2965 PERL_CALLCONV CV * 2966 Perl_newSTUB(pTHX_ GV *gv, bool fake) 2967 __attribute__visibility__("hidden"); 2968 #define PERL_ARGS_ASSERT_NEWSTUB \ 2969 assert(gv) 2970 2971 PERL_CALLCONV SV * 2972 Perl_newSV(pTHX_ const STRLEN len) 2973 __attribute__warn_unused_result__; 2974 #define PERL_ARGS_ASSERT_NEWSV 2975 2976 PERL_CALLCONV OP * 2977 Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv) 2978 __attribute__warn_unused_result__; 2979 #define PERL_ARGS_ASSERT_NEWSVOP \ 2980 assert(sv) 2981 2982 PERL_CALLCONV OP * 2983 Perl_newSVREF(pTHX_ OP *o) 2984 __attribute__warn_unused_result__; 2985 #define PERL_ARGS_ASSERT_NEWSVREF \ 2986 assert(o) 2987 2988 PERL_CALLCONV SV * 2989 Perl_newSV_false(pTHX) 2990 __attribute__warn_unused_result__; 2991 #define PERL_ARGS_ASSERT_NEWSV_FALSE 2992 2993 PERL_CALLCONV SV * 2994 Perl_newSV_true(pTHX) 2995 __attribute__warn_unused_result__; 2996 #define PERL_ARGS_ASSERT_NEWSV_TRUE 2997 2998 PERL_CALLCONV SV * 2999 Perl_newSVavdefelem(pTHX_ AV *av, SSize_t ix, bool extendible) 3000 __attribute__warn_unused_result__ 3001 __attribute__visibility__("hidden"); 3002 #define PERL_ARGS_ASSERT_NEWSVAVDEFELEM \ 3003 assert(av) 3004 3005 PERL_CALLCONV SV * 3006 Perl_newSVbool(pTHX_ const bool bool_val) 3007 __attribute__warn_unused_result__; 3008 #define PERL_ARGS_ASSERT_NEWSVBOOL 3009 3010 PERL_CALLCONV SV * 3011 Perl_newSVhek(pTHX_ const HEK * const hek) 3012 __attribute__warn_unused_result__; 3013 #define PERL_ARGS_ASSERT_NEWSVHEK 3014 3015 PERL_CALLCONV SV * 3016 Perl_newSVhek_mortal(pTHX_ const HEK * const hek) 3017 __attribute__warn_unused_result__; 3018 #define PERL_ARGS_ASSERT_NEWSVHEK_MORTAL 3019 3020 PERL_CALLCONV SV * 3021 Perl_newSViv(pTHX_ const IV i) 3022 __attribute__warn_unused_result__; 3023 #define PERL_ARGS_ASSERT_NEWSVIV 3024 3025 PERL_CALLCONV SV * 3026 Perl_newSVnv(pTHX_ const NV n) 3027 __attribute__warn_unused_result__; 3028 #define PERL_ARGS_ASSERT_NEWSVNV 3029 3030 PERL_CALLCONV SV * 3031 Perl_newSVpv(pTHX_ const char * const s, const STRLEN len) 3032 __attribute__warn_unused_result__; 3033 #define PERL_ARGS_ASSERT_NEWSVPV 3034 3035 PERL_CALLCONV SV * 3036 Perl_newSVpv_share(pTHX_ const char *s, U32 hash) 3037 __attribute__warn_unused_result__; 3038 #define PERL_ARGS_ASSERT_NEWSVPV_SHARE 3039 3040 PERL_CALLCONV SV * 3041 Perl_newSVpvf(pTHX_ const char * const pat, ...) 3042 __attribute__warn_unused_result__ 3043 __attribute__format__(__printf__,pTHX_1,pTHX_2); 3044 #define PERL_ARGS_ASSERT_NEWSVPVF \ 3045 assert(pat) 3046 3047 PERL_CALLCONV SV * 3048 Perl_newSVpvn(pTHX_ const char * const buffer, const STRLEN len) 3049 __attribute__warn_unused_result__; 3050 #define PERL_ARGS_ASSERT_NEWSVPVN 3051 3052 PERL_CALLCONV SV * 3053 Perl_newSVpvn_flags(pTHX_ const char * const s, const STRLEN len, const U32 flags) 3054 __attribute__warn_unused_result__; 3055 #define PERL_ARGS_ASSERT_NEWSVPVN_FLAGS 3056 3057 PERL_CALLCONV SV * 3058 Perl_newSVpvn_share(pTHX_ const char *s, I32 len, U32 hash) 3059 __attribute__warn_unused_result__; 3060 #define PERL_ARGS_ASSERT_NEWSVPVN_SHARE 3061 3062 PERL_CALLCONV SV * 3063 Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); 3064 #define PERL_ARGS_ASSERT_NEWSVRV \ 3065 assert(rv) 3066 3067 PERL_CALLCONV SV * 3068 Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags) 3069 __attribute__warn_unused_result__; 3070 #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS 3071 3072 /* PERL_CALLCONV SV * 3073 newSVsv_nomg(pTHX_ SV * const old) 3074 __attribute__warn_unused_result__; */ 3075 3076 PERL_CALLCONV SV * 3077 Perl_newSVuv(pTHX_ const UV u) 3078 __attribute__warn_unused_result__; 3079 #define PERL_ARGS_ASSERT_NEWSVUV 3080 3081 PERL_CALLCONV OP * 3082 Perl_newTRYCATCHOP(pTHX_ I32 flags, OP *tryblock, OP *catchvar, OP *catchblock) 3083 __attribute__warn_unused_result__; 3084 #define PERL_ARGS_ASSERT_NEWTRYCATCHOP \ 3085 assert(tryblock); assert(catchvar); assert(catchblock) 3086 3087 PERL_CALLCONV OP * 3088 Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first) 3089 __attribute__warn_unused_result__; 3090 #define PERL_ARGS_ASSERT_NEWUNOP 3091 3092 PERL_CALLCONV OP * 3093 Perl_newUNOP_AUX(pTHX_ I32 type, I32 flags, OP *first, UNOP_AUX_item *aux) 3094 __attribute__warn_unused_result__; 3095 #define PERL_ARGS_ASSERT_NEWUNOP_AUX 3096 3097 PERL_CALLCONV OP * 3098 Perl_newWHENOP(pTHX_ OP *cond, OP *block) 3099 __attribute__warn_unused_result__; 3100 #define PERL_ARGS_ASSERT_NEWWHENOP \ 3101 assert(block) 3102 3103 PERL_CALLCONV OP * 3104 Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP *loop, OP *expr, OP *block, OP *cont, I32 has_my) 3105 __attribute__warn_unused_result__; 3106 #define PERL_ARGS_ASSERT_NEWWHILEOP 3107 3108 PERL_CALLCONV CV * 3109 Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename); 3110 #define PERL_ARGS_ASSERT_NEWXS \ 3111 assert(subaddr); assert(filename) 3112 3113 PERL_CALLCONV CV * 3114 Perl_newXS_deffile(pTHX_ const char *name, XSUBADDR_t subaddr); 3115 #define PERL_ARGS_ASSERT_NEWXS_DEFFILE \ 3116 assert(name); assert(subaddr) 3117 3118 PERL_CALLCONV CV * 3119 Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char * const filename, const char * const proto, U32 flags); 3120 #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ 3121 assert(subaddr); assert(filename) 3122 3123 PERL_CALLCONV CV * 3124 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) 3125 __attribute__visibility__("hidden"); 3126 #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ 3127 assert(subaddr) 3128 3129 PERL_CALLCONV PERL_SI * 3130 Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) 3131 __attribute__warn_unused_result__; 3132 #define PERL_ARGS_ASSERT_NEW_STACKINFO 3133 3134 PERL_CALLCONV PERL_SI * 3135 Perl_new_stackinfo_flags(pTHX_ I32 stitems, I32 cxitems, UV flags) 3136 __attribute__warn_unused_result__; 3137 #define PERL_ARGS_ASSERT_NEW_STACKINFO_FLAGS 3138 3139 PERL_CALLCONV SV * 3140 Perl_new_version(pTHX_ SV *ver); 3141 #define PERL_ARGS_ASSERT_NEW_VERSION \ 3142 assert(ver) 3143 3144 PERL_CALLCONV char * 3145 Perl_new_warnings_bitfield(pTHX_ char *buffer, const char * const bits, STRLEN size) 3146 __attribute__warn_unused_result__; 3147 #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ 3148 assert(bits) 3149 3150 PERL_CALLCONV PerlIO * 3151 Perl_nextargv(pTHX_ GV *gv, bool nomagicopen) 3152 __attribute__visibility__("hidden"); 3153 #define PERL_ARGS_ASSERT_NEXTARGV \ 3154 assert(gv) 3155 3156 PERL_CALLCONV char * 3157 Perl_ninstr(const char *big, const char *bigend, const char *little, const char *lend) 3158 __attribute__warn_unused_result__ 3159 __attribute__pure__; 3160 #define PERL_ARGS_ASSERT_NINSTR \ 3161 assert(big); assert(bigend); assert(little); assert(lend) 3162 3163 PERL_CALLCONV void 3164 Perl_no_bareword_filehandle(pTHX_ const char *fhname) 3165 __attribute__visibility__("hidden"); 3166 #define PERL_ARGS_ASSERT_NO_BAREWORD_FILEHANDLE \ 3167 assert(fhname) 3168 3169 PERL_CALLCONV_NO_RET void 3170 Perl_noperl_die(const char *pat, ...) 3171 __attribute__noreturn__ 3172 __attribute__format__(__printf__,1,2); 3173 #define PERL_ARGS_ASSERT_NOPERL_DIE \ 3174 assert(pat) 3175 3176 PERL_CALLCONV int 3177 Perl_nothreadhook(pTHX); 3178 #define PERL_ARGS_ASSERT_NOTHREADHOOK 3179 3180 PERL_CALLCONV void 3181 Perl_notify_parser_that_changed_to_utf8(pTHX) 3182 __attribute__visibility__("hidden"); 3183 #define PERL_ARGS_ASSERT_NOTIFY_PARSER_THAT_CHANGED_TO_UTF8 3184 3185 PERL_CALLCONV OP * 3186 Perl_oopsAV(pTHX_ OP *o) 3187 __attribute__warn_unused_result__ 3188 __attribute__visibility__("hidden"); 3189 #define PERL_ARGS_ASSERT_OOPSAV \ 3190 assert(o) 3191 3192 PERL_CALLCONV OP * 3193 Perl_oopsHV(pTHX_ OP *o) 3194 __attribute__warn_unused_result__ 3195 __attribute__visibility__("hidden"); 3196 #define PERL_ARGS_ASSERT_OOPSHV \ 3197 assert(o) 3198 3199 PERL_CALLCONV OP * 3200 Perl_op_append_elem(pTHX_ I32 optype, OP *first, OP *last); 3201 #define PERL_ARGS_ASSERT_OP_APPEND_ELEM 3202 3203 PERL_CALLCONV OP * 3204 Perl_op_append_list(pTHX_ I32 optype, OP *first, OP *last); 3205 #define PERL_ARGS_ASSERT_OP_APPEND_LIST 3206 3207 PERL_CALLCONV OPclass 3208 Perl_op_class(pTHX_ const OP *o); 3209 #define PERL_ARGS_ASSERT_OP_CLASS 3210 3211 PERL_CALLCONV void 3212 Perl_op_clear(pTHX_ OP *o); 3213 #define PERL_ARGS_ASSERT_OP_CLEAR \ 3214 assert(o) 3215 3216 PERL_CALLCONV OP * 3217 Perl_op_contextualize(pTHX_ OP *o, I32 context); 3218 #define PERL_ARGS_ASSERT_OP_CONTEXTUALIZE \ 3219 assert(o) 3220 3221 PERL_CALLCONV OP * 3222 Perl_op_convert_list(pTHX_ I32 optype, I32 flags, OP *o) 3223 __attribute__warn_unused_result__; 3224 #define PERL_ARGS_ASSERT_OP_CONVERT_LIST 3225 3226 PERL_CALLCONV void 3227 Perl_op_dump(pTHX_ const OP *o); 3228 #define PERL_ARGS_ASSERT_OP_DUMP \ 3229 assert(o) 3230 3231 PERL_CALLCONV OP * 3232 Perl_op_force_list(pTHX_ OP *o); 3233 #define PERL_ARGS_ASSERT_OP_FORCE_LIST 3234 3235 PERL_CALLCONV void 3236 Perl_op_free(pTHX_ OP *arg); 3237 #define PERL_ARGS_ASSERT_OP_FREE 3238 3239 PERL_CALLCONV OP * 3240 Perl_op_linklist(pTHX_ OP *o); 3241 #define PERL_ARGS_ASSERT_OP_LINKLIST \ 3242 assert(o) 3243 3244 /* PERL_CALLCONV OP * 3245 op_lvalue(pTHX_ OP *o, I32 type); */ 3246 3247 PERL_CALLCONV OP * 3248 Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags); 3249 #define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS 3250 3251 PERL_CALLCONV void 3252 Perl_op_null(pTHX_ OP *o); 3253 #define PERL_ARGS_ASSERT_OP_NULL \ 3254 assert(o) 3255 3256 PERL_CALLCONV OP * 3257 Perl_op_parent(OP *o); 3258 #define PERL_ARGS_ASSERT_OP_PARENT \ 3259 assert(o) 3260 3261 PERL_CALLCONV OP * 3262 Perl_op_prepend_elem(pTHX_ I32 optype, OP *first, OP *last); 3263 #define PERL_ARGS_ASSERT_OP_PREPEND_ELEM 3264 3265 PERL_CALLCONV void 3266 Perl_op_refcnt_lock(pTHX); 3267 #define PERL_ARGS_ASSERT_OP_REFCNT_LOCK 3268 3269 PERL_CALLCONV void 3270 Perl_op_refcnt_unlock(pTHX); 3271 #define PERL_ARGS_ASSERT_OP_REFCNT_UNLOCK 3272 3273 PERL_CALLCONV OP * 3274 Perl_op_scope(pTHX_ OP *o); 3275 #define PERL_ARGS_ASSERT_OP_SCOPE 3276 3277 PERL_CALLCONV OP * 3278 Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP *insert); 3279 #define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE 3280 3281 PERL_CALLCONV OP * 3282 Perl_op_unscope(pTHX_ OP *o) 3283 __attribute__visibility__("hidden"); 3284 #define PERL_ARGS_ASSERT_OP_UNSCOPE 3285 3286 PERL_CALLCONV OP * 3287 Perl_op_wrap_finally(pTHX_ OP *block, OP *finally) 3288 __attribute__warn_unused_result__; 3289 #define PERL_ARGS_ASSERT_OP_WRAP_FINALLY \ 3290 assert(block); assert(finally) 3291 3292 PERL_CALLCONV void 3293 Perl_package(pTHX_ OP *o) 3294 __attribute__visibility__("hidden"); 3295 #define PERL_ARGS_ASSERT_PACKAGE \ 3296 assert(o) 3297 3298 PERL_CALLCONV void 3299 Perl_package_version(pTHX_ OP *v) 3300 __attribute__visibility__("hidden"); 3301 #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ 3302 assert(v) 3303 3304 PERL_CALLCONV void 3305 Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist); 3306 #define PERL_ARGS_ASSERT_PACKLIST \ 3307 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist) 3308 3309 PERL_CALLCONV PADOFFSET 3310 Perl_pad_add_anon(pTHX_ CV *func, I32 optype); 3311 #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ 3312 assert(func) 3313 3314 PERL_CALLCONV PADOFFSET 3315 Perl_pad_add_name_pv(pTHX_ const char *name, const U32 flags, HV *typestash, HV *ourstash); 3316 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PV \ 3317 assert(name) 3318 3319 PERL_CALLCONV PADOFFSET 3320 Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags, HV *typestash, HV *ourstash); 3321 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN \ 3322 assert(namepv) 3323 3324 PERL_CALLCONV PADOFFSET 3325 Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash); 3326 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ 3327 assert(name) 3328 3329 PERL_CALLCONV void 3330 Perl_pad_add_weakref(pTHX_ CV *func) 3331 __attribute__visibility__("hidden"); 3332 #define PERL_ARGS_ASSERT_PAD_ADD_WEAKREF \ 3333 assert(func) 3334 3335 PERL_CALLCONV PADOFFSET 3336 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); 3337 #define PERL_ARGS_ASSERT_PAD_ALLOC 3338 3339 PERL_CALLCONV void 3340 Perl_pad_block_start(pTHX_ int full) 3341 __attribute__visibility__("hidden"); 3342 #define PERL_ARGS_ASSERT_PAD_BLOCK_START 3343 3344 PERL_CALLCONV PADOFFSET 3345 Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags); 3346 #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \ 3347 assert(name) 3348 3349 PERL_CALLCONV PADOFFSET 3350 Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags); 3351 #define PERL_ARGS_ASSERT_PAD_FINDMY_PVN \ 3352 assert(namepv) 3353 3354 PERL_CALLCONV PADOFFSET 3355 Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags); 3356 #define PERL_ARGS_ASSERT_PAD_FINDMY_SV \ 3357 assert(name) 3358 3359 PERL_CALLCONV void 3360 Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) 3361 __attribute__visibility__("hidden"); 3362 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ 3363 assert(padlist); assert(old_cv); assert(new_cv) 3364 3365 PERL_CALLCONV void 3366 Perl_pad_free(pTHX_ PADOFFSET po) 3367 __attribute__visibility__("hidden"); 3368 #define PERL_ARGS_ASSERT_PAD_FREE 3369 3370 PERL_CALLCONV OP * 3371 Perl_pad_leavemy(pTHX) 3372 __attribute__visibility__("hidden"); 3373 #define PERL_ARGS_ASSERT_PAD_LEAVEMY 3374 3375 PERL_CALLCONV PADLIST * 3376 Perl_pad_new(pTHX_ int flags) 3377 __attribute__warn_unused_result__; 3378 #define PERL_ARGS_ASSERT_PAD_NEW 3379 3380 PERL_CALLCONV void 3381 Perl_pad_push(pTHX_ PADLIST *padlist, int depth); 3382 #define PERL_ARGS_ASSERT_PAD_PUSH \ 3383 assert(padlist) 3384 3385 PERL_CALLCONV void 3386 Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust) 3387 __attribute__visibility__("hidden"); 3388 #define PERL_ARGS_ASSERT_PAD_SWIPE 3389 3390 PERL_CALLCONV void 3391 Perl_pad_tidy(pTHX_ padtidy_type type); 3392 #define PERL_ARGS_ASSERT_PAD_TIDY 3393 3394 PERL_CALLCONV PAD ** 3395 Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val) 3396 __attribute__visibility__("hidden"); 3397 #define PERL_ARGS_ASSERT_PADLIST_STORE \ 3398 assert(padlist) 3399 3400 PERL_CALLCONV void 3401 Perl_padname_free(pTHX_ PADNAME *pn); 3402 #define PERL_ARGS_ASSERT_PADNAME_FREE \ 3403 assert(pn) 3404 3405 PERL_CALLCONV PADNAME * 3406 Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key) 3407 __attribute__warn_unused_result__; 3408 #define PERL_ARGS_ASSERT_PADNAMELIST_FETCH \ 3409 assert(pnl) 3410 3411 PERL_CALLCONV void 3412 Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl); 3413 #define PERL_ARGS_ASSERT_PADNAMELIST_FREE \ 3414 assert(pnl) 3415 3416 PERL_CALLCONV PADNAME ** 3417 Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val); 3418 #define PERL_ARGS_ASSERT_PADNAMELIST_STORE \ 3419 assert(pnl) 3420 3421 PERL_CALLCONV OP * 3422 Perl_parse_arithexpr(pTHX_ U32 flags); 3423 #define PERL_ARGS_ASSERT_PARSE_ARITHEXPR 3424 3425 PERL_CALLCONV OP * 3426 Perl_parse_barestmt(pTHX_ U32 flags); 3427 #define PERL_ARGS_ASSERT_PARSE_BARESTMT 3428 3429 PERL_CALLCONV OP * 3430 Perl_parse_block(pTHX_ U32 flags); 3431 #define PERL_ARGS_ASSERT_PARSE_BLOCK 3432 3433 PERL_CALLCONV OP * 3434 Perl_parse_fullexpr(pTHX_ U32 flags); 3435 #define PERL_ARGS_ASSERT_PARSE_FULLEXPR 3436 3437 PERL_CALLCONV OP * 3438 Perl_parse_fullstmt(pTHX_ U32 flags); 3439 #define PERL_ARGS_ASSERT_PARSE_FULLSTMT 3440 3441 PERL_CALLCONV SV * 3442 Perl_parse_label(pTHX_ U32 flags); 3443 #define PERL_ARGS_ASSERT_PARSE_LABEL 3444 3445 PERL_CALLCONV OP * 3446 Perl_parse_listexpr(pTHX_ U32 flags); 3447 #define PERL_ARGS_ASSERT_PARSE_LISTEXPR 3448 3449 PERL_CALLCONV OP * 3450 Perl_parse_stmtseq(pTHX_ U32 flags); 3451 #define PERL_ARGS_ASSERT_PARSE_STMTSEQ 3452 3453 PERL_CALLCONV OP * 3454 Perl_parse_subsignature(pTHX_ U32 flags); 3455 #define PERL_ARGS_ASSERT_PARSE_SUBSIGNATURE 3456 3457 PERL_CALLCONV OP * 3458 Perl_parse_termexpr(pTHX_ U32 flags); 3459 #define PERL_ARGS_ASSERT_PARSE_TERMEXPR 3460 3461 PERL_CALLCONV U32 3462 Perl_parse_unicode_opts(pTHX_ const char **popt) 3463 __attribute__visibility__("hidden"); 3464 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ 3465 assert(popt) 3466 3467 PERL_CALLCONV void 3468 Perl_parser_free(pTHX_ const yy_parser *parser) 3469 __attribute__visibility__("hidden"); 3470 #define PERL_ARGS_ASSERT_PARSER_FREE \ 3471 assert(parser) 3472 3473 PERL_CALLCONV void 3474 Perl_peep(pTHX_ OP *o) 3475 __attribute__visibility__("hidden"); 3476 #define PERL_ARGS_ASSERT_PEEP 3477 3478 PERL_CALLCONV PerlInterpreter * 3479 perl_alloc(void); 3480 #define PERL_ARGS_ASSERT_PERL_ALLOC 3481 3482 PERL_CALLCONV void 3483 perl_construct(PerlInterpreter *my_perl); 3484 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ 3485 assert(my_perl) 3486 3487 PERL_CALLCONV int 3488 perl_destruct(PerlInterpreter *my_perl); 3489 #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ 3490 assert(my_perl) 3491 3492 PERL_CALLCONV void 3493 perl_free(PerlInterpreter *my_perl); 3494 #define PERL_ARGS_ASSERT_PERL_FREE \ 3495 assert(my_perl) 3496 3497 PERL_CALLCONV int 3498 perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char **argv, char **env); 3499 #define PERL_ARGS_ASSERT_PERL_PARSE \ 3500 assert(my_perl) 3501 3502 PERL_CALLCONV int 3503 perl_run(PerlInterpreter *my_perl); 3504 #define PERL_ARGS_ASSERT_PERL_RUN \ 3505 assert(my_perl) 3506 3507 PERL_CALLCONV Signal_t 3508 Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); 3509 #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER 3510 3511 /* PERL_CALLCONV const char * const 3512 phase_name(pTHX_ enum perl_phase); */ 3513 3514 PERL_CALLCONV void 3515 Perl_pmop_dump(pTHX_ PMOP *pm); 3516 #define PERL_ARGS_ASSERT_PMOP_DUMP 3517 3518 PERL_CALLCONV OP * 3519 Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl, UV flags, I32 floor) 3520 __attribute__visibility__("hidden"); 3521 #define PERL_ARGS_ASSERT_PMRUNTIME \ 3522 assert(o); assert(expr) 3523 3524 PERL_CALLCONV void 3525 Perl_pop_scope(pTHX); 3526 #define PERL_ARGS_ASSERT_POP_SCOPE 3527 3528 PERL_CALLCONV void 3529 Perl_populate_isa(pTHX_ const char *name, STRLEN len, ...) 3530 __attribute__visibility__("hidden"); 3531 #define PERL_ARGS_ASSERT_POPULATE_ISA \ 3532 assert(name) 3533 3534 PERL_CALLCONV REGEXP * 3535 Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags); 3536 #define PERL_ARGS_ASSERT_PREGCOMP \ 3537 assert(pattern) 3538 3539 PERL_CALLCONV I32 3540 Perl_pregexec(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); 3541 #define PERL_ARGS_ASSERT_PREGEXEC \ 3542 assert(prog); assert(stringarg); assert(strend); assert(strbeg); \ 3543 assert(screamer) 3544 3545 PERL_CALLCONV void 3546 Perl_pregfree(pTHX_ REGEXP *r); 3547 #define PERL_ARGS_ASSERT_PREGFREE 3548 3549 PERL_CALLCONV void 3550 Perl_pregfree2(pTHX_ REGEXP *rx); 3551 #define PERL_ARGS_ASSERT_PREGFREE2 \ 3552 assert(rx) 3553 3554 PERL_CALLCONV const char * 3555 Perl_prescan_version(pTHX_ const char *s, bool strict, const char **errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha); 3556 #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ 3557 assert(s) 3558 3559 PERL_CALLCONV void * 3560 Perl_ptr_table_fetch(pTHX_ PTR_TBL_t * const tbl, const void * const sv) 3561 __attribute__warn_unused_result__; 3562 #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ 3563 assert(tbl) 3564 3565 PERL_CALLCONV void 3566 Perl_ptr_table_free(pTHX_ PTR_TBL_t * const tbl); 3567 #define PERL_ARGS_ASSERT_PTR_TABLE_FREE 3568 3569 PERL_CALLCONV PTR_TBL_t * 3570 Perl_ptr_table_new(pTHX) 3571 __attribute__warn_unused_result__; 3572 #define PERL_ARGS_ASSERT_PTR_TABLE_NEW 3573 3574 PERL_CALLCONV void 3575 Perl_ptr_table_split(pTHX_ PTR_TBL_t * const tbl); 3576 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ 3577 assert(tbl) 3578 3579 PERL_CALLCONV void 3580 Perl_ptr_table_store(pTHX_ PTR_TBL_t * const tbl, const void * const oldsv, void * const newsv); 3581 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ 3582 assert(tbl); assert(newsv) 3583 3584 PERL_CALLCONV void 3585 Perl_push_scope(pTHX); 3586 #define PERL_ARGS_ASSERT_PUSH_SCOPE 3587 3588 PERL_CALLCONV char * 3589 Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim); 3590 #define PERL_ARGS_ASSERT_PV_DISPLAY \ 3591 assert(dsv); assert(pv) 3592 3593 PERL_CALLCONV char * 3594 Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, STRLEN max, STRLEN * const escaped, U32 flags); 3595 #define PERL_ARGS_ASSERT_PV_ESCAPE \ 3596 assert(str) 3597 3598 PERL_CALLCONV char * 3599 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); 3600 #define PERL_ARGS_ASSERT_PV_PRETTY \ 3601 assert(dsv); assert(str) 3602 3603 PERL_CALLCONV char * 3604 Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags); 3605 #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ 3606 assert(dsv); assert(spv) 3607 3608 PERL_CALLCONV void 3609 Perl_qerror(pTHX_ SV *err); 3610 #define PERL_ARGS_ASSERT_QERROR 3611 3612 PERL_CALLCONV char * 3613 Perl_rcpv_copy(pTHX_ char * const pv); 3614 #define PERL_ARGS_ASSERT_RCPV_COPY 3615 3616 PERL_CALLCONV char * 3617 Perl_rcpv_free(pTHX_ char * const pv); 3618 #define PERL_ARGS_ASSERT_RCPV_FREE 3619 3620 PERL_CALLCONV char * 3621 Perl_rcpv_new(pTHX_ const char * const pv, STRLEN len, U32 flags) 3622 __attribute__malloc__ 3623 __attribute__warn_unused_result__; 3624 #define PERL_ARGS_ASSERT_RCPV_NEW 3625 3626 PERL_CALLCONV REGEXP * 3627 Perl_re_compile(pTHX_ SV * const pattern, U32 orig_rx_flags); 3628 #define PERL_ARGS_ASSERT_RE_COMPILE \ 3629 assert(pattern) 3630 3631 PERL_CALLCONV char * 3632 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); 3633 #define PERL_ARGS_ASSERT_RE_INTUIT_START \ 3634 assert(rx); assert(strbeg); assert(strpos); assert(strend) 3635 3636 PERL_CALLCONV SV * 3637 Perl_re_intuit_string(pTHX_ REGEXP * const r); 3638 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ 3639 assert(r) 3640 3641 PERL_CALLCONV REGEXP * 3642 Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine *eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags); 3643 #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ 3644 assert(eng) 3645 3646 PERL_CALLCONV Malloc_t 3647 Perl_realloc(Malloc_t where, MEM_SIZE nbytes) 3648 __attribute__warn_unused_result__; 3649 #define PERL_ARGS_ASSERT_REALLOC 3650 3651 PERL_CALLCONV void 3652 Perl_reentrant_free(pTHX); 3653 #define PERL_ARGS_ASSERT_REENTRANT_FREE 3654 3655 PERL_CALLCONV void 3656 Perl_reentrant_init(pTHX); 3657 #define PERL_ARGS_ASSERT_REENTRANT_INIT 3658 3659 PERL_CALLCONV void * 3660 Perl_reentrant_retry(const char *f, ...); 3661 #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ 3662 assert(f) 3663 3664 PERL_CALLCONV void 3665 Perl_reentrant_size(pTHX); 3666 #define PERL_ARGS_ASSERT_REENTRANT_SIZE 3667 3668 PERL_CALLCONV HV * 3669 Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags); 3670 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_CHAIN_2HV 3671 3672 PERL_CALLCONV SV * 3673 Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags); 3674 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV \ 3675 assert(key) 3676 3677 PERL_CALLCONV SV * 3678 Perl_refcounted_he_fetch_pvn(pTHX_ const struct refcounted_he *chain, const char *keypv, STRLEN keylen, U32 hash, U32 flags); 3679 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PVN \ 3680 assert(keypv) 3681 3682 PERL_CALLCONV SV * 3683 Perl_refcounted_he_fetch_sv(pTHX_ const struct refcounted_he *chain, SV *key, U32 hash, U32 flags); 3684 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_SV \ 3685 assert(key) 3686 3687 PERL_CALLCONV void 3688 Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); 3689 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FREE 3690 3691 PERL_CALLCONV struct refcounted_he * 3692 Perl_refcounted_he_inc(pTHX_ struct refcounted_he *he); 3693 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_INC 3694 3695 PERL_CALLCONV struct refcounted_he * 3696 Perl_refcounted_he_new_pv(pTHX_ struct refcounted_he *parent, const char *key, U32 hash, SV *value, U32 flags); 3697 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PV \ 3698 assert(key) 3699 3700 PERL_CALLCONV struct refcounted_he * 3701 Perl_refcounted_he_new_pvn(pTHX_ struct refcounted_he *parent, const char *keypv, STRLEN keylen, U32 hash, SV *value, U32 flags); 3702 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_PVN \ 3703 assert(keypv) 3704 3705 PERL_CALLCONV struct refcounted_he * 3706 Perl_refcounted_he_new_sv(pTHX_ struct refcounted_he *parent, SV *key, U32 hash, SV *value, U32 flags); 3707 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_SV \ 3708 assert(key) 3709 3710 PERL_CALLCONV SV * 3711 Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags); 3712 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ 3713 assert(rx) 3714 3715 PERL_CALLCONV SV * 3716 Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags); 3717 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ 3718 assert(rx) 3719 3720 PERL_CALLCONV bool 3721 Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags); 3722 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ 3723 assert(rx); assert(key) 3724 3725 PERL_CALLCONV SV * 3726 Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags); 3727 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ 3728 assert(rx); assert(namesv) 3729 3730 PERL_CALLCONV SV * 3731 Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags); 3732 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ 3733 assert(rx) 3734 3735 PERL_CALLCONV SV * 3736 Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags); 3737 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ 3738 assert(rx) 3739 3740 PERL_CALLCONV SV * 3741 Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags); 3742 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ 3743 assert(rx) 3744 3745 PERL_CALLCONV SV * 3746 Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags); 3747 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ 3748 assert(rx) 3749 3750 PERL_CALLCONV void 3751 Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const re, const I32 paren, SV * const sv); 3752 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ 3753 assert(re) 3754 3755 PERL_CALLCONV void 3756 Perl_reg_numbered_buff_fetch_flags(pTHX_ REGEXP * const re, const I32 paren, SV * const sv, U32 flags); 3757 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH_FLAGS \ 3758 assert(re) 3759 3760 PERL_CALLCONV I32 3761 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren); 3762 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ 3763 assert(rx); assert(sv) 3764 3765 PERL_CALLCONV void 3766 Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value); 3767 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ 3768 assert(rx) 3769 3770 PERL_CALLCONV SV * 3771 Perl_reg_qr_package(pTHX_ REGEXP * const rx); 3772 #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ 3773 assert(rx) 3774 3775 PERL_CALLCONV REGEXP * 3776 Perl_reg_temp_copy(pTHX_ REGEXP *dsv, REGEXP *ssv); 3777 #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ 3778 assert(ssv) 3779 3780 PERL_CALLCONV void 3781 Perl_regdump(pTHX_ const regexp *r); 3782 #define PERL_ARGS_ASSERT_REGDUMP \ 3783 assert(r) 3784 3785 PERL_CALLCONV I32 3786 Perl_regexec_flags(pTHX_ REGEXP * const rx, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *sv, void *data, U32 flags); 3787 #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ 3788 assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv) 3789 3790 PERL_CALLCONV void 3791 Perl_regfree_internal(pTHX_ REGEXP * const rx); 3792 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ 3793 assert(rx) 3794 3795 PERL_CALLCONV void 3796 Perl_reginitcolors(pTHX); 3797 #define PERL_ARGS_ASSERT_REGINITCOLORS 3798 3799 PERL_CALLCONV void 3800 Perl_repeatcpy(char *to, const char *from, SSize_t len, IV count); 3801 #define PERL_ARGS_ASSERT_REPEATCPY \ 3802 assert(to); assert(from) 3803 3804 PERL_CALLCONV void 3805 Perl_report_evil_fh(pTHX_ const GV *gv) 3806 __attribute__visibility__("hidden"); 3807 #define PERL_ARGS_ASSERT_REPORT_EVIL_FH 3808 3809 PERL_CALLCONV void 3810 Perl_report_uninit(pTHX_ const SV *uninit_sv); 3811 #define PERL_ARGS_ASSERT_REPORT_UNINIT 3812 3813 PERL_CALLCONV void 3814 Perl_report_wrongway_fh(pTHX_ const GV *gv, const char have) 3815 __attribute__visibility__("hidden"); 3816 #define PERL_ARGS_ASSERT_REPORT_WRONGWAY_FH 3817 3818 PERL_CALLCONV void 3819 Perl_require_pv(pTHX_ const char *pv); 3820 #define PERL_ARGS_ASSERT_REQUIRE_PV \ 3821 assert(pv) 3822 3823 PERL_CALLCONV void 3824 Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save); 3825 #define PERL_ARGS_ASSERT_RESUME_COMPCV \ 3826 assert(buffer) 3827 3828 /* PERL_CALLCONV void 3829 resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); */ 3830 3831 /* PERL_CALLCONV void 3832 resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */ 3833 3834 PERL_CALLCONV char * 3835 Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) 3836 __attribute__warn_unused_result__ 3837 __attribute__pure__; 3838 #define PERL_ARGS_ASSERT_RNINSTR \ 3839 assert(big); assert(bigend); assert(little); assert(lend) 3840 3841 PERL_CALLCONV void 3842 Perl_rpeep(pTHX_ OP *o) 3843 __attribute__visibility__("hidden"); 3844 #define PERL_ARGS_ASSERT_RPEEP 3845 3846 PERL_CALLCONV void 3847 Perl_rpp_free_2_(pTHX_ SV * const sv1, SV * const sv2, const U32 rc1, const U32 rc2); 3848 #define PERL_ARGS_ASSERT_RPP_FREE_2_ \ 3849 assert(sv1); assert(sv2) 3850 3851 PERL_CALLCONV void 3852 Perl_rpp_obliterate_stack_to(pTHX_ I32 ix); 3853 #define PERL_ARGS_ASSERT_RPP_OBLITERATE_STACK_TO 3854 3855 PERL_CALLCONV Sighandler_t 3856 Perl_rsignal(pTHX_ int i, Sighandler_t t); 3857 #define PERL_ARGS_ASSERT_RSIGNAL 3858 3859 PERL_CALLCONV int 3860 Perl_rsignal_restore(pTHX_ int i, Sigsave_t *t) 3861 __attribute__visibility__("hidden"); 3862 #define PERL_ARGS_ASSERT_RSIGNAL_RESTORE 3863 3864 PERL_CALLCONV int 3865 Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t *save) 3866 __attribute__visibility__("hidden"); 3867 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ 3868 assert(save) 3869 3870 PERL_CALLCONV Sighandler_t 3871 Perl_rsignal_state(pTHX_ int i); 3872 #define PERL_ARGS_ASSERT_RSIGNAL_STATE 3873 3874 PERL_CALLCONV int 3875 Perl_runops_debug(pTHX); 3876 #define PERL_ARGS_ASSERT_RUNOPS_DEBUG 3877 3878 PERL_CALLCONV int 3879 Perl_runops_standard(pTHX); 3880 #define PERL_ARGS_ASSERT_RUNOPS_STANDARD 3881 3882 PERL_CALLCONV CV * 3883 Perl_rv2cv_op_cv(pTHX_ OP *cvop, U32 flags); 3884 #define PERL_ARGS_ASSERT_RV2CV_OP_CV \ 3885 assert(cvop) 3886 3887 PERL_CALLCONV void 3888 Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) 3889 __attribute__visibility__("hidden"); 3890 #define PERL_ARGS_ASSERT_RXRES_SAVE \ 3891 assert(rsp); assert(rx) 3892 3893 PERL_CALLCONV Malloc_t 3894 Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) 3895 __attribute__malloc__ 3896 __attribute__warn_unused_result__; 3897 #define PERL_ARGS_ASSERT_SAFESYSCALLOC 3898 3899 PERL_CALLCONV Free_t 3900 Perl_safesysfree(Malloc_t where); 3901 #define PERL_ARGS_ASSERT_SAFESYSFREE 3902 3903 PERL_CALLCONV Malloc_t 3904 Perl_safesysmalloc(MEM_SIZE nbytes) 3905 __attribute__malloc__ 3906 __attribute__warn_unused_result__; 3907 #define PERL_ARGS_ASSERT_SAFESYSMALLOC 3908 3909 PERL_CALLCONV Malloc_t 3910 Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) 3911 __attribute__warn_unused_result__; 3912 #define PERL_ARGS_ASSERT_SAFESYSREALLOC 3913 3914 PERL_CALLCONV void 3915 Perl_save_I16(pTHX_ I16 *intp); 3916 #define PERL_ARGS_ASSERT_SAVE_I16 \ 3917 assert(intp) 3918 3919 PERL_CALLCONV void 3920 Perl_save_I32(pTHX_ I32 *intp); 3921 #define PERL_ARGS_ASSERT_SAVE_I32 \ 3922 assert(intp) 3923 3924 PERL_CALLCONV void 3925 Perl_save_I8(pTHX_ I8 *bytep); 3926 #define PERL_ARGS_ASSERT_SAVE_I8 \ 3927 assert(bytep) 3928 3929 PERL_CALLCONV void 3930 Perl_save_adelete(pTHX_ AV *av, SSize_t key); 3931 #define PERL_ARGS_ASSERT_SAVE_ADELETE \ 3932 assert(av) 3933 3934 /* PERL_CALLCONV void 3935 save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ 3936 3937 PERL_CALLCONV void 3938 Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags); 3939 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ 3940 assert(av); assert(sptr) 3941 3942 PERL_CALLCONV SSize_t 3943 Perl_save_alloc(pTHX_ SSize_t size, I32 pad); 3944 #define PERL_ARGS_ASSERT_SAVE_ALLOC 3945 3946 PERL_CALLCONV void 3947 Perl_save_aptr(pTHX_ AV **aptr); 3948 #define PERL_ARGS_ASSERT_SAVE_APTR \ 3949 assert(aptr) 3950 3951 PERL_CALLCONV AV * 3952 Perl_save_ary(pTHX_ GV *gv); 3953 #define PERL_ARGS_ASSERT_SAVE_ARY \ 3954 assert(gv) 3955 3956 PERL_CALLCONV void 3957 Perl_save_bool(pTHX_ bool *boolp); 3958 #define PERL_ARGS_ASSERT_SAVE_BOOL \ 3959 assert(boolp) 3960 3961 PERL_CALLCONV void 3962 Perl_save_clearsv(pTHX_ SV **svp); 3963 #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ 3964 assert(svp) 3965 3966 PERL_CALLCONV void 3967 Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen); 3968 #define PERL_ARGS_ASSERT_SAVE_DELETE \ 3969 assert(hv); assert(key) 3970 3971 PERL_CALLCONV void 3972 Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void *p); 3973 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ 3974 assert(p) 3975 3976 PERL_CALLCONV void 3977 Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p); 3978 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X 3979 3980 PERL_CALLCONV void 3981 Perl_save_freercpv(pTHX_ char *rcpv); 3982 #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ 3983 assert(rcpv) 3984 3985 PERL_CALLCONV void 3986 Perl_save_generic_pvref(pTHX_ char **str); 3987 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ 3988 assert(str) 3989 3990 PERL_CALLCONV void 3991 Perl_save_generic_svref(pTHX_ SV **sptr); 3992 #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ 3993 assert(sptr) 3994 3995 PERL_CALLCONV void 3996 Perl_save_gp(pTHX_ GV *gv, I32 empty); 3997 #define PERL_ARGS_ASSERT_SAVE_GP \ 3998 assert(gv) 3999 4000 PERL_CALLCONV HV * 4001 Perl_save_hash(pTHX_ GV *gv); 4002 #define PERL_ARGS_ASSERT_SAVE_HASH \ 4003 assert(gv) 4004 4005 PERL_CALLCONV void 4006 Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); 4007 #define PERL_ARGS_ASSERT_SAVE_HDELETE \ 4008 assert(hv); assert(keysv) 4009 4010 /* PERL_CALLCONV void 4011 save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ 4012 4013 PERL_CALLCONV void 4014 Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); 4015 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ 4016 assert(hv); assert(key); assert(sptr) 4017 4018 PERL_CALLCONV void 4019 Perl_save_hints(pTHX); 4020 #define PERL_ARGS_ASSERT_SAVE_HINTS 4021 4022 PERL_CALLCONV void 4023 Perl_save_hptr(pTHX_ HV **hptr); 4024 #define PERL_ARGS_ASSERT_SAVE_HPTR \ 4025 assert(hptr) 4026 4027 PERL_CALLCONV void 4028 Perl_save_int(pTHX_ int *intp); 4029 #define PERL_ARGS_ASSERT_SAVE_INT \ 4030 assert(intp) 4031 4032 PERL_CALLCONV void 4033 Perl_save_item(pTHX_ SV *item); 4034 #define PERL_ARGS_ASSERT_SAVE_ITEM \ 4035 assert(item) 4036 4037 PERL_CALLCONV void 4038 Perl_save_iv(pTHX_ IV *ivp); 4039 #define PERL_ARGS_ASSERT_SAVE_IV \ 4040 assert(ivp) 4041 4042 PERL_CALLCONV void 4043 Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); 4044 #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE 4045 4046 PERL_CALLCONV void 4047 Perl_save_pptr(pTHX_ char **pptr); 4048 #define PERL_ARGS_ASSERT_SAVE_PPTR \ 4049 assert(pptr) 4050 4051 PERL_CALLCONV void 4052 Perl_save_pushi32ptr(pTHX_ const I32 i, void * const ptr, const int type); 4053 #define PERL_ARGS_ASSERT_SAVE_PUSHI32PTR 4054 4055 PERL_CALLCONV void 4056 Perl_save_pushptr(pTHX_ void * const ptr, const int type); 4057 #define PERL_ARGS_ASSERT_SAVE_PUSHPTR 4058 4059 PERL_CALLCONV void 4060 Perl_save_pushptrptr(pTHX_ void * const ptr1, void * const ptr2, const int type); 4061 #define PERL_ARGS_ASSERT_SAVE_PUSHPTRPTR 4062 4063 PERL_CALLCONV void 4064 Perl_save_rcpv(pTHX_ char **prcpv); 4065 #define PERL_ARGS_ASSERT_SAVE_RCPV \ 4066 assert(prcpv) 4067 4068 PERL_CALLCONV void 4069 Perl_save_re_context(pTHX); 4070 #define PERL_ARGS_ASSERT_SAVE_RE_CONTEXT 4071 4072 PERL_CALLCONV SV * 4073 Perl_save_scalar(pTHX_ GV *gv); 4074 #define PERL_ARGS_ASSERT_SAVE_SCALAR \ 4075 assert(gv) 4076 4077 PERL_CALLCONV void 4078 Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val); 4079 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ 4080 assert(sv) 4081 4082 PERL_CALLCONV void 4083 Perl_save_shared_pvref(pTHX_ char **str); 4084 #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ 4085 assert(str) 4086 4087 PERL_CALLCONV void 4088 Perl_save_sptr(pTHX_ SV **sptr); 4089 #define PERL_ARGS_ASSERT_SAVE_SPTR \ 4090 assert(sptr) 4091 4092 PERL_CALLCONV void 4093 Perl_save_strlen(pTHX_ STRLEN *ptr); 4094 #define PERL_ARGS_ASSERT_SAVE_STRLEN \ 4095 assert(ptr) 4096 4097 PERL_CALLCONV SV * 4098 Perl_save_svref(pTHX_ SV **sptr); 4099 #define PERL_ARGS_ASSERT_SAVE_SVREF \ 4100 assert(sptr) 4101 4102 PERL_CALLCONV void 4103 Perl_save_vptr(pTHX_ void *ptr); 4104 #define PERL_ARGS_ASSERT_SAVE_VPTR \ 4105 assert(ptr) 4106 4107 PERL_CALLCONV char * 4108 Perl_savesharedpv(pTHX_ const char *pv) 4109 __attribute__malloc__ 4110 __attribute__warn_unused_result__; 4111 #define PERL_ARGS_ASSERT_SAVESHAREDPV 4112 4113 PERL_CALLCONV char * 4114 Perl_savesharedpvn(pTHX_ const char * const pv, const STRLEN len) 4115 __attribute__malloc__ 4116 __attribute__warn_unused_result__; 4117 #define PERL_ARGS_ASSERT_SAVESHAREDPVN 4118 4119 PERL_CALLCONV void 4120 Perl_savestack_grow(pTHX); 4121 #define PERL_ARGS_ASSERT_SAVESTACK_GROW 4122 4123 PERL_CALLCONV void 4124 Perl_savestack_grow_cnt(pTHX_ I32 need); 4125 #define PERL_ARGS_ASSERT_SAVESTACK_GROW_CNT 4126 4127 PERL_CALLCONV void 4128 Perl_savetmps(pTHX); 4129 #define PERL_ARGS_ASSERT_SAVETMPS 4130 4131 PERL_CALLCONV OP * 4132 Perl_sawparens(pTHX_ OP *o) 4133 __attribute__visibility__("hidden"); 4134 #define PERL_ARGS_ASSERT_SAWPARENS 4135 4136 PERL_CALLCONV OP * 4137 Perl_scalar(pTHX_ OP *o) 4138 __attribute__visibility__("hidden"); 4139 #define PERL_ARGS_ASSERT_SCALAR 4140 4141 PERL_CALLCONV OP * 4142 Perl_scalarvoid(pTHX_ OP *o) 4143 __attribute__visibility__("hidden"); 4144 #define PERL_ARGS_ASSERT_SCALARVOID \ 4145 assert(o) 4146 4147 PERL_CALLCONV NV 4148 Perl_scan_bin(pTHX_ const char *start, STRLEN len, STRLEN *retlen); 4149 #define PERL_ARGS_ASSERT_SCAN_BIN \ 4150 assert(start); assert(retlen) 4151 4152 PERL_CALLCONV NV 4153 Perl_scan_hex(pTHX_ const char *start, STRLEN len, STRLEN *retlen); 4154 #define PERL_ARGS_ASSERT_SCAN_HEX \ 4155 assert(start); assert(retlen) 4156 4157 PERL_CALLCONV char * 4158 Perl_scan_num(pTHX_ const char *s, YYSTYPE *lvalp); 4159 #define PERL_ARGS_ASSERT_SCAN_NUM \ 4160 assert(s); assert(lvalp) 4161 4162 PERL_CALLCONV NV 4163 Perl_scan_oct(pTHX_ const char *start, STRLEN len, STRLEN *retlen); 4164 #define PERL_ARGS_ASSERT_SCAN_OCT \ 4165 assert(start); assert(retlen) 4166 4167 PERL_CALLCONV char * 4168 Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) 4169 __attribute__warn_unused_result__; 4170 #define PERL_ARGS_ASSERT_SCAN_STR \ 4171 assert(start) 4172 4173 PERL_CALLCONV const char * 4174 Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv); 4175 #define PERL_ARGS_ASSERT_SCAN_VERSION \ 4176 assert(s); assert(rv) 4177 4178 PERL_CALLCONV char * 4179 Perl_scan_vstring(pTHX_ const char *s, const char * const e, SV *sv); 4180 #define PERL_ARGS_ASSERT_SCAN_VSTRING \ 4181 assert(s); assert(e); assert(sv) 4182 4183 PERL_CALLCONV char * 4184 Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); 4185 #define PERL_ARGS_ASSERT_SCAN_WORD \ 4186 assert(s); assert(dest); assert(slp) 4187 4188 PERL_CALLCONV char * 4189 Perl_scan_word6(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp, bool warn_tick); 4190 #define PERL_ARGS_ASSERT_SCAN_WORD6 \ 4191 assert(s); assert(dest); assert(slp) 4192 4193 PERL_CALLCONV U32 4194 Perl_seed(pTHX); 4195 #define PERL_ARGS_ASSERT_SEED 4196 4197 PERL_CALLCONV void 4198 Perl_set_caret_X(pTHX); 4199 #define PERL_ARGS_ASSERT_SET_CARET_X 4200 4201 PERL_CALLCONV void 4202 Perl_set_context(void *t); 4203 #define PERL_ARGS_ASSERT_SET_CONTEXT \ 4204 assert(t) 4205 4206 PERL_CALLCONV void 4207 Perl_set_numeric_standard(pTHX_ const char *file, const line_t caller_line); 4208 #define PERL_ARGS_ASSERT_SET_NUMERIC_STANDARD \ 4209 assert(file) 4210 4211 PERL_CALLCONV void 4212 Perl_set_numeric_underlying(pTHX_ const char *file, const line_t caller_line); 4213 #define PERL_ARGS_ASSERT_SET_NUMERIC_UNDERLYING \ 4214 assert(file) 4215 4216 PERL_CALLCONV void 4217 Perl_setdefout(pTHX_ GV *gv); 4218 #define PERL_ARGS_ASSERT_SETDEFOUT \ 4219 assert(gv) 4220 4221 PERL_CALLCONV void 4222 Perl_setfd_cloexec(int fd) 4223 __attribute__visibility__("hidden"); 4224 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC 4225 4226 PERL_CALLCONV void 4227 Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd) 4228 __attribute__visibility__("hidden"); 4229 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_FOR_NONSYSFD 4230 4231 PERL_CALLCONV void 4232 Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd) 4233 __attribute__visibility__("hidden"); 4234 #define PERL_ARGS_ASSERT_SETFD_CLOEXEC_OR_INHEXEC_BY_SYSFDNESS 4235 4236 PERL_CALLCONV void 4237 Perl_setfd_inhexec(int fd) 4238 __attribute__visibility__("hidden"); 4239 #define PERL_ARGS_ASSERT_SETFD_INHEXEC 4240 4241 PERL_CALLCONV void 4242 Perl_setfd_inhexec_for_sysfd(pTHX_ int fd) 4243 __attribute__visibility__("hidden"); 4244 #define PERL_ARGS_ASSERT_SETFD_INHEXEC_FOR_SYSFD 4245 4246 PERL_CALLCONV HEK * 4247 Perl_share_hek(pTHX_ const char *str, SSize_t len, U32 hash); 4248 #define PERL_ARGS_ASSERT_SHARE_HEK \ 4249 assert(str) 4250 4251 PERL_CALLCONV Signal_t 4252 Perl_sighandler1(int sig) 4253 __attribute__visibility__("hidden"); 4254 #define PERL_ARGS_ASSERT_SIGHANDLER1 4255 4256 PERL_CALLCONV Signal_t 4257 Perl_sighandler3(int sig, Siginfo_t *info, void *uap) 4258 __attribute__visibility__("hidden"); 4259 #define PERL_ARGS_ASSERT_SIGHANDLER3 4260 4261 PERL_CALLCONV char * 4262 Perl_skipspace_flags(pTHX_ char *s, U32 flags) 4263 __attribute__warn_unused_result__; 4264 #define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ 4265 assert(s) 4266 4267 PERL_CALLCONV void 4268 Perl_sortsv(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp); 4269 #define PERL_ARGS_ASSERT_SORTSV \ 4270 assert(cmp) 4271 4272 PERL_CALLCONV void 4273 Perl_sortsv_flags(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags); 4274 #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ 4275 assert(cmp) 4276 4277 PERL_CALLCONV SV ** 4278 Perl_stack_grow(pTHX_ SV **sp, SV **p, SSize_t n); 4279 #define PERL_ARGS_ASSERT_STACK_GROW \ 4280 assert(sp); assert(p) 4281 4282 PERL_CALLCONV PerlIO * 4283 Perl_start_glob(pTHX_ SV *tmpglob, IO *io) 4284 __attribute__visibility__("hidden"); 4285 #define PERL_ARGS_ASSERT_START_GLOB \ 4286 assert(tmpglob); assert(io) 4287 4288 PERL_CALLCONV I32 4289 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); 4290 #define PERL_ARGS_ASSERT_START_SUBPARSE 4291 4292 PERL_CALLCONV NV 4293 Perl_str_to_version(pTHX_ SV *sv) 4294 __attribute__warn_unused_result__; 4295 #define PERL_ARGS_ASSERT_STR_TO_VERSION \ 4296 assert(sv) 4297 4298 PERL_CALLCONV void 4299 Perl_sub_crush_depth(pTHX_ CV *cv) 4300 __attribute__visibility__("hidden"); 4301 #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ 4302 assert(cv) 4303 4304 PERL_CALLCONV void 4305 Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); 4306 #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ 4307 assert(buffer) 4308 4309 PERL_CALLCONV bool 4310 Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); 4311 #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ 4312 assert(sv) 4313 4314 PERL_CALLCONV CV * 4315 Perl_sv_2cv(pTHX_ SV *sv, HV ** const st, GV ** const gvp, const I32 lref); 4316 #define PERL_ARGS_ASSERT_SV_2CV \ 4317 assert(st); assert(gvp) 4318 4319 PERL_CALLCONV IO * 4320 Perl_sv_2io(pTHX_ SV * const sv); 4321 #define PERL_ARGS_ASSERT_SV_2IO \ 4322 assert(sv) 4323 4324 PERL_CALLCONV IV 4325 Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); 4326 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ 4327 assert(sv) 4328 4329 PERL_CALLCONV SV * 4330 Perl_sv_2mortal(pTHX_ SV * const sv); 4331 #define PERL_ARGS_ASSERT_SV_2MORTAL 4332 4333 PERL_CALLCONV SV * 4334 Perl_sv_2num(pTHX_ SV * const sv) 4335 __attribute__visibility__("hidden"); 4336 #define PERL_ARGS_ASSERT_SV_2NUM \ 4337 assert(sv) 4338 4339 PERL_CALLCONV NV 4340 Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); 4341 #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ 4342 assert(sv) 4343 4344 PERL_CALLCONV char * 4345 Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); 4346 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ 4347 assert(sv) 4348 4349 PERL_CALLCONV char * 4350 Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); 4351 #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ 4352 assert(sv) 4353 4354 PERL_CALLCONV char * 4355 Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); 4356 #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ 4357 assert(sv) 4358 4359 PERL_CALLCONV UV 4360 Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); 4361 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ 4362 assert(sv) 4363 4364 PERL_CALLCONV void 4365 Perl_sv_backoff(SV * const sv); 4366 #define PERL_ARGS_ASSERT_SV_BACKOFF \ 4367 assert(sv) 4368 4369 PERL_CALLCONV SV * 4370 Perl_sv_bless(pTHX_ SV * const sv, HV * const stash); 4371 #define PERL_ARGS_ASSERT_SV_BLESS \ 4372 assert(sv); assert(stash) 4373 4374 PERL_CALLCONV bool 4375 Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding, SV *ssv, int *offset, char *tstr, int tlen); 4376 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ 4377 assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) 4378 4379 PERL_CALLCONV void 4380 Perl_sv_catpv(pTHX_ SV * const dsv, const char *sstr); 4381 #define PERL_ARGS_ASSERT_SV_CATPV \ 4382 assert(dsv) 4383 4384 PERL_CALLCONV void 4385 Perl_sv_catpv_flags(pTHX_ SV *dsv, const char *sstr, const I32 flags); 4386 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS \ 4387 assert(dsv); assert(sstr) 4388 4389 PERL_CALLCONV void 4390 Perl_sv_catpv_mg(pTHX_ SV * const dsv, const char * const sstr); 4391 #define PERL_ARGS_ASSERT_SV_CATPV_MG \ 4392 assert(dsv) 4393 4394 PERL_CALLCONV void 4395 Perl_sv_catpvf(pTHX_ SV * const sv, const char * const pat, ...) 4396 __attribute__format__(__printf__,pTHX_2,pTHX_3); 4397 #define PERL_ARGS_ASSERT_SV_CATPVF \ 4398 assert(sv); assert(pat) 4399 4400 PERL_CALLCONV void 4401 Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) 4402 __attribute__format__(__printf__,pTHX_2,pTHX_3); 4403 #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ 4404 assert(sv); assert(pat) 4405 4406 PERL_CALLCONV void 4407 Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags); 4408 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ 4409 assert(dsv); assert(sstr) 4410 4411 PERL_CALLCONV void 4412 Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); 4413 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ 4414 assert(dsv) 4415 4416 PERL_CALLCONV void 4417 Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); 4418 #define PERL_ARGS_ASSERT_SV_CHOP \ 4419 assert(sv) 4420 4421 PERL_CALLCONV SSize_t 4422 Perl_sv_clean_all(pTHX) 4423 __attribute__visibility__("hidden"); 4424 #define PERL_ARGS_ASSERT_SV_CLEAN_ALL 4425 4426 PERL_CALLCONV void 4427 Perl_sv_clean_objs(pTHX) 4428 __attribute__visibility__("hidden"); 4429 #define PERL_ARGS_ASSERT_SV_CLEAN_OBJS 4430 4431 PERL_CALLCONV void 4432 Perl_sv_clear(pTHX_ SV * const orig_sv); 4433 #define PERL_ARGS_ASSERT_SV_CLEAR \ 4434 assert(orig_sv) 4435 4436 PERL_CALLCONV I32 4437 Perl_sv_cmp(pTHX_ SV * const sv1, SV * const sv2); 4438 #define PERL_ARGS_ASSERT_SV_CMP 4439 4440 PERL_CALLCONV I32 4441 Perl_sv_cmp_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); 4442 #define PERL_ARGS_ASSERT_SV_CMP_FLAGS 4443 4444 PERL_CALLCONV I32 4445 Perl_sv_cmp_locale(pTHX_ SV * const sv1, SV * const sv2); 4446 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE 4447 4448 PERL_CALLCONV I32 4449 Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); 4450 #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS 4451 4452 PERL_CALLCONV void 4453 Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags); 4454 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ 4455 assert(dsv); assert(ssv) 4456 4457 /* PERL_CALLCONV void 4458 sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); */ 4459 4460 PERL_CALLCONV void 4461 Perl_sv_dec(pTHX_ SV * const sv); 4462 #define PERL_ARGS_ASSERT_SV_DEC 4463 4464 PERL_CALLCONV void 4465 Perl_sv_dec_nomg(pTHX_ SV * const sv); 4466 #define PERL_ARGS_ASSERT_SV_DEC_NOMG 4467 4468 PERL_CALLCONV void 4469 Perl_sv_del_backref(pTHX_ SV * const tsv, SV * const sv); 4470 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ 4471 assert(tsv); assert(sv) 4472 4473 PERL_CALLCONV bool 4474 Perl_sv_derived_from(pTHX_ SV *sv, const char * const name) 4475 __attribute__warn_unused_result__; 4476 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ 4477 assert(sv); assert(name) 4478 4479 PERL_CALLCONV bool 4480 Perl_sv_derived_from_hv(pTHX_ SV *sv, HV *hv) 4481 __attribute__warn_unused_result__; 4482 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_HV \ 4483 assert(sv); assert(hv) 4484 4485 PERL_CALLCONV bool 4486 Perl_sv_derived_from_pv(pTHX_ SV *sv, const char * const name, U32 flags) 4487 __attribute__warn_unused_result__; 4488 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PV \ 4489 assert(sv); assert(name) 4490 4491 PERL_CALLCONV bool 4492 Perl_sv_derived_from_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) 4493 __attribute__warn_unused_result__; 4494 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_PVN \ 4495 assert(sv); assert(name) 4496 4497 PERL_CALLCONV bool 4498 Perl_sv_derived_from_sv(pTHX_ SV *sv, SV *namesv, U32 flags) 4499 __attribute__warn_unused_result__; 4500 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM_SV \ 4501 assert(sv); assert(namesv) 4502 4503 PERL_CALLCONV bool 4504 Perl_sv_destroyable(pTHX_ SV *sv); 4505 #define PERL_ARGS_ASSERT_SV_DESTROYABLE 4506 4507 PERL_CALLCONV bool 4508 Perl_sv_does(pTHX_ SV *sv, const char * const name) 4509 __attribute__warn_unused_result__; 4510 #define PERL_ARGS_ASSERT_SV_DOES \ 4511 assert(sv); assert(name) 4512 4513 PERL_CALLCONV bool 4514 Perl_sv_does_pv(pTHX_ SV *sv, const char * const name, U32 flags) 4515 __attribute__warn_unused_result__; 4516 #define PERL_ARGS_ASSERT_SV_DOES_PV \ 4517 assert(sv); assert(name) 4518 4519 PERL_CALLCONV bool 4520 Perl_sv_does_pvn(pTHX_ SV *sv, const char * const name, const STRLEN len, U32 flags) 4521 __attribute__warn_unused_result__; 4522 #define PERL_ARGS_ASSERT_SV_DOES_PVN \ 4523 assert(sv); assert(name) 4524 4525 PERL_CALLCONV bool 4526 Perl_sv_does_sv(pTHX_ SV *sv, SV *namesv, U32 flags) 4527 __attribute__warn_unused_result__; 4528 #define PERL_ARGS_ASSERT_SV_DOES_SV \ 4529 assert(sv); assert(namesv) 4530 4531 PERL_CALLCONV void 4532 Perl_sv_dump(pTHX_ SV *sv); 4533 #define PERL_ARGS_ASSERT_SV_DUMP 4534 4535 PERL_CALLCONV void 4536 Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth); 4537 #define PERL_ARGS_ASSERT_SV_DUMP_DEPTH 4538 4539 PERL_CALLCONV I32 4540 Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); 4541 #define PERL_ARGS_ASSERT_SV_EQ_FLAGS 4542 4543 PERL_CALLCONV void 4544 Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); 4545 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ 4546 assert(sv) 4547 4548 PERL_CALLCONV void 4549 Perl_sv_free(pTHX_ SV * const sv); 4550 #define PERL_ARGS_ASSERT_SV_FREE 4551 4552 PERL_CALLCONV void 4553 Perl_sv_free2(pTHX_ SV * const sv, const U32 refcnt); 4554 #define PERL_ARGS_ASSERT_SV_FREE2 \ 4555 assert(sv) 4556 4557 PERL_CALLCONV void 4558 Perl_sv_free_arenas(pTHX) 4559 __attribute__visibility__("hidden"); 4560 #define PERL_ARGS_ASSERT_SV_FREE_ARENAS 4561 4562 PERL_CALLCONV SV * 4563 Perl_sv_get_backrefs(SV * const sv); 4564 #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ 4565 assert(sv) 4566 4567 PERL_CALLCONV char * 4568 Perl_sv_gets(pTHX_ SV * const sv, PerlIO * const fp, I32 append); 4569 #define PERL_ARGS_ASSERT_SV_GETS \ 4570 assert(sv); assert(fp) 4571 4572 PERL_CALLCONV char * 4573 Perl_sv_grow(pTHX_ SV * const sv, STRLEN newlen); 4574 #define PERL_ARGS_ASSERT_SV_GROW \ 4575 assert(sv) 4576 4577 PERL_CALLCONV char * 4578 Perl_sv_grow_fresh(pTHX_ SV * const sv, STRLEN newlen); 4579 #define PERL_ARGS_ASSERT_SV_GROW_FRESH \ 4580 assert(sv) 4581 4582 PERL_CALLCONV void 4583 Perl_sv_inc(pTHX_ SV * const sv); 4584 #define PERL_ARGS_ASSERT_SV_INC 4585 4586 PERL_CALLCONV void 4587 Perl_sv_inc_nomg(pTHX_ SV * const sv); 4588 #define PERL_ARGS_ASSERT_SV_INC_NOMG 4589 4590 PERL_CALLCONV void 4591 Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); 4592 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ 4593 assert(bigstr); assert(little) 4594 4595 PERL_CALLCONV int 4596 Perl_sv_isa(pTHX_ SV *sv, const char * const name); 4597 #define PERL_ARGS_ASSERT_SV_ISA \ 4598 assert(name) 4599 4600 PERL_CALLCONV bool 4601 Perl_sv_isa_sv(pTHX_ SV *sv, SV *namesv) 4602 __attribute__warn_unused_result__; 4603 #define PERL_ARGS_ASSERT_SV_ISA_SV \ 4604 assert(sv); assert(namesv) 4605 4606 PERL_CALLCONV int 4607 Perl_sv_isobject(pTHX_ SV *sv); 4608 #define PERL_ARGS_ASSERT_SV_ISOBJECT 4609 4610 PERL_CALLCONV SV * 4611 Perl_sv_langinfo(pTHX_ const nl_item item); 4612 #define PERL_ARGS_ASSERT_SV_LANGINFO 4613 4614 PERL_CALLCONV STRLEN 4615 Perl_sv_len(pTHX_ SV * const sv); 4616 #define PERL_ARGS_ASSERT_SV_LEN 4617 4618 PERL_CALLCONV STRLEN 4619 Perl_sv_len_utf8(pTHX_ SV * const sv); 4620 #define PERL_ARGS_ASSERT_SV_LEN_UTF8 4621 4622 PERL_CALLCONV STRLEN 4623 Perl_sv_len_utf8_nomg(pTHX_ SV * const sv); 4624 #define PERL_ARGS_ASSERT_SV_LEN_UTF8_NOMG \ 4625 assert(sv) 4626 4627 PERL_CALLCONV void 4628 Perl_sv_magic(pTHX_ SV * const sv, SV * const obj, const int how, const char * const name, const I32 namlen); 4629 #define PERL_ARGS_ASSERT_SV_MAGIC \ 4630 assert(sv) 4631 4632 PERL_CALLCONV MAGIC * 4633 Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTBL * const vtbl, const char * const name, const I32 namlen); 4634 #define PERL_ARGS_ASSERT_SV_MAGICEXT \ 4635 assert(sv) 4636 4637 PERL_CALLCONV MAGIC * 4638 Perl_sv_magicext_mglob(pTHX_ SV *sv); 4639 #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ 4640 assert(sv) 4641 4642 PERL_CALLCONV SV * 4643 Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags) 4644 __attribute__warn_unused_result__; 4645 #define PERL_ARGS_ASSERT_SV_MORTALCOPY_FLAGS 4646 4647 PERL_CALLCONV SV * 4648 Perl_sv_newmortal(pTHX) 4649 __attribute__warn_unused_result__; 4650 #define PERL_ARGS_ASSERT_SV_NEWMORTAL 4651 4652 PERL_CALLCONV SV * 4653 Perl_sv_newref(pTHX_ SV * const sv); 4654 #define PERL_ARGS_ASSERT_SV_NEWREF 4655 4656 PERL_CALLCONV void 4657 Perl_sv_nosharing(pTHX_ SV *sv); 4658 #define PERL_ARGS_ASSERT_SV_NOSHARING 4659 4660 /* PERL_CALLCONV bool 4661 sv_numeq(pTHX_ SV *sv1, SV *sv2); */ 4662 4663 PERL_CALLCONV bool 4664 Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); 4665 #define PERL_ARGS_ASSERT_SV_NUMEQ_FLAGS 4666 4667 PERL_CALLCONV char * 4668 Perl_sv_peek(pTHX_ SV *sv); 4669 #define PERL_ARGS_ASSERT_SV_PEEK 4670 4671 PERL_CALLCONV void 4672 Perl_sv_pos_b2u(pTHX_ SV * const sv, I32 * const offsetp); 4673 #define PERL_ARGS_ASSERT_SV_POS_B2U \ 4674 assert(offsetp) 4675 4676 PERL_CALLCONV STRLEN 4677 Perl_sv_pos_b2u_flags(pTHX_ SV * const sv, STRLEN const offset, U32 flags); 4678 #define PERL_ARGS_ASSERT_SV_POS_B2U_FLAGS \ 4679 assert(sv) 4680 4681 PERL_CALLCONV void 4682 Perl_sv_pos_u2b(pTHX_ SV * const sv, I32 * const offsetp, I32 * const lenp); 4683 #define PERL_ARGS_ASSERT_SV_POS_U2B \ 4684 assert(offsetp) 4685 4686 PERL_CALLCONV STRLEN 4687 Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, U32 flags); 4688 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ 4689 assert(sv) 4690 4691 PERL_CALLCONV char * 4692 Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); 4693 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ 4694 assert(sv) 4695 4696 PERL_CALLCONV char * 4697 Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); 4698 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ 4699 assert(sv) 4700 4701 PERL_CALLCONV char * 4702 Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); 4703 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ 4704 assert(sv) 4705 4706 PERL_CALLCONV char * 4707 Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding); 4708 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ 4709 assert(sv); assert(encoding) 4710 4711 PERL_CALLCONV SV * 4712 Perl_sv_ref(pTHX_ SV *dst, const SV * const sv, const int ob); 4713 #define PERL_ARGS_ASSERT_SV_REF \ 4714 assert(sv) 4715 4716 PERL_CALLCONV const char * 4717 Perl_sv_reftype(pTHX_ const SV * const sv, const int ob) 4718 __attribute__warn_unused_result__; 4719 #define PERL_ARGS_ASSERT_SV_REFTYPE \ 4720 assert(sv) 4721 4722 PERL_CALLCONV void 4723 Perl_sv_replace(pTHX_ SV * const sv, SV * const nsv); 4724 #define PERL_ARGS_ASSERT_SV_REPLACE \ 4725 assert(sv); assert(nsv) 4726 4727 PERL_CALLCONV void 4728 Perl_sv_report_used(pTHX); 4729 #define PERL_ARGS_ASSERT_SV_REPORT_USED 4730 4731 PERL_CALLCONV void 4732 Perl_sv_reset(pTHX_ const char *s, HV * const stash); 4733 #define PERL_ARGS_ASSERT_SV_RESET \ 4734 assert(s) 4735 4736 PERL_CALLCONV void 4737 Perl_sv_resetpvn(pTHX_ const char *s, STRLEN len, HV * const stash) 4738 __attribute__visibility__("hidden"); 4739 #define PERL_ARGS_ASSERT_SV_RESETPVN 4740 4741 PERL_CALLCONV SV * 4742 Perl_sv_rvunweaken(pTHX_ SV * const sv); 4743 #define PERL_ARGS_ASSERT_SV_RVUNWEAKEN \ 4744 assert(sv) 4745 4746 PERL_CALLCONV SV * 4747 Perl_sv_rvweaken(pTHX_ SV * const sv); 4748 #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ 4749 assert(sv) 4750 4751 PERL_CALLCONV void 4752 Perl_sv_set_bool(pTHX_ SV *sv, const bool bool_val); 4753 #define PERL_ARGS_ASSERT_SV_SET_BOOL \ 4754 assert(sv) 4755 4756 PERL_CALLCONV void 4757 Perl_sv_set_false(pTHX_ SV *sv); 4758 #define PERL_ARGS_ASSERT_SV_SET_FALSE \ 4759 assert(sv) 4760 4761 PERL_CALLCONV void 4762 Perl_sv_set_true(pTHX_ SV *sv); 4763 #define PERL_ARGS_ASSERT_SV_SET_TRUE \ 4764 assert(sv) 4765 4766 PERL_CALLCONV void 4767 Perl_sv_set_undef(pTHX_ SV *sv); 4768 #define PERL_ARGS_ASSERT_SV_SET_UNDEF \ 4769 assert(sv) 4770 4771 PERL_CALLCONV void 4772 Perl_sv_sethek(pTHX_ SV * const sv, const HEK * const hek); 4773 #define PERL_ARGS_ASSERT_SV_SETHEK \ 4774 assert(sv) 4775 4776 PERL_CALLCONV void 4777 Perl_sv_setiv(pTHX_ SV * const sv, const IV num); 4778 #define PERL_ARGS_ASSERT_SV_SETIV \ 4779 assert(sv) 4780 4781 PERL_CALLCONV void 4782 Perl_sv_setiv_mg(pTHX_ SV * const sv, const IV i); 4783 #define PERL_ARGS_ASSERT_SV_SETIV_MG \ 4784 assert(sv) 4785 4786 PERL_CALLCONV void 4787 Perl_sv_setnv(pTHX_ SV * const sv, const NV num); 4788 #define PERL_ARGS_ASSERT_SV_SETNV \ 4789 assert(sv) 4790 4791 PERL_CALLCONV void 4792 Perl_sv_setnv_mg(pTHX_ SV * const sv, const NV num); 4793 #define PERL_ARGS_ASSERT_SV_SETNV_MG \ 4794 assert(sv) 4795 4796 PERL_CALLCONV void 4797 Perl_sv_setpv(pTHX_ SV * const sv, const char * const ptr); 4798 #define PERL_ARGS_ASSERT_SV_SETPV \ 4799 assert(sv) 4800 4801 PERL_CALLCONV char * 4802 Perl_sv_setpv_bufsize(pTHX_ SV * const sv, const STRLEN cur, const STRLEN len); 4803 #define PERL_ARGS_ASSERT_SV_SETPV_BUFSIZE \ 4804 assert(sv) 4805 4806 PERL_CALLCONV void 4807 Perl_sv_setpv_mg(pTHX_ SV * const sv, const char * const ptr); 4808 #define PERL_ARGS_ASSERT_SV_SETPV_MG \ 4809 assert(sv) 4810 4811 PERL_CALLCONV void 4812 Perl_sv_setpvf(pTHX_ SV * const sv, const char * const pat, ...) 4813 __attribute__format__(__printf__,pTHX_2,pTHX_3); 4814 #define PERL_ARGS_ASSERT_SV_SETPVF \ 4815 assert(sv); assert(pat) 4816 4817 PERL_CALLCONV void 4818 Perl_sv_setpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) 4819 __attribute__format__(__printf__,pTHX_2,pTHX_3); 4820 #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ 4821 assert(sv); assert(pat) 4822 4823 PERL_CALLCONV void 4824 Perl_sv_setpvn(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); 4825 #define PERL_ARGS_ASSERT_SV_SETPVN \ 4826 assert(sv) 4827 4828 PERL_CALLCONV void 4829 Perl_sv_setpvn_fresh(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); 4830 #define PERL_ARGS_ASSERT_SV_SETPVN_FRESH \ 4831 assert(sv) 4832 4833 PERL_CALLCONV void 4834 Perl_sv_setpvn_mg(pTHX_ SV * const sv, const char * const ptr, const STRLEN len); 4835 #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ 4836 assert(sv); assert(ptr) 4837 4838 PERL_CALLCONV SV * 4839 Perl_sv_setref_iv(pTHX_ SV * const rv, const char * const classname, const IV iv); 4840 #define PERL_ARGS_ASSERT_SV_SETREF_IV \ 4841 assert(rv) 4842 4843 PERL_CALLCONV SV * 4844 Perl_sv_setref_nv(pTHX_ SV * const rv, const char * const classname, const NV nv); 4845 #define PERL_ARGS_ASSERT_SV_SETREF_NV \ 4846 assert(rv) 4847 4848 PERL_CALLCONV SV * 4849 Perl_sv_setref_pv(pTHX_ SV * const rv, const char * const classname, void * const pv); 4850 #define PERL_ARGS_ASSERT_SV_SETREF_PV \ 4851 assert(rv) 4852 4853 PERL_CALLCONV SV * 4854 Perl_sv_setref_pvn(pTHX_ SV * const rv, const char * const classname, const char * const pv, const STRLEN n); 4855 #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ 4856 assert(rv); assert(pv) 4857 4858 PERL_CALLCONV SV * 4859 Perl_sv_setref_uv(pTHX_ SV * const rv, const char * const classname, const UV uv); 4860 #define PERL_ARGS_ASSERT_SV_SETREF_UV \ 4861 assert(rv) 4862 4863 PERL_CALLCONV void 4864 Perl_sv_setrv_inc(pTHX_ SV * const sv, SV * const ref); 4865 #define PERL_ARGS_ASSERT_SV_SETRV_INC \ 4866 assert(sv); assert(ref) 4867 4868 PERL_CALLCONV void 4869 Perl_sv_setrv_inc_mg(pTHX_ SV * const sv, SV * const ref); 4870 #define PERL_ARGS_ASSERT_SV_SETRV_INC_MG \ 4871 assert(sv); assert(ref) 4872 4873 PERL_CALLCONV void 4874 Perl_sv_setrv_noinc(pTHX_ SV * const sv, SV * const ref); 4875 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC \ 4876 assert(sv); assert(ref) 4877 4878 PERL_CALLCONV void 4879 Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); 4880 #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ 4881 assert(sv); assert(ref) 4882 4883 PERL_CALLCONV void 4884 Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); 4885 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ 4886 assert(dsv) 4887 4888 PERL_CALLCONV void 4889 Perl_sv_setsv_mg(pTHX_ SV * const dsv, SV * const ssv); 4890 #define PERL_ARGS_ASSERT_SV_SETSV_MG \ 4891 assert(dsv) 4892 4893 PERL_CALLCONV void 4894 Perl_sv_setuv(pTHX_ SV * const sv, const UV num); 4895 #define PERL_ARGS_ASSERT_SV_SETUV \ 4896 assert(sv) 4897 4898 PERL_CALLCONV void 4899 Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u); 4900 #define PERL_ARGS_ASSERT_SV_SETUV_MG \ 4901 assert(sv) 4902 4903 /* PERL_CALLCONV bool 4904 sv_streq(pTHX_ SV *sv1, SV *sv2); */ 4905 4906 PERL_CALLCONV bool 4907 Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); 4908 #define PERL_ARGS_ASSERT_SV_STREQ_FLAGS 4909 4910 PERL_CALLCONV SV * 4911 Perl_sv_strftime_ints(pTHX_ SV *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst); 4912 #define PERL_ARGS_ASSERT_SV_STRFTIME_INTS \ 4913 assert(fmt) 4914 4915 PERL_CALLCONV SV * 4916 Perl_sv_strftime_tm(pTHX_ SV *fmt, const struct tm *mytm); 4917 #define PERL_ARGS_ASSERT_SV_STRFTIME_TM \ 4918 assert(fmt); assert(mytm) 4919 4920 PERL_CALLCONV SV * 4921 Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv); 4922 #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM 4923 4924 PERL_CALLCONV bool 4925 Perl_sv_tainted(pTHX_ SV * const sv) 4926 __attribute__warn_unused_result__; 4927 #define PERL_ARGS_ASSERT_SV_TAINTED \ 4928 assert(sv) 4929 4930 PERL_CALLCONV I32 4931 Perl_sv_true(pTHX_ SV * const sv); 4932 #define PERL_ARGS_ASSERT_SV_TRUE 4933 4934 PERL_CALLCONV char * 4935 Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) 4936 __attribute__warn_unused_result__; 4937 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ 4938 assert(dsv); assert(ssv) 4939 4940 PERL_CALLCONV int 4941 Perl_sv_unmagic(pTHX_ SV * const sv, const int type); 4942 #define PERL_ARGS_ASSERT_SV_UNMAGIC \ 4943 assert(sv) 4944 4945 PERL_CALLCONV int 4946 Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); 4947 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ 4948 assert(sv) 4949 4950 PERL_CALLCONV void 4951 Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); 4952 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ 4953 assert(ref) 4954 4955 PERL_CALLCONV void 4956 Perl_sv_untaint(pTHX_ SV * const sv); 4957 #define PERL_ARGS_ASSERT_SV_UNTAINT \ 4958 assert(sv) 4959 4960 PERL_CALLCONV void 4961 Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); 4962 #define PERL_ARGS_ASSERT_SV_UPGRADE \ 4963 assert(sv) 4964 4965 PERL_CALLCONV void 4966 Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags); 4967 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ 4968 assert(sv) 4969 4970 PERL_CALLCONV bool 4971 Perl_sv_utf8_decode(pTHX_ SV * const sv); 4972 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ 4973 assert(sv) 4974 4975 PERL_CALLCONV bool 4976 Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags); 4977 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ 4978 assert(sv) 4979 4980 /* PERL_CALLCONV bool 4981 sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ 4982 4983 PERL_CALLCONV void 4984 Perl_sv_utf8_encode(pTHX_ SV * const sv); 4985 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ 4986 assert(sv) 4987 4988 /* PERL_CALLCONV STRLEN 4989 sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ 4990 4991 PERL_CALLCONV STRLEN 4992 Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra); 4993 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ 4994 assert(sv) 4995 4996 /* PERL_CALLCONV STRLEN 4997 sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ 4998 4999 PERL_CALLCONV void 5000 Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); 5001 #define PERL_ARGS_ASSERT_SV_VCATPVF \ 5002 assert(sv); assert(pat) 5003 5004 PERL_CALLCONV void 5005 Perl_sv_vcatpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); 5006 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ 5007 assert(sv); assert(pat) 5008 5009 PERL_CALLCONV void 5010 Perl_sv_vcatpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); 5011 #define PERL_ARGS_ASSERT_SV_VCATPVFN \ 5012 assert(sv); assert(pat) 5013 5014 PERL_CALLCONV void 5015 Perl_sv_vcatpvfn_flags(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted, const U32 flags); 5016 #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ 5017 assert(sv); assert(pat) 5018 5019 PERL_CALLCONV void 5020 Perl_sv_vsetpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); 5021 #define PERL_ARGS_ASSERT_SV_VSETPVF \ 5022 assert(sv); assert(pat) 5023 5024 PERL_CALLCONV void 5025 Perl_sv_vsetpvf_mg(pTHX_ SV * const sv, const char * const pat, va_list * const args); 5026 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ 5027 assert(sv); assert(pat) 5028 5029 PERL_CALLCONV void 5030 Perl_sv_vsetpvfn(pTHX_ SV * const sv, const char * const pat, const STRLEN patlen, va_list * const args, SV ** const svargs, const Size_t sv_count, bool * const maybe_tainted); 5031 #define PERL_ARGS_ASSERT_SV_VSETPVFN \ 5032 assert(sv); assert(pat) 5033 5034 PERL_CALLCONV void 5035 Perl_switch_to_global_locale(pTHX); 5036 #define PERL_ARGS_ASSERT_SWITCH_TO_GLOBAL_LOCALE 5037 5038 PERL_CALLCONV bool 5039 Perl_sync_locale(pTHX); 5040 #define PERL_ARGS_ASSERT_SYNC_LOCALE 5041 5042 PERL_CALLCONV void 5043 Perl_sys_init(int *argc, char ***argv); 5044 #define PERL_ARGS_ASSERT_SYS_INIT \ 5045 assert(argc); assert(argv) 5046 5047 PERL_CALLCONV void 5048 Perl_sys_init3(int *argc, char ***argv, char ***env); 5049 #define PERL_ARGS_ASSERT_SYS_INIT3 \ 5050 assert(argc); assert(argv); assert(env) 5051 5052 PERL_CALLCONV void 5053 Perl_sys_term(void); 5054 #define PERL_ARGS_ASSERT_SYS_TERM 5055 5056 PERL_CALLCONV void 5057 Perl_taint_env(pTHX); 5058 #define PERL_ARGS_ASSERT_TAINT_ENV 5059 5060 PERL_CALLCONV void 5061 Perl_taint_proper(pTHX_ const char *f, const char * const s); 5062 #define PERL_ARGS_ASSERT_TAINT_PROPER \ 5063 assert(s) 5064 5065 PERL_CALLCONV OP * 5066 Perl_tied_method(pTHX_ SV *methname, SV **mark, SV * const sv, const MAGIC * const mg, const U32 flags, U32 argc, ...) 5067 __attribute__visibility__("hidden"); 5068 #define PERL_ARGS_ASSERT_TIED_METHOD \ 5069 assert(methname); assert(mark); assert(sv); assert(mg) 5070 5071 PERL_CALLCONV SSize_t 5072 Perl_tmps_grow_p(pTHX_ SSize_t ix); 5073 #define PERL_ARGS_ASSERT_TMPS_GROW_P 5074 5075 /* PERL_CALLCONV UV 5076 to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ 5077 5078 PERL_CALLCONV UV 5079 Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); 5080 #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ 5081 assert(p); assert(lenp) 5082 5083 PERL_CALLCONV UV 5084 Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); 5085 #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ 5086 assert(p); assert(lenp) 5087 5088 PERL_CALLCONV UV 5089 Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); 5090 #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ 5091 assert(p); assert(lenp) 5092 5093 PERL_CALLCONV bool 5094 Perl_try_amagic_bin(pTHX_ int method, int flags); 5095 #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN 5096 5097 PERL_CALLCONV bool 5098 Perl_try_amagic_un(pTHX_ int method, int flags); 5099 #define PERL_ARGS_ASSERT_TRY_AMAGIC_UN 5100 5101 PERL_CALLCONV SSize_t 5102 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags); 5103 #define PERL_ARGS_ASSERT_UNPACKSTRING \ 5104 assert(pat); assert(patend); assert(s); assert(strend) 5105 5106 PERL_CALLCONV void 5107 Perl_unshare_hek(pTHX_ HEK *hek); 5108 #define PERL_ARGS_ASSERT_UNSHARE_HEK 5109 5110 PERL_CALLCONV void 5111 Perl_unsharepvn(pTHX_ const char *sv, I32 len, U32 hash); 5112 #define PERL_ARGS_ASSERT_UNSHAREPVN 5113 5114 PERL_CALLCONV SV * 5115 Perl_upg_version(pTHX_ SV *ver, bool qv); 5116 #define PERL_ARGS_ASSERT_UPG_VERSION \ 5117 assert(ver) 5118 5119 PERL_CALLCONV U8 * 5120 Perl_utf16_to_utf8(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen); 5121 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ 5122 assert(p); assert(d); assert(newlen) 5123 5124 PERL_CALLCONV U8 * 5125 Perl_utf16_to_utf8_base(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); 5126 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_BASE \ 5127 assert(p); assert(d); assert(newlen) 5128 5129 PERL_CALLCONV U8 * 5130 Perl_utf16_to_utf8_reversed(pTHX_ U8 *p, U8 *d, Size_t bytelen, Size_t *newlen); 5131 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ 5132 assert(p); assert(d); assert(newlen) 5133 5134 PERL_CALLCONV STRLEN 5135 Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) 5136 __attribute__warn_unused_result__; 5137 #define PERL_ARGS_ASSERT_UTF8_LENGTH \ 5138 assert(s0); assert(e) 5139 5140 PERL_CALLCONV U8 * 5141 Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); 5142 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ 5143 assert(s); assert(lenp) 5144 5145 PERL_CALLCONV U8 * 5146 Perl_utf8_to_utf16_base(pTHX_ U8 *s, U8 *d, Size_t bytelen, Size_t *newlen, const bool high, const bool low); 5147 #define PERL_ARGS_ASSERT_UTF8_TO_UTF16_BASE \ 5148 assert(s); assert(d); assert(newlen) 5149 5150 PERL_CALLCONV UV 5151 Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); 5152 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ 5153 assert(s); assert(send) 5154 5155 PERL_CALLCONV UV 5156 Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); 5157 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 5158 assert(s) 5159 5160 PERL_CALLCONV UV 5161 Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors); 5162 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR \ 5163 assert(s) 5164 5165 PERL_CALLCONV void 5166 Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) 5167 __attribute__visibility__("hidden"); 5168 #define PERL_ARGS_ASSERT_UTILIZE \ 5169 assert(idop) 5170 5171 /* PERL_CALLCONV U8 * 5172 uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ 5173 5174 /* PERL_CALLCONV U8 * 5175 uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ 5176 5177 /* PERL_CALLCONV U8 * 5178 uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ 5179 5180 PERL_CALLCONV U8 * 5181 Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); 5182 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ 5183 assert(d) 5184 5185 PERL_CALLCONV U8 * 5186 Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs); 5187 #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ 5188 assert(d) 5189 5190 PERL_CALLCONV bool 5191 Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash); 5192 #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ 5193 assert(name) 5194 5195 PERL_CALLCONV int 5196 Perl_vcmp(pTHX_ SV *lhv, SV *rhv); 5197 #define PERL_ARGS_ASSERT_VCMP \ 5198 assert(lhv); assert(rhv) 5199 5200 PERL_CALLCONV_NO_RET void 5201 Perl_vcroak(pTHX_ const char *pat, va_list *args) 5202 __attribute__noreturn__; 5203 #define PERL_ARGS_ASSERT_VCROAK 5204 5205 PERL_CALLCONV void 5206 Perl_vdeb(pTHX_ const char *pat, va_list *args); 5207 #define PERL_ARGS_ASSERT_VDEB \ 5208 assert(pat) 5209 5210 PERL_CALLCONV void 5211 Perl_vfatal_warner(pTHX_ U32 err, const char *pat, va_list *args); 5212 #define PERL_ARGS_ASSERT_VFATAL_WARNER \ 5213 assert(pat) 5214 5215 PERL_CALLCONV char * 5216 Perl_vform(pTHX_ const char *pat, va_list *args); 5217 #define PERL_ARGS_ASSERT_VFORM \ 5218 assert(pat) 5219 5220 PERL_CALLCONV void 5221 Perl_vivify_defelem(pTHX_ SV *sv); 5222 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ 5223 assert(sv) 5224 5225 PERL_CALLCONV SV * 5226 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what) 5227 __attribute__warn_unused_result__ 5228 __attribute__visibility__("hidden"); 5229 #define PERL_ARGS_ASSERT_VIVIFY_REF \ 5230 assert(sv) 5231 5232 PERL_CALLCONV void 5233 Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args); 5234 #define PERL_ARGS_ASSERT_VLOAD_MODULE \ 5235 assert(name) 5236 5237 PERL_CALLCONV SV * 5238 Perl_vmess(pTHX_ const char *pat, va_list *args); 5239 #define PERL_ARGS_ASSERT_VMESS \ 5240 assert(pat) 5241 5242 PERL_CALLCONV SV * 5243 Perl_vnewSVpvf(pTHX_ const char * const pat, va_list * const args) 5244 __attribute__warn_unused_result__; 5245 #define PERL_ARGS_ASSERT_VNEWSVPVF \ 5246 assert(pat) 5247 5248 PERL_CALLCONV SV * 5249 Perl_vnormal(pTHX_ SV *vs); 5250 #define PERL_ARGS_ASSERT_VNORMAL \ 5251 assert(vs) 5252 5253 PERL_CALLCONV SV * 5254 Perl_vnumify(pTHX_ SV *vs); 5255 #define PERL_ARGS_ASSERT_VNUMIFY \ 5256 assert(vs) 5257 5258 PERL_CALLCONV SV * 5259 Perl_vstringify(pTHX_ SV *vs); 5260 #define PERL_ARGS_ASSERT_VSTRINGIFY \ 5261 assert(vs) 5262 5263 PERL_CALLCONV SV * 5264 Perl_vverify(pTHX_ SV *vs); 5265 #define PERL_ARGS_ASSERT_VVERIFY \ 5266 assert(vs) 5267 5268 PERL_CALLCONV void 5269 Perl_vwarn(pTHX_ const char *pat, va_list *args); 5270 #define PERL_ARGS_ASSERT_VWARN \ 5271 assert(pat) 5272 5273 PERL_CALLCONV void 5274 Perl_vwarner(pTHX_ U32 err, const char *pat, va_list *args); 5275 #define PERL_ARGS_ASSERT_VWARNER \ 5276 assert(pat) 5277 5278 PERL_CALLCONV I32 5279 Perl_wait4pid(pTHX_ Pid_t pid, int *statusp, int flags) 5280 __attribute__visibility__("hidden"); 5281 #define PERL_ARGS_ASSERT_WAIT4PID \ 5282 assert(statusp) 5283 5284 PERL_CALLCONV void 5285 Perl_warn(pTHX_ const char *pat, ...) 5286 __attribute__format__(__printf__,pTHX_1,pTHX_2); 5287 #define PERL_ARGS_ASSERT_WARN \ 5288 assert(pat) 5289 5290 PERL_CALLCONV void 5291 Perl_warn_sv(pTHX_ SV *baseex); 5292 #define PERL_ARGS_ASSERT_WARN_SV \ 5293 assert(baseex) 5294 5295 PERL_CALLCONV void 5296 Perl_warner(pTHX_ U32 err, const char *pat, ...) 5297 __attribute__format__(__printf__,pTHX_2,pTHX_3); 5298 #define PERL_ARGS_ASSERT_WARNER \ 5299 assert(pat) 5300 5301 PERL_CALLCONV I32 5302 Perl_was_lvalue_sub(pTHX) 5303 __attribute__warn_unused_result__; 5304 #define PERL_ARGS_ASSERT_WAS_LVALUE_SUB 5305 5306 PERL_CALLCONV void 5307 Perl_watch(pTHX_ char **addr) 5308 __attribute__visibility__("hidden"); 5309 #define PERL_ARGS_ASSERT_WATCH \ 5310 assert(addr) 5311 5312 /* PERL_CALLCONV I32 5313 whichsig(pTHX_ const char *sig); */ 5314 5315 PERL_CALLCONV I32 5316 Perl_whichsig_pv(pTHX_ const char *sig); 5317 #define PERL_ARGS_ASSERT_WHICHSIG_PV \ 5318 assert(sig) 5319 5320 PERL_CALLCONV I32 5321 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len); 5322 #define PERL_ARGS_ASSERT_WHICHSIG_PVN \ 5323 assert(sig) 5324 5325 PERL_CALLCONV I32 5326 Perl_whichsig_sv(pTHX_ SV *sigsv); 5327 #define PERL_ARGS_ASSERT_WHICHSIG_SV \ 5328 assert(sigsv) 5329 5330 PERL_CALLCONV void 5331 Perl_wrap_infix_plugin(pTHX_ Perl_infix_plugin_t new_plugin, Perl_infix_plugin_t *old_plugin_p); 5332 #define PERL_ARGS_ASSERT_WRAP_INFIX_PLUGIN \ 5333 assert(new_plugin); assert(old_plugin_p) 5334 5335 PERL_CALLCONV void 5336 Perl_wrap_keyword_plugin(pTHX_ Perl_keyword_plugin_t new_plugin, Perl_keyword_plugin_t *old_plugin_p); 5337 #define PERL_ARGS_ASSERT_WRAP_KEYWORD_PLUGIN \ 5338 assert(new_plugin); assert(old_plugin_p) 5339 5340 PERL_CALLCONV void 5341 Perl_wrap_op_checker(pTHX_ Optype opcode, Perl_check_t new_checker, Perl_check_t *old_checker_p); 5342 #define PERL_ARGS_ASSERT_WRAP_OP_CHECKER \ 5343 assert(new_checker); assert(old_checker_p) 5344 5345 PERL_CALLCONV void 5346 Perl_write_to_stderr(pTHX_ SV *msv) 5347 __attribute__visibility__("hidden"); 5348 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ 5349 assert(msv) 5350 5351 PERL_CALLCONV void 5352 Perl_xs_boot_epilog(pTHX_ const SSize_t ax); 5353 #define PERL_ARGS_ASSERT_XS_BOOT_EPILOG 5354 5355 PERL_CALLCONV Stack_off_t 5356 Perl_xs_handshake(const U32 key, void *v_my_perl, const char *file, ...); 5357 #define PERL_ARGS_ASSERT_XS_HANDSHAKE \ 5358 assert(v_my_perl); assert(file) 5359 5360 PERL_CALLCONV int 5361 Perl_yyerror(pTHX_ const char * const s) 5362 __attribute__visibility__("hidden"); 5363 #define PERL_ARGS_ASSERT_YYERROR \ 5364 assert(s) 5365 5366 PERL_CALLCONV int 5367 Perl_yyerror_pv(pTHX_ const char * const s, U32 flags) 5368 __attribute__visibility__("hidden"); 5369 #define PERL_ARGS_ASSERT_YYERROR_PV \ 5370 assert(s) 5371 5372 PERL_CALLCONV int 5373 Perl_yyerror_pvn(pTHX_ const char * const s, STRLEN len, U32 flags) 5374 __attribute__visibility__("hidden"); 5375 #define PERL_ARGS_ASSERT_YYERROR_PVN 5376 5377 PERL_CALLCONV int 5378 Perl_yylex(pTHX); 5379 #define PERL_ARGS_ASSERT_YYLEX 5380 5381 PERL_CALLCONV int 5382 Perl_yyparse(pTHX_ int gramtype) 5383 __attribute__visibility__("hidden"); 5384 #define PERL_ARGS_ASSERT_YYPARSE 5385 5386 PERL_CALLCONV void 5387 Perl_yyquit(pTHX) 5388 __attribute__visibility__("hidden"); 5389 #define PERL_ARGS_ASSERT_YYQUIT 5390 5391 PERL_CALLCONV void 5392 Perl_yyunlex(pTHX) 5393 __attribute__visibility__("hidden"); 5394 #define PERL_ARGS_ASSERT_YYUNLEX 5395 5396 #if defined(DEBUGGING) 5397 PERL_CALLCONV int 5398 Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) 5399 __attribute__warn_unused_result__ 5400 __attribute__visibility__("hidden"); 5401 # define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ 5402 assert(s) 5403 5404 PERL_CALLCONV void 5405 Perl_hv_assert(pTHX_ HV *hv); 5406 # define PERL_ARGS_ASSERT_HV_ASSERT \ 5407 assert(hv) 5408 5409 PERL_CALLCONV void 5410 Perl_pad_setsv(pTHX_ PADOFFSET po, SV *sv); 5411 # define PERL_ARGS_ASSERT_PAD_SETSV \ 5412 assert(sv) 5413 5414 PERL_CALLCONV SV * 5415 Perl_pad_sv(pTHX_ PADOFFSET po); 5416 # define PERL_ARGS_ASSERT_PAD_SV 5417 5418 PERL_CALLCONV void 5419 Perl_set_padlist(CV *cv, PADLIST *padlist); 5420 # define PERL_ARGS_ASSERT_SET_PADLIST \ 5421 assert(cv) 5422 5423 #endif /* defined(DEBUGGING) */ 5424 #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) 5425 PERL_CALLCONV void 5426 Perl_dump_sv_child(pTHX_ SV *sv) 5427 __attribute__visibility__("hidden"); 5428 # define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ 5429 assert(sv) 5430 5431 #endif 5432 #if !defined(EBCDIC) 5433 5434 # if !defined(PERL_NO_INLINE_FUNCTIONS) 5435 PERL_STATIC_INLINE unsigned int 5436 Perl_variant_byte_number(PERL_UINTMAX_T word) 5437 __attribute__warn_unused_result__; 5438 # define PERL_ARGS_ASSERT_VARIANT_BYTE_NUMBER 5439 5440 # endif 5441 #endif 5442 #if defined(F_FREESP) && !defined(HAS_CHSIZE) && !defined(HAS_TRUNCATE) 5443 PERL_CALLCONV I32 5444 Perl_my_chsize(pTHX_ int fd, Off_t length) 5445 __attribute__warn_unused_result__; 5446 # define PERL_ARGS_ASSERT_MY_CHSIZE 5447 5448 #endif 5449 #if !defined(HAS_GETENV_LEN) 5450 PERL_CALLCONV char * 5451 Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) 5452 __attribute__visibility__("hidden"); 5453 # define PERL_ARGS_ASSERT_GETENV_LEN \ 5454 assert(env_elem); assert(len) 5455 5456 #endif 5457 #if !defined(HAS_MKOSTEMP) 5458 PERL_CALLCONV int 5459 Perl_my_mkostemp(char *templte, int flags) 5460 __attribute__visibility__("hidden"); 5461 # define PERL_ARGS_ASSERT_MY_MKOSTEMP \ 5462 assert(templte) 5463 5464 #endif 5465 #if !defined(HAS_MKSTEMP) 5466 PERL_CALLCONV int 5467 Perl_my_mkstemp(char *templte) 5468 __attribute__visibility__("hidden"); 5469 # define PERL_ARGS_ASSERT_MY_MKSTEMP \ 5470 assert(templte) 5471 5472 #endif 5473 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) 5474 PERL_CALLCONV I32 5475 Perl_do_ipcctl(pTHX_ I32 optype, SV **mark, SV **sp) 5476 __attribute__visibility__("hidden"); 5477 # define PERL_ARGS_ASSERT_DO_IPCCTL \ 5478 assert(mark); assert(sp) 5479 5480 PERL_CALLCONV I32 5481 Perl_do_ipcget(pTHX_ I32 optype, SV **mark, SV **sp) 5482 __attribute__visibility__("hidden"); 5483 # define PERL_ARGS_ASSERT_DO_IPCGET \ 5484 assert(mark); assert(sp) 5485 5486 PERL_CALLCONV SSize_t 5487 Perl_do_msgrcv(pTHX_ SV **mark, SV **sp) 5488 __attribute__visibility__("hidden"); 5489 # define PERL_ARGS_ASSERT_DO_MSGRCV \ 5490 assert(mark); assert(sp) 5491 5492 PERL_CALLCONV I32 5493 Perl_do_msgsnd(pTHX_ SV **mark, SV **sp) 5494 __attribute__visibility__("hidden"); 5495 # define PERL_ARGS_ASSERT_DO_MSGSND \ 5496 assert(mark); assert(sp) 5497 5498 PERL_CALLCONV I32 5499 Perl_do_semop(pTHX_ SV **mark, SV **sp) 5500 __attribute__visibility__("hidden"); 5501 # define PERL_ARGS_ASSERT_DO_SEMOP \ 5502 assert(mark); assert(sp) 5503 5504 PERL_CALLCONV I32 5505 Perl_do_shmio(pTHX_ I32 optype, SV **mark, SV **sp) 5506 __attribute__visibility__("hidden"); 5507 # define PERL_ARGS_ASSERT_DO_SHMIO \ 5508 assert(mark); assert(sp) 5509 5510 #endif /* defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) */ 5511 #if defined(HAS_PIPE) 5512 PERL_CALLCONV int 5513 Perl_PerlProc_pipe_cloexec(pTHX_ int *pipefd) 5514 __attribute__warn_unused_result__ 5515 __attribute__visibility__("hidden"); 5516 # define PERL_ARGS_ASSERT_PERLPROC_PIPE_CLOEXEC \ 5517 assert(pipefd) 5518 5519 #endif 5520 #if !defined(HAS_RENAME) 5521 PERL_CALLCONV I32 5522 Perl_same_dirent(pTHX_ const char *a, const char *b) 5523 __attribute__visibility__("hidden"); 5524 # define PERL_ARGS_ASSERT_SAME_DIRENT \ 5525 assert(a); assert(b) 5526 5527 #endif 5528 #if !defined(HAS_SIGNBIT) 5529 PERL_CALLCONV int 5530 Perl_signbit(NV f) 5531 __attribute__warn_unused_result__ 5532 __attribute__pure__; 5533 # define PERL_ARGS_ASSERT_PERL_SIGNBIT 5534 5535 #endif 5536 #if defined(HAS_SOCKET) 5537 PERL_CALLCONV int 5538 Perl_PerlSock_accept_cloexec(pTHX_ int listenfd, struct sockaddr *addr, Sock_size_t *addrlen) 5539 __attribute__warn_unused_result__ 5540 __attribute__visibility__("hidden"); 5541 # define PERL_ARGS_ASSERT_PERLSOCK_ACCEPT_CLOEXEC 5542 5543 PERL_CALLCONV int 5544 Perl_PerlSock_socket_cloexec(pTHX_ int domain, int type, int protocol) 5545 __attribute__warn_unused_result__ 5546 __attribute__visibility__("hidden"); 5547 # define PERL_ARGS_ASSERT_PERLSOCK_SOCKET_CLOEXEC 5548 5549 #endif /* defined(HAS_SOCKET) */ 5550 #if defined(HAS_SOCKETPAIR) || \ 5551 ( defined(AF_INET) && defined(HAS_SOCKET) && defined(PF_INET) && \ 5552 defined(SOCK_DGRAM) ) 5553 PERL_CALLCONV int 5554 Perl_PerlSock_socketpair_cloexec(pTHX_ int domain, int type, int protocol, int *pairfd) 5555 __attribute__warn_unused_result__ 5556 __attribute__visibility__("hidden"); 5557 # define PERL_ARGS_ASSERT_PERLSOCK_SOCKETPAIR_CLOEXEC \ 5558 assert(pairfd) 5559 5560 #endif 5561 #if !defined(HAS_STRLCPY) 5562 STATIC Size_t 5563 Perl_my_strlcpy(char *dst, const char *src, Size_t size); 5564 # define PERL_ARGS_ASSERT_MY_STRLCPY 5565 5566 #endif 5567 #if defined(HAVE_INTERP_INTERN) 5568 PERL_CALLCONV void 5569 Perl_sys_intern_clear(pTHX); 5570 # define PERL_ARGS_ASSERT_SYS_INTERN_CLEAR 5571 5572 PERL_CALLCONV void 5573 Perl_sys_intern_init(pTHX); 5574 # define PERL_ARGS_ASSERT_SYS_INTERN_INIT 5575 5576 # if defined(USE_ITHREADS) 5577 PERL_CALLCONV void 5578 Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst); 5579 # define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ 5580 assert(src); assert(dst) 5581 5582 # endif 5583 #endif /* defined(HAVE_INTERP_INTERN) */ 5584 #if defined(_MSC_VER) 5585 PERL_CALLCONV int 5586 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) 5587 __attribute__visibility__("hidden"); 5588 # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 5589 assert(sv); assert(mg) 5590 5591 #else 5592 PERL_CALLCONV_NO_RET int 5593 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg) 5594 __attribute__noreturn__ 5595 __attribute__visibility__("hidden"); 5596 # define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 5597 assert(sv); assert(mg) 5598 5599 #endif 5600 #if defined(MULTIPLICITY) 5601 PERL_CALLCONV_NO_RET void 5602 Perl_croak_nocontext(const char *pat, ...) 5603 __attribute__noreturn__ 5604 __attribute__format__null_ok__(__printf__,1,2); 5605 # define PERL_ARGS_ASSERT_CROAK_NOCONTEXT 5606 5607 PERL_CALLCONV void 5608 Perl_deb_nocontext(const char *pat, ...) 5609 __attribute__format__(__printf__,1,2); 5610 # define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ 5611 assert(pat) 5612 5613 PERL_CALLCONV_NO_RET OP * 5614 Perl_die_nocontext(const char *pat, ...) 5615 __attribute__noreturn__ 5616 __attribute__format__null_ok__(__printf__,1,2); 5617 # define PERL_ARGS_ASSERT_DIE_NOCONTEXT 5618 5619 PERL_CALLCONV char * 5620 Perl_form_nocontext(const char *pat, ...) 5621 __attribute__format__(__printf__,1,2); 5622 # define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ 5623 assert(pat) 5624 5625 PERL_CALLCONV void 5626 Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...); 5627 # define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ 5628 assert(name) 5629 5630 PERL_CALLCONV SV * 5631 Perl_mess_nocontext(const char *pat, ...) 5632 __attribute__format__(__printf__,1,2); 5633 # define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ 5634 assert(pat) 5635 5636 PERL_CALLCONV void * 5637 Perl_my_cxt_init(pTHX_ int *indexp, size_t size); 5638 # define PERL_ARGS_ASSERT_MY_CXT_INIT \ 5639 assert(indexp) 5640 5641 PERL_CALLCONV SV * 5642 Perl_newSVpvf_nocontext(const char * const pat, ...) 5643 __attribute__format__(__printf__,1,2); 5644 # define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ 5645 assert(pat) 5646 5647 PERL_CALLCONV void 5648 Perl_sv_catpvf_mg_nocontext(SV * const sv, const char * const pat, ...) 5649 __attribute__format__(__printf__,2,3); 5650 # define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ 5651 assert(sv); assert(pat) 5652 5653 PERL_CALLCONV void 5654 Perl_sv_catpvf_nocontext(SV * const sv, const char * const pat, ...) 5655 __attribute__format__(__printf__,2,3); 5656 # define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ 5657 assert(sv); assert(pat) 5658 5659 PERL_CALLCONV void 5660 Perl_sv_setpvf_mg_nocontext(SV * const sv, const char * const pat, ...) 5661 __attribute__format__(__printf__,2,3); 5662 # define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ 5663 assert(sv); assert(pat) 5664 5665 PERL_CALLCONV void 5666 Perl_sv_setpvf_nocontext(SV * const sv, const char * const pat, ...) 5667 __attribute__format__(__printf__,2,3); 5668 # define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ 5669 assert(sv); assert(pat) 5670 5671 PERL_CALLCONV void 5672 Perl_warn_nocontext(const char *pat, ...) 5673 __attribute__format__(__printf__,1,2); 5674 # define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ 5675 assert(pat) 5676 5677 PERL_CALLCONV void 5678 Perl_warner_nocontext(U32 err, const char *pat, ...) 5679 __attribute__format__(__printf__,2,3); 5680 # define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ 5681 assert(pat) 5682 5683 #endif /* defined(MULTIPLICITY) */ 5684 #if defined(MYMALLOC) 5685 PERL_CALLCONV void 5686 Perl_dump_mstats(pTHX_ const char *s); 5687 # define PERL_ARGS_ASSERT_DUMP_MSTATS \ 5688 assert(s) 5689 5690 PERL_CALLCONV int 5691 Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level); 5692 # define PERL_ARGS_ASSERT_GET_MSTATS \ 5693 assert(buf) 5694 5695 PERL_CALLCONV MEM_SIZE 5696 Perl_malloc_good_size(size_t nbytes) 5697 __attribute__warn_unused_result__ 5698 __attribute__visibility__("hidden"); 5699 # define PERL_ARGS_ASSERT_MALLOC_GOOD_SIZE 5700 5701 PERL_CALLCONV MEM_SIZE 5702 Perl_malloced_size(void *p) 5703 __attribute__warn_unused_result__ 5704 __attribute__visibility__("hidden"); 5705 # define PERL_ARGS_ASSERT_MALLOCED_SIZE \ 5706 assert(p) 5707 5708 #endif /* defined(MYMALLOC) */ 5709 #if !defined(NO_MATHOMS) 5710 PERL_CALLCONV bool 5711 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); 5712 # define PERL_ARGS_ASSERT_DO_AEXEC \ 5713 assert(mark); assert(sp) 5714 5715 PERL_CALLCONV bool 5716 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); 5717 # define PERL_ARGS_ASSERT_DO_OPEN \ 5718 assert(gv); assert(name) 5719 5720 PERL_CALLCONV GV * 5721 Perl_gv_AVadd(pTHX_ GV *gv); 5722 # define PERL_ARGS_ASSERT_GV_AVADD 5723 5724 PERL_CALLCONV GV * 5725 Perl_gv_HVadd(pTHX_ GV *gv); 5726 # define PERL_ARGS_ASSERT_GV_HVADD 5727 5728 PERL_CALLCONV GV * 5729 Perl_gv_IOadd(pTHX_ GV *gv); 5730 # define PERL_ARGS_ASSERT_GV_IOADD 5731 5732 PERL_CALLCONV void 5733 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); 5734 # define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ 5735 assert(sv); assert(gv) 5736 5737 PERL_CALLCONV GV * 5738 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); 5739 # define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ 5740 assert(stash); assert(name) 5741 5742 PERL_CALLCONV void 5743 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); 5744 # define PERL_ARGS_ASSERT_GV_FULLNAME3 \ 5745 assert(sv); assert(gv) 5746 5747 PERL_CALLCONV SV * 5748 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); 5749 # define PERL_ARGS_ASSERT_HV_DELETE \ 5750 assert(key) 5751 5752 PERL_CALLCONV SV * 5753 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); 5754 # define PERL_ARGS_ASSERT_HV_DELETE_ENT \ 5755 assert(keysv) 5756 5757 PERL_CALLCONV bool 5758 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) 5759 __attribute__warn_unused_result__; 5760 # define PERL_ARGS_ASSERT_HV_EXISTS \ 5761 assert(key) 5762 5763 PERL_CALLCONV bool 5764 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) 5765 __attribute__warn_unused_result__; 5766 # define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ 5767 assert(keysv) 5768 5769 PERL_CALLCONV SV ** 5770 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); 5771 # define PERL_ARGS_ASSERT_HV_FETCH \ 5772 assert(key) 5773 5774 PERL_CALLCONV HE * 5775 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); 5776 # define PERL_ARGS_ASSERT_HV_FETCH_ENT \ 5777 assert(keysv) 5778 5779 PERL_CALLCONV HE * 5780 Perl_hv_iternext(pTHX_ HV *hv) 5781 __attribute__warn_unused_result__; 5782 # define PERL_ARGS_ASSERT_HV_ITERNEXT \ 5783 assert(hv) 5784 5785 PERL_CALLCONV void 5786 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); 5787 # define PERL_ARGS_ASSERT_HV_MAGIC \ 5788 assert(hv) 5789 5790 PERL_CALLCONV SV ** 5791 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); 5792 # define PERL_ARGS_ASSERT_HV_STORE 5793 5794 PERL_CALLCONV HE * 5795 Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); 5796 # define PERL_ARGS_ASSERT_HV_STORE_ENT 5797 5798 PERL_CALLCONV SV ** 5799 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); 5800 # define PERL_ARGS_ASSERT_HV_STORE_FLAGS 5801 5802 PERL_CALLCONV char * 5803 Perl_instr(const char *big, const char *little) 5804 __attribute__warn_unused_result__ 5805 __attribute__pure__; 5806 # define PERL_ARGS_ASSERT_INSTR \ 5807 assert(big); assert(little) 5808 5809 PERL_CALLCONV STRLEN 5810 Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); 5811 # define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ 5812 assert(buf); assert(buf_end) 5813 5814 PERL_CALLCONV bool 5815 Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); 5816 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ 5817 assert(s); assert(ep) 5818 5819 PERL_CALLCONV AV * 5820 Perl_newAV(pTHX) 5821 __attribute__warn_unused_result__; 5822 # define PERL_ARGS_ASSERT_NEWAV 5823 5824 PERL_CALLCONV HV * 5825 Perl_newHV(pTHX) 5826 __attribute__warn_unused_result__; 5827 # define PERL_ARGS_ASSERT_NEWHV 5828 5829 PERL_CALLCONV IO * 5830 Perl_newIO(pTHX) 5831 __attribute__warn_unused_result__; 5832 # define PERL_ARGS_ASSERT_NEWIO 5833 5834 PERL_CALLCONV CV * 5835 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); 5836 # define PERL_ARGS_ASSERT_NEWSUB 5837 5838 PERL_CALLCONV SV * 5839 Perl_newSVsv(pTHX_ SV * const old) 5840 __attribute__warn_unused_result__; 5841 # define PERL_ARGS_ASSERT_NEWSVSV 5842 5843 PERL_CALLCONV void 5844 Perl_save_freeop(pTHX_ OP *o); 5845 # define PERL_ARGS_ASSERT_SAVE_FREEOP 5846 5847 PERL_CALLCONV void 5848 Perl_save_freepv(pTHX_ char *pv); 5849 # define PERL_ARGS_ASSERT_SAVE_FREEPV 5850 5851 PERL_CALLCONV void 5852 Perl_save_freesv(pTHX_ SV *sv); 5853 # define PERL_ARGS_ASSERT_SAVE_FREESV 5854 5855 PERL_CALLCONV void 5856 Perl_save_mortalizesv(pTHX_ SV *sv); 5857 # define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ 5858 assert(sv) 5859 5860 PERL_CALLCONV void 5861 Perl_save_op(pTHX); 5862 # define PERL_ARGS_ASSERT_SAVE_OP 5863 5864 PERL_CALLCONV bool 5865 Perl_sv_2bool(pTHX_ SV * const sv); 5866 # define PERL_ARGS_ASSERT_SV_2BOOL \ 5867 assert(sv) 5868 5869 PERL_CALLCONV IV 5870 Perl_sv_2iv(pTHX_ SV *sv); 5871 # define PERL_ARGS_ASSERT_SV_2IV \ 5872 assert(sv) 5873 5874 PERL_CALLCONV char * 5875 Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); 5876 # define PERL_ARGS_ASSERT_SV_2PV \ 5877 assert(sv) 5878 5879 PERL_CALLCONV char * 5880 Perl_sv_2pv_nolen(pTHX_ SV *sv) 5881 __attribute__warn_unused_result__; 5882 # define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ 5883 assert(sv) 5884 5885 PERL_CALLCONV char * 5886 Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); 5887 # define PERL_ARGS_ASSERT_SV_2PVBYTE \ 5888 assert(sv) 5889 5890 PERL_CALLCONV char * 5891 Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) 5892 __attribute__warn_unused_result__; 5893 # define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ 5894 assert(sv) 5895 5896 PERL_CALLCONV char * 5897 Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); 5898 # define PERL_ARGS_ASSERT_SV_2PVUTF8 \ 5899 assert(sv) 5900 5901 PERL_CALLCONV char * 5902 Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) 5903 __attribute__warn_unused_result__; 5904 # define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ 5905 assert(sv) 5906 5907 PERL_CALLCONV UV 5908 Perl_sv_2uv(pTHX_ SV *sv); 5909 # define PERL_ARGS_ASSERT_SV_2UV \ 5910 assert(sv) 5911 5912 PERL_CALLCONV void 5913 Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len); 5914 # define PERL_ARGS_ASSERT_SV_CATPVN \ 5915 assert(dsv); assert(sstr) 5916 5917 PERL_CALLCONV void 5918 Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len); 5919 # define PERL_ARGS_ASSERT_SV_CATPVN_MG \ 5920 assert(dsv); assert(sstr) 5921 5922 PERL_CALLCONV void 5923 Perl_sv_catsv(pTHX_ SV *dsv, SV *sstr); 5924 # define PERL_ARGS_ASSERT_SV_CATSV \ 5925 assert(dsv) 5926 5927 PERL_CALLCONV void 5928 Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *sstr); 5929 # define PERL_ARGS_ASSERT_SV_CATSV_MG \ 5930 assert(dsv) 5931 5932 PERL_CALLCONV void 5933 Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); 5934 # define PERL_ARGS_ASSERT_SV_COPYPV \ 5935 assert(dsv); assert(ssv) 5936 5937 PERL_CALLCONV I32 5938 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); 5939 # define PERL_ARGS_ASSERT_SV_EQ 5940 5941 PERL_CALLCONV void 5942 Perl_sv_force_normal(pTHX_ SV *sv); 5943 # define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ 5944 assert(sv) 5945 5946 PERL_CALLCONV void 5947 Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); 5948 # define PERL_ARGS_ASSERT_SV_INSERT \ 5949 assert(bigstr); assert(little) 5950 5951 PERL_CALLCONV SV * 5952 Perl_sv_mortalcopy(pTHX_ SV * const oldsv) 5953 __attribute__warn_unused_result__; 5954 # define PERL_ARGS_ASSERT_SV_MORTALCOPY 5955 5956 PERL_CALLCONV void 5957 Perl_sv_nolocking(pTHX_ SV *sv) 5958 __attribute__deprecated__; 5959 # define PERL_ARGS_ASSERT_SV_NOLOCKING 5960 5961 PERL_CALLCONV void 5962 Perl_sv_nounlocking(pTHX_ SV *sv) 5963 __attribute__deprecated__; 5964 # define PERL_ARGS_ASSERT_SV_NOUNLOCKING 5965 5966 PERL_CALLCONV char * 5967 Perl_sv_pv(pTHX_ SV *sv) 5968 __attribute__warn_unused_result__; 5969 # define PERL_ARGS_ASSERT_SV_PV \ 5970 assert(sv) 5971 5972 PERL_CALLCONV char * 5973 Perl_sv_pvbyte(pTHX_ SV *sv) 5974 __attribute__warn_unused_result__; 5975 # define PERL_ARGS_ASSERT_SV_PVBYTE \ 5976 assert(sv) 5977 5978 PERL_CALLCONV char * 5979 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); 5980 # define PERL_ARGS_ASSERT_SV_PVN_FORCE \ 5981 assert(sv) 5982 5983 PERL_CALLCONV char * 5984 Perl_sv_pvutf8(pTHX_ SV *sv) 5985 __attribute__warn_unused_result__; 5986 # define PERL_ARGS_ASSERT_SV_PVUTF8 \ 5987 assert(sv) 5988 5989 PERL_CALLCONV void 5990 Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); 5991 # define PERL_ARGS_ASSERT_SV_SETSV \ 5992 assert(dsv) 5993 5994 PERL_CALLCONV void 5995 Perl_sv_taint(pTHX_ SV *sv); 5996 # define PERL_ARGS_ASSERT_SV_TAINT \ 5997 assert(sv) 5998 5999 PERL_CALLCONV void 6000 Perl_sv_unref(pTHX_ SV *sv); 6001 # define PERL_ARGS_ASSERT_SV_UNREF \ 6002 assert(sv) 6003 6004 PERL_CALLCONV void 6005 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); 6006 # define PERL_ARGS_ASSERT_SV_USEPVN \ 6007 assert(sv) 6008 6009 PERL_CALLCONV void 6010 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); 6011 # define PERL_ARGS_ASSERT_SV_USEPVN_MG \ 6012 assert(sv) 6013 6014 PERL_CALLCONV bool 6015 Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); 6016 # define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ 6017 assert(sv) 6018 6019 PERL_CALLCONV STRLEN 6020 Perl_sv_utf8_upgrade(pTHX_ SV *sv); 6021 # define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ 6022 assert(sv) 6023 6024 PERL_CALLCONV UV 6025 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 6026 __attribute__deprecated__; 6027 # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ 6028 assert(s) 6029 6030 PERL_CALLCONV UV 6031 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 6032 __attribute__deprecated__; 6033 # define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ 6034 assert(s) 6035 6036 PERL_CALLCONV UV 6037 Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 6038 __attribute__deprecated__; 6039 # define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ 6040 assert(s) 6041 6042 PERL_CALLCONV U8 * 6043 Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) 6044 __attribute__deprecated__; 6045 # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ 6046 assert(d) 6047 6048 # if defined(PERL_DONT_CREATE_GVSV) 6049 PERL_CALLCONV GV * 6050 Perl_gv_SVadd(pTHX_ GV *gv); 6051 # define PERL_ARGS_ASSERT_GV_SVADD 6052 6053 # endif 6054 # if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ 6055 defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) 6056 PERL_CALLCONV OP * 6057 Perl_ref(pTHX_ OP *o, I32 type); 6058 # define PERL_ARGS_ASSERT_REF 6059 6060 # endif 6061 # if defined(USE_LOCALE_COLLATE) 6062 PERL_CALLCONV char * 6063 Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); 6064 # define PERL_ARGS_ASSERT_SV_COLLXFRM \ 6065 assert(sv); assert(nxp) 6066 6067 # endif 6068 #endif /* !defined(NO_MATHOMS) */ 6069 #if defined(PERL_ANY_COW) 6070 PERL_CALLCONV SV * 6071 Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv); 6072 # define PERL_ARGS_ASSERT_SV_SETSV_COW \ 6073 assert(ssv) 6074 6075 #endif 6076 #if defined(PERL_CORE) 6077 PERL_CALLCONV void 6078 Perl_opslab_force_free(pTHX_ OPSLAB *slab) 6079 __attribute__visibility__("hidden"); 6080 # define PERL_ARGS_ASSERT_OPSLAB_FORCE_FREE \ 6081 assert(slab) 6082 6083 PERL_CALLCONV void 6084 Perl_opslab_free(pTHX_ OPSLAB *slab) 6085 __attribute__visibility__("hidden"); 6086 # define PERL_ARGS_ASSERT_OPSLAB_FREE \ 6087 assert(slab) 6088 6089 PERL_CALLCONV void 6090 Perl_opslab_free_nopad(pTHX_ OPSLAB *slab) 6091 __attribute__visibility__("hidden"); 6092 # define PERL_ARGS_ASSERT_OPSLAB_FREE_NOPAD \ 6093 assert(slab) 6094 6095 PERL_CALLCONV void 6096 Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab) 6097 __attribute__visibility__("hidden"); 6098 # define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ 6099 assert(parser); assert(slab) 6100 6101 # if defined(PERL_DEBUG_READONLY_OPS) 6102 PERL_CALLCONV void 6103 Perl_Slab_to_ro(pTHX_ OPSLAB *slab); 6104 # define PERL_ARGS_ASSERT_SLAB_TO_RO \ 6105 assert(slab) 6106 6107 PERL_CALLCONV void 6108 Perl_Slab_to_rw(pTHX_ OPSLAB * const slab); 6109 # define PERL_ARGS_ASSERT_SLAB_TO_RW \ 6110 assert(slab) 6111 6112 # endif /* defined(PERL_DEBUG_READONLY_OPS) */ 6113 # if !defined(PERL_NO_INLINE_FUNCTIONS) 6114 PERL_STATIC_INLINE bool 6115 S_should_warn_nl(const char *pv) 6116 __attribute__warn_unused_result__; 6117 # define PERL_ARGS_ASSERT_SHOULD_WARN_NL \ 6118 assert(pv) 6119 6120 # endif 6121 #endif /* defined(PERL_CORE) */ 6122 #if defined(PERL_CORE) || defined(PERL_EXT) 6123 PERL_CALLCONV bool 6124 Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) 6125 __attribute__warn_unused_result__; 6126 # define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ 6127 assert(s); assert(send) 6128 6129 #endif /* defined(PERL_CORE) || defined(PERL_EXT) */ 6130 #if defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) 6131 PERL_CALLCONV void 6132 Perl_finalize_optree(pTHX_ OP *o); 6133 # define PERL_ARGS_ASSERT_FINALIZE_OPTREE \ 6134 assert(o) 6135 6136 PERL_CALLCONV void 6137 Perl_optimize_optree(pTHX_ OP *o); 6138 # define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ 6139 assert(o) 6140 6141 #endif /* defined(PERL_CORE) || defined(PERL_USE_VOLATILE_API) */ 6142 #if defined(PERL_DEBUG_READONLY_COW) 6143 PERL_CALLCONV void 6144 Perl_sv_buf_to_ro(pTHX_ SV *sv) 6145 __attribute__visibility__("hidden"); 6146 # define PERL_ARGS_ASSERT_SV_BUF_TO_RO \ 6147 assert(sv) 6148 6149 #endif 6150 #if defined(PERL_DEBUG_READONLY_OPS) 6151 PERL_CALLCONV PADOFFSET 6152 Perl_op_refcnt_dec(pTHX_ OP *o); 6153 # define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ 6154 assert(o) 6155 6156 PERL_CALLCONV OP * 6157 Perl_op_refcnt_inc(pTHX_ OP *o); 6158 # define PERL_ARGS_ASSERT_OP_REFCNT_INC 6159 6160 #endif /* defined(PERL_DEBUG_READONLY_OPS) */ 6161 #if defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION) 6162 PERL_CALLCONV bool 6163 Perl_do_exec(pTHX_ const char *cmd) 6164 __attribute__visibility__("hidden"); 6165 # define PERL_ARGS_ASSERT_DO_EXEC \ 6166 assert(cmd) 6167 6168 #else 6169 PERL_CALLCONV bool 6170 Perl_do_exec(pTHX_ const char *cmd) 6171 __attribute__visibility__("hidden"); 6172 # define PERL_ARGS_ASSERT_DO_EXEC \ 6173 assert(cmd) 6174 6175 #endif 6176 #if defined(PERL_IMPLICIT_SYS) 6177 PERL_CALLCONV PerlInterpreter * 6178 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); 6179 # define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ 6180 assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); \ 6181 assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 6182 6183 # if defined(USE_ITHREADS) 6184 PERL_CALLCONV PerlInterpreter * 6185 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); 6186 # define PERL_ARGS_ASSERT_PERL_CLONE_USING \ 6187 assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); \ 6188 assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 6189 6190 # endif 6191 #else /* if !defined(PERL_IMPLICIT_SYS) */ 6192 PERL_CALLCONV I32 6193 Perl_my_pclose(pTHX_ PerlIO *ptr); 6194 # define PERL_ARGS_ASSERT_MY_PCLOSE 6195 6196 PERL_CALLCONV PerlIO * 6197 Perl_my_popen(pTHX_ const char *cmd, const char *mode); 6198 # define PERL_ARGS_ASSERT_MY_POPEN \ 6199 assert(cmd); assert(mode) 6200 6201 #endif /* !defined(PERL_IMPLICIT_SYS) */ 6202 #if defined(PERL_IN_AV_C) 6203 STATIC MAGIC * 6204 S_get_aux_mg(pTHX_ AV *av); 6205 # define PERL_ARGS_ASSERT_GET_AUX_MG \ 6206 assert(av) 6207 6208 #endif 6209 #if defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) 6210 PERL_CALLCONV void 6211 Perl_finish_export_lexical(pTHX) 6212 __attribute__visibility__("hidden"); 6213 # define PERL_ARGS_ASSERT_FINISH_EXPORT_LEXICAL 6214 6215 PERL_CALLCONV void 6216 Perl_import_builtin_bundle(pTHX_ U16 ver) 6217 __attribute__visibility__("hidden"); 6218 # define PERL_ARGS_ASSERT_IMPORT_BUILTIN_BUNDLE 6219 6220 PERL_CALLCONV void 6221 Perl_prepare_export_lexical(pTHX) 6222 __attribute__visibility__("hidden"); 6223 # define PERL_ARGS_ASSERT_PREPARE_EXPORT_LEXICAL 6224 6225 #endif /* defined(PERL_IN_BUILTIN_C) || defined(PERL_IN_OP_C) */ 6226 #if defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) || \ 6227 defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) 6228 PERL_CALLCONV OP * 6229 Perl_ck_anoncode(pTHX_ OP *o) 6230 __attribute__warn_unused_result__ 6231 __attribute__visibility__("hidden"); 6232 # define PERL_ARGS_ASSERT_CK_ANONCODE \ 6233 assert(o) 6234 6235 PERL_CALLCONV OP * 6236 Perl_ck_backtick(pTHX_ OP *o) 6237 __attribute__warn_unused_result__ 6238 __attribute__visibility__("hidden"); 6239 # define PERL_ARGS_ASSERT_CK_BACKTICK \ 6240 assert(o) 6241 6242 PERL_CALLCONV OP * 6243 Perl_ck_bitop(pTHX_ OP *o) 6244 __attribute__warn_unused_result__ 6245 __attribute__visibility__("hidden"); 6246 # define PERL_ARGS_ASSERT_CK_BITOP \ 6247 assert(o) 6248 6249 PERL_CALLCONV OP * 6250 Perl_ck_classname(pTHX_ OP *o) 6251 __attribute__warn_unused_result__ 6252 __attribute__visibility__("hidden"); 6253 # define PERL_ARGS_ASSERT_CK_CLASSNAME \ 6254 assert(o) 6255 6256 PERL_CALLCONV OP * 6257 Perl_ck_cmp(pTHX_ OP *o) 6258 __attribute__warn_unused_result__ 6259 __attribute__visibility__("hidden"); 6260 # define PERL_ARGS_ASSERT_CK_CMP \ 6261 assert(o) 6262 6263 PERL_CALLCONV OP * 6264 Perl_ck_concat(pTHX_ OP *o) 6265 __attribute__warn_unused_result__ 6266 __attribute__visibility__("hidden"); 6267 # define PERL_ARGS_ASSERT_CK_CONCAT \ 6268 assert(o) 6269 6270 PERL_CALLCONV OP * 6271 Perl_ck_defined(pTHX_ OP *o) 6272 __attribute__warn_unused_result__ 6273 __attribute__visibility__("hidden"); 6274 # define PERL_ARGS_ASSERT_CK_DEFINED \ 6275 assert(o) 6276 6277 PERL_CALLCONV OP * 6278 Perl_ck_delete(pTHX_ OP *o) 6279 __attribute__warn_unused_result__ 6280 __attribute__visibility__("hidden"); 6281 # define PERL_ARGS_ASSERT_CK_DELETE \ 6282 assert(o) 6283 6284 PERL_CALLCONV OP * 6285 Perl_ck_each(pTHX_ OP *o) 6286 __attribute__warn_unused_result__ 6287 __attribute__visibility__("hidden"); 6288 # define PERL_ARGS_ASSERT_CK_EACH \ 6289 assert(o) 6290 6291 PERL_CALLCONV OP * 6292 Perl_ck_eof(pTHX_ OP *o) 6293 __attribute__warn_unused_result__ 6294 __attribute__visibility__("hidden"); 6295 # define PERL_ARGS_ASSERT_CK_EOF \ 6296 assert(o) 6297 6298 PERL_CALLCONV OP * 6299 Perl_ck_eval(pTHX_ OP *o) 6300 __attribute__warn_unused_result__ 6301 __attribute__visibility__("hidden"); 6302 # define PERL_ARGS_ASSERT_CK_EVAL \ 6303 assert(o) 6304 6305 PERL_CALLCONV OP * 6306 Perl_ck_exec(pTHX_ OP *o) 6307 __attribute__warn_unused_result__ 6308 __attribute__visibility__("hidden"); 6309 # define PERL_ARGS_ASSERT_CK_EXEC \ 6310 assert(o) 6311 6312 PERL_CALLCONV OP * 6313 Perl_ck_exists(pTHX_ OP *o) 6314 __attribute__warn_unused_result__ 6315 __attribute__visibility__("hidden"); 6316 # define PERL_ARGS_ASSERT_CK_EXISTS \ 6317 assert(o) 6318 6319 PERL_CALLCONV OP * 6320 Perl_ck_ftst(pTHX_ OP *o) 6321 __attribute__warn_unused_result__ 6322 __attribute__visibility__("hidden"); 6323 # define PERL_ARGS_ASSERT_CK_FTST \ 6324 assert(o) 6325 6326 PERL_CALLCONV OP * 6327 Perl_ck_fun(pTHX_ OP *o) 6328 __attribute__warn_unused_result__ 6329 __attribute__visibility__("hidden"); 6330 # define PERL_ARGS_ASSERT_CK_FUN \ 6331 assert(o) 6332 6333 PERL_CALLCONV OP * 6334 Perl_ck_glob(pTHX_ OP *o) 6335 __attribute__warn_unused_result__ 6336 __attribute__visibility__("hidden"); 6337 # define PERL_ARGS_ASSERT_CK_GLOB \ 6338 assert(o) 6339 6340 PERL_CALLCONV OP * 6341 Perl_ck_grep(pTHX_ OP *o) 6342 __attribute__warn_unused_result__ 6343 __attribute__visibility__("hidden"); 6344 # define PERL_ARGS_ASSERT_CK_GREP \ 6345 assert(o) 6346 6347 PERL_CALLCONV OP * 6348 Perl_ck_helemexistsor(pTHX_ OP *o) 6349 __attribute__warn_unused_result__ 6350 __attribute__visibility__("hidden"); 6351 # define PERL_ARGS_ASSERT_CK_HELEMEXISTSOR \ 6352 assert(o) 6353 6354 PERL_CALLCONV OP * 6355 Perl_ck_index(pTHX_ OP *o) 6356 __attribute__warn_unused_result__ 6357 __attribute__visibility__("hidden"); 6358 # define PERL_ARGS_ASSERT_CK_INDEX \ 6359 assert(o) 6360 6361 PERL_CALLCONV OP * 6362 Perl_ck_isa(pTHX_ OP *o) 6363 __attribute__warn_unused_result__ 6364 __attribute__visibility__("hidden"); 6365 # define PERL_ARGS_ASSERT_CK_ISA \ 6366 assert(o) 6367 6368 PERL_CALLCONV OP * 6369 Perl_ck_join(pTHX_ OP *o) 6370 __attribute__warn_unused_result__ 6371 __attribute__visibility__("hidden"); 6372 # define PERL_ARGS_ASSERT_CK_JOIN \ 6373 assert(o) 6374 6375 PERL_CALLCONV OP * 6376 Perl_ck_length(pTHX_ OP *o) 6377 __attribute__warn_unused_result__ 6378 __attribute__visibility__("hidden"); 6379 # define PERL_ARGS_ASSERT_CK_LENGTH \ 6380 assert(o) 6381 6382 PERL_CALLCONV OP * 6383 Perl_ck_lfun(pTHX_ OP *o) 6384 __attribute__warn_unused_result__ 6385 __attribute__visibility__("hidden"); 6386 # define PERL_ARGS_ASSERT_CK_LFUN \ 6387 assert(o) 6388 6389 PERL_CALLCONV OP * 6390 Perl_ck_listiob(pTHX_ OP *o) 6391 __attribute__warn_unused_result__ 6392 __attribute__visibility__("hidden"); 6393 # define PERL_ARGS_ASSERT_CK_LISTIOB \ 6394 assert(o) 6395 6396 PERL_CALLCONV OP * 6397 Perl_ck_match(pTHX_ OP *o) 6398 __attribute__warn_unused_result__ 6399 __attribute__visibility__("hidden"); 6400 # define PERL_ARGS_ASSERT_CK_MATCH \ 6401 assert(o) 6402 6403 PERL_CALLCONV OP * 6404 Perl_ck_method(pTHX_ OP *o) 6405 __attribute__warn_unused_result__ 6406 __attribute__visibility__("hidden"); 6407 # define PERL_ARGS_ASSERT_CK_METHOD \ 6408 assert(o) 6409 6410 PERL_CALLCONV OP * 6411 Perl_ck_null(pTHX_ OP *o) 6412 __attribute__warn_unused_result__ 6413 __attribute__visibility__("hidden"); 6414 # define PERL_ARGS_ASSERT_CK_NULL \ 6415 assert(o) 6416 6417 PERL_CALLCONV OP * 6418 Perl_ck_open(pTHX_ OP *o) 6419 __attribute__warn_unused_result__ 6420 __attribute__visibility__("hidden"); 6421 # define PERL_ARGS_ASSERT_CK_OPEN \ 6422 assert(o) 6423 6424 PERL_CALLCONV OP * 6425 Perl_ck_prototype(pTHX_ OP *o) 6426 __attribute__warn_unused_result__ 6427 __attribute__visibility__("hidden"); 6428 # define PERL_ARGS_ASSERT_CK_PROTOTYPE \ 6429 assert(o) 6430 6431 PERL_CALLCONV OP * 6432 Perl_ck_readline(pTHX_ OP *o) 6433 __attribute__warn_unused_result__ 6434 __attribute__visibility__("hidden"); 6435 # define PERL_ARGS_ASSERT_CK_READLINE \ 6436 assert(o) 6437 6438 PERL_CALLCONV OP * 6439 Perl_ck_refassign(pTHX_ OP *o) 6440 __attribute__warn_unused_result__ 6441 __attribute__visibility__("hidden"); 6442 # define PERL_ARGS_ASSERT_CK_REFASSIGN \ 6443 assert(o) 6444 6445 PERL_CALLCONV OP * 6446 Perl_ck_repeat(pTHX_ OP *o) 6447 __attribute__warn_unused_result__ 6448 __attribute__visibility__("hidden"); 6449 # define PERL_ARGS_ASSERT_CK_REPEAT \ 6450 assert(o) 6451 6452 PERL_CALLCONV OP * 6453 Perl_ck_require(pTHX_ OP *o) 6454 __attribute__warn_unused_result__ 6455 __attribute__visibility__("hidden"); 6456 # define PERL_ARGS_ASSERT_CK_REQUIRE \ 6457 assert(o) 6458 6459 PERL_CALLCONV OP * 6460 Perl_ck_return(pTHX_ OP *o) 6461 __attribute__warn_unused_result__ 6462 __attribute__visibility__("hidden"); 6463 # define PERL_ARGS_ASSERT_CK_RETURN \ 6464 assert(o) 6465 6466 PERL_CALLCONV OP * 6467 Perl_ck_rfun(pTHX_ OP *o) 6468 __attribute__warn_unused_result__ 6469 __attribute__visibility__("hidden"); 6470 # define PERL_ARGS_ASSERT_CK_RFUN \ 6471 assert(o) 6472 6473 PERL_CALLCONV OP * 6474 Perl_ck_rvconst(pTHX_ OP *o) 6475 __attribute__warn_unused_result__ 6476 __attribute__visibility__("hidden"); 6477 # define PERL_ARGS_ASSERT_CK_RVCONST \ 6478 assert(o) 6479 6480 PERL_CALLCONV OP * 6481 Perl_ck_sassign(pTHX_ OP *o) 6482 __attribute__warn_unused_result__ 6483 __attribute__visibility__("hidden"); 6484 # define PERL_ARGS_ASSERT_CK_SASSIGN \ 6485 assert(o) 6486 6487 PERL_CALLCONV OP * 6488 Perl_ck_select(pTHX_ OP *o) 6489 __attribute__warn_unused_result__ 6490 __attribute__visibility__("hidden"); 6491 # define PERL_ARGS_ASSERT_CK_SELECT \ 6492 assert(o) 6493 6494 PERL_CALLCONV OP * 6495 Perl_ck_shift(pTHX_ OP *o) 6496 __attribute__warn_unused_result__ 6497 __attribute__visibility__("hidden"); 6498 # define PERL_ARGS_ASSERT_CK_SHIFT \ 6499 assert(o) 6500 6501 PERL_CALLCONV OP * 6502 Perl_ck_smartmatch(pTHX_ OP *o) 6503 __attribute__warn_unused_result__ 6504 __attribute__visibility__("hidden"); 6505 # define PERL_ARGS_ASSERT_CK_SMARTMATCH \ 6506 assert(o) 6507 6508 PERL_CALLCONV OP * 6509 Perl_ck_sort(pTHX_ OP *o) 6510 __attribute__warn_unused_result__ 6511 __attribute__visibility__("hidden"); 6512 # define PERL_ARGS_ASSERT_CK_SORT \ 6513 assert(o) 6514 6515 PERL_CALLCONV OP * 6516 Perl_ck_spair(pTHX_ OP *o) 6517 __attribute__warn_unused_result__ 6518 __attribute__visibility__("hidden"); 6519 # define PERL_ARGS_ASSERT_CK_SPAIR \ 6520 assert(o) 6521 6522 PERL_CALLCONV OP * 6523 Perl_ck_split(pTHX_ OP *o) 6524 __attribute__warn_unused_result__ 6525 __attribute__visibility__("hidden"); 6526 # define PERL_ARGS_ASSERT_CK_SPLIT \ 6527 assert(o) 6528 6529 PERL_CALLCONV OP * 6530 Perl_ck_stringify(pTHX_ OP *o) 6531 __attribute__warn_unused_result__ 6532 __attribute__visibility__("hidden"); 6533 # define PERL_ARGS_ASSERT_CK_STRINGIFY \ 6534 assert(o) 6535 6536 PERL_CALLCONV OP * 6537 Perl_ck_subr(pTHX_ OP *o) 6538 __attribute__warn_unused_result__ 6539 __attribute__visibility__("hidden"); 6540 # define PERL_ARGS_ASSERT_CK_SUBR \ 6541 assert(o) 6542 6543 PERL_CALLCONV OP * 6544 Perl_ck_substr(pTHX_ OP *o) 6545 __attribute__warn_unused_result__ 6546 __attribute__visibility__("hidden"); 6547 # define PERL_ARGS_ASSERT_CK_SUBSTR \ 6548 assert(o) 6549 6550 PERL_CALLCONV OP * 6551 Perl_ck_svconst(pTHX_ OP *o) 6552 __attribute__warn_unused_result__ 6553 __attribute__visibility__("hidden"); 6554 # define PERL_ARGS_ASSERT_CK_SVCONST \ 6555 assert(o) 6556 6557 PERL_CALLCONV OP * 6558 Perl_ck_tell(pTHX_ OP *o) 6559 __attribute__warn_unused_result__ 6560 __attribute__visibility__("hidden"); 6561 # define PERL_ARGS_ASSERT_CK_TELL \ 6562 assert(o) 6563 6564 PERL_CALLCONV OP * 6565 Perl_ck_trunc(pTHX_ OP *o) 6566 __attribute__warn_unused_result__ 6567 __attribute__visibility__("hidden"); 6568 # define PERL_ARGS_ASSERT_CK_TRUNC \ 6569 assert(o) 6570 6571 PERL_CALLCONV OP * 6572 Perl_ck_trycatch(pTHX_ OP *o) 6573 __attribute__warn_unused_result__ 6574 __attribute__visibility__("hidden"); 6575 # define PERL_ARGS_ASSERT_CK_TRYCATCH \ 6576 assert(o) 6577 6578 #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_GLOBALS_C) || 6579 defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ 6580 #if defined(PERL_IN_CLASS_C) || defined(PERL_IN_OP_C) || \ 6581 defined(PERL_IN_PAD_C) || defined(PERL_IN_PERLY_C) || \ 6582 defined(PERL_IN_TOKE_C) 6583 PERL_CALLCONV void 6584 Perl_class_add_ADJUST(pTHX_ HV *stash, CV *cv); 6585 # define PERL_ARGS_ASSERT_CLASS_ADD_ADJUST \ 6586 assert(stash); assert(cv) 6587 6588 PERL_CALLCONV void 6589 Perl_class_add_field(pTHX_ HV *stash, PADNAME *pn); 6590 # define PERL_ARGS_ASSERT_CLASS_ADD_FIELD \ 6591 assert(stash); assert(pn) 6592 6593 PERL_CALLCONV void 6594 Perl_class_apply_attributes(pTHX_ HV *stash, OP *attrlist); 6595 # define PERL_ARGS_ASSERT_CLASS_APPLY_ATTRIBUTES \ 6596 assert(stash) 6597 6598 PERL_CALLCONV void 6599 Perl_class_apply_field_attributes(pTHX_ PADNAME *pn, OP *attrlist); 6600 # define PERL_ARGS_ASSERT_CLASS_APPLY_FIELD_ATTRIBUTES \ 6601 assert(pn) 6602 6603 PERL_CALLCONV void 6604 Perl_class_prepare_initfield_parse(pTHX); 6605 # define PERL_ARGS_ASSERT_CLASS_PREPARE_INITFIELD_PARSE 6606 6607 PERL_CALLCONV void 6608 Perl_class_prepare_method_parse(pTHX_ CV *cv); 6609 # define PERL_ARGS_ASSERT_CLASS_PREPARE_METHOD_PARSE \ 6610 assert(cv) 6611 6612 PERL_CALLCONV void 6613 Perl_class_seal_stash(pTHX_ HV *stash); 6614 # define PERL_ARGS_ASSERT_CLASS_SEAL_STASH \ 6615 assert(stash) 6616 6617 PERL_CALLCONV void 6618 Perl_class_set_field_defop(pTHX_ PADNAME *pn, OPCODE defmode, OP *defop); 6619 # define PERL_ARGS_ASSERT_CLASS_SET_FIELD_DEFOP \ 6620 assert(pn); assert(defop) 6621 6622 PERL_CALLCONV void 6623 Perl_class_setup_stash(pTHX_ HV *stash); 6624 # define PERL_ARGS_ASSERT_CLASS_SETUP_STASH \ 6625 assert(stash) 6626 6627 PERL_CALLCONV OP * 6628 Perl_class_wrap_method_body(pTHX_ OP *o); 6629 # define PERL_ARGS_ASSERT_CLASS_WRAP_METHOD_BODY 6630 6631 PERL_CALLCONV void 6632 Perl_croak_kw_unless_class(pTHX_ const char *kw); 6633 # define PERL_ARGS_ASSERT_CROAK_KW_UNLESS_CLASS \ 6634 assert(kw) 6635 6636 #endif /* defined(PERL_IN_CLASS_C) || defined(PERL_IN_OP_C) || 6637 defined(PERL_IN_PAD_C) || defined(PERL_IN_PERLY_C) || 6638 defined(PERL_IN_TOKE_C) */ 6639 #if defined(PERL_IN_DEB_C) 6640 STATIC void 6641 S_deb_stack_n(pTHX_ SV **stack_base, SSize_t stack_min, SSize_t stack_max, SSize_t mark_min, SSize_t mark_max, SSize_t nonrc_base); 6642 # define PERL_ARGS_ASSERT_DEB_STACK_N \ 6643 assert(stack_base) 6644 6645 #endif 6646 #if defined(PERL_IN_DOIO_C) 6647 STATIC bool 6648 S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool is_explicit); 6649 # define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ 6650 assert(mg); assert(io) 6651 6652 STATIC void 6653 S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); 6654 # define PERL_ARGS_ASSERT_EXEC_FAILED \ 6655 assert(cmd) 6656 6657 STATIC bool 6658 S_is_fork_open(const char *name); 6659 # define PERL_ARGS_ASSERT_IS_FORK_OPEN \ 6660 assert(name) 6661 6662 STATIC bool 6663 S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp); 6664 # define PERL_ARGS_ASSERT_OPENN_CLEANUP \ 6665 assert(gv); assert(io); assert(mode); assert(oname) 6666 6667 STATIC IO * 6668 S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype); 6669 # define PERL_ARGS_ASSERT_OPENN_SETUP \ 6670 assert(gv); assert(mode); assert(saveifp); assert(saveofp); assert(savefd); \ 6671 assert(savetype) 6672 6673 # if !defined(DOSISH) 6674 STATIC bool 6675 S_ingroup(pTHX_ Gid_t testgid, bool effective) 6676 __attribute__warn_unused_result__; 6677 # define PERL_ARGS_ASSERT_INGROUP 6678 6679 # endif 6680 #endif /* defined(PERL_IN_DOIO_C) */ 6681 #if defined(PERL_IN_DOOP_C) 6682 STATIC Size_t 6683 S_do_trans_complex(pTHX_ SV * const sv, const OPtrans_map * const tbl) 6684 __attribute__warn_unused_result__; 6685 # define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ 6686 assert(sv); assert(tbl) 6687 6688 STATIC Size_t 6689 S_do_trans_count(pTHX_ SV * const sv, const OPtrans_map * const tbl) 6690 __attribute__warn_unused_result__; 6691 # define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ 6692 assert(sv); assert(tbl) 6693 6694 STATIC Size_t 6695 S_do_trans_count_invmap(pTHX_ SV * const sv, AV * const map) 6696 __attribute__warn_unused_result__; 6697 # define PERL_ARGS_ASSERT_DO_TRANS_COUNT_INVMAP \ 6698 assert(sv); assert(map) 6699 6700 STATIC Size_t 6701 S_do_trans_invmap(pTHX_ SV * const sv, AV * const map) 6702 __attribute__warn_unused_result__; 6703 # define PERL_ARGS_ASSERT_DO_TRANS_INVMAP \ 6704 assert(sv); assert(map) 6705 6706 STATIC Size_t 6707 S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) 6708 __attribute__warn_unused_result__; 6709 # define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ 6710 assert(sv); assert(tbl) 6711 6712 #endif /* defined(PERL_IN_DOOP_C) */ 6713 #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ 6714 defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ 6715 defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || \ 6716 defined(PERL_IN_UTF8_C) 6717 6718 PERL_CALLCONV SSize_t 6719 Perl__invlist_search(SV * const invlist, const UV cp) 6720 __attribute__warn_unused_result__; 6721 # define PERL_ARGS_ASSERT__INVLIST_SEARCH \ 6722 assert(invlist) 6723 6724 #endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || 6725 defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || 6726 defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || 6727 defined(PERL_IN_UTF8_C) */ 6728 #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ 6729 defined(PERL_IN_REGCOMP_ANY) 6730 6731 #endif 6732 #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ 6733 defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) 6734 PERL_CALLCONV SV * 6735 Perl__add_range_to_invlist(pTHX_ SV *invlist, UV start, UV end) 6736 __attribute__warn_unused_result__; 6737 # define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST 6738 6739 /* PERL_CALLCONV void 6740 _invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */ 6741 6742 PERL_CALLCONV void 6743 Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i); 6744 # define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ 6745 assert(b); assert(i) 6746 6747 PERL_CALLCONV void 6748 Perl__invlist_invert(pTHX_ SV * const invlist); 6749 # define PERL_ARGS_ASSERT__INVLIST_INVERT \ 6750 assert(invlist) 6751 6752 /* PERL_CALLCONV void 6753 _invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */ 6754 6755 /* PERL_CALLCONV void 6756 _invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */ 6757 6758 PERL_CALLCONV void 6759 Perl__invlist_union_maybe_complement_2nd(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output); 6760 # define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ 6761 assert(b); assert(output) 6762 6763 PERL_CALLCONV SV * 6764 Perl__new_invlist(pTHX_ IV initial_size) 6765 __attribute__warn_unused_result__; 6766 # define PERL_ARGS_ASSERT__NEW_INVLIST 6767 6768 PERL_CALLCONV SV * 6769 Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV **other_elements_ptr) 6770 __attribute__warn_unused_result__; 6771 # define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ 6772 assert(other_elements_ptr) 6773 6774 #endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || 6775 defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) */ 6776 #if defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || \ 6777 defined(PERL_IN_TOKE_C) 6778 PERL_CALLCONV const char * 6779 Perl_form_alien_digit_msg(pTHX_ const U8 which, const STRLEN valids_len, const char * const first_bad, const char * const send, const bool UTF, const bool braced) 6780 __attribute__warn_unused_result__; 6781 # define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG \ 6782 assert(first_bad); assert(send) 6783 6784 PERL_CALLCONV bool 6785 Perl_grok_bslash_c(pTHX_ const char source, U8 *result, const char **message, U32 *packed_warn) 6786 __attribute__warn_unused_result__; 6787 # define PERL_ARGS_ASSERT_GROK_BSLASH_C \ 6788 assert(result); assert(message) 6789 6790 PERL_CALLCONV bool 6791 Perl_grok_bslash_o(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) 6792 __attribute__warn_unused_result__; 6793 # define PERL_ARGS_ASSERT_GROK_BSLASH_O \ 6794 assert(s); assert(send); assert(uv); assert(message) 6795 6796 PERL_CALLCONV bool 6797 Perl_grok_bslash_x(pTHX_ char **s, const char * const send, UV *uv, const char **message, U32 *packed_warn, const bool strict, const bool allow_UV_MAX, const bool utf8) 6798 __attribute__warn_unused_result__; 6799 # define PERL_ARGS_ASSERT_GROK_BSLASH_X \ 6800 assert(s); assert(send); assert(uv); assert(message) 6801 6802 #endif /* defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || 6803 defined(PERL_IN_TOKE_C) */ 6804 #if defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_REGCOMP_C) || \ 6805 defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) 6806 PERL_CALLCONV const char * 6807 Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char *string, const Size_t len, const UV cp) 6808 __attribute__warn_unused_result__; 6809 # define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG 6810 6811 #endif 6812 #if defined(PERL_IN_DUMP_C) 6813 STATIC CV * 6814 S_deb_curcv(pTHX_ I32 ix); 6815 # define PERL_ARGS_ASSERT_DEB_CURCV 6816 6817 STATIC void 6818 S_debprof(pTHX_ const OP *o); 6819 # define PERL_ARGS_ASSERT_DEBPROF \ 6820 assert(o) 6821 6822 STATIC SV * 6823 S_pm_description(pTHX_ const PMOP *pm); 6824 # define PERL_ARGS_ASSERT_PM_DESCRIPTION \ 6825 assert(pm) 6826 6827 STATIC UV 6828 S_sequence_num(pTHX_ const OP *o); 6829 # define PERL_ARGS_ASSERT_SEQUENCE_NUM 6830 6831 #endif /* defined(PERL_IN_DUMP_C) */ 6832 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || \ 6833 defined(PERL_IN_SCOPE_C) || defined(PERL_IN_SV_C) 6834 PERL_CALLCONV void 6835 Perl_hv_kill_backrefs(pTHX_ HV *hv) 6836 __attribute__visibility__("hidden"); 6837 # define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ 6838 assert(hv) 6839 6840 #endif 6841 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_OP_C) || \ 6842 defined(PERL_IN_REGCOMP_ANY) 6843 PERL_CALLCONV void 6844 Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char * const indent, SV * const invlist); 6845 # define PERL_ARGS_ASSERT__INVLIST_DUMP \ 6846 assert(file); assert(indent); assert(invlist) 6847 6848 #endif 6849 #if defined(PERL_IN_GV_C) 6850 STATIC bool 6851 S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type); 6852 # define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ 6853 assert(stash); assert(name) 6854 6855 STATIC void 6856 S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); 6857 # define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ 6858 assert(gv) 6859 6860 STATIC bool 6861 S_gv_is_in_main(pTHX_ const char *name, STRLEN len, const U32 is_utf8); 6862 # define PERL_ARGS_ASSERT_GV_IS_IN_MAIN \ 6863 assert(name) 6864 6865 STATIC bool 6866 S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, const svtype sv_type); 6867 # define PERL_ARGS_ASSERT_GV_MAGICALIZE \ 6868 assert(gv); assert(stash); assert(name) 6869 6870 STATIC void 6871 S_gv_magicalize_isa(pTHX_ GV *gv); 6872 # define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ 6873 assert(gv) 6874 6875 STATIC void 6876 S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type); 6877 # define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ 6878 assert(gv); assert(name) 6879 6880 STATIC bool 6881 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); 6882 # define PERL_ARGS_ASSERT_PARSE_GV_STASH_NAME \ 6883 assert(stash); assert(gv); assert(name); assert(len); assert(nambeg) 6884 6885 STATIC void 6886 S_require_tie_mod(pTHX_ GV *gv, const char varname, const char *name, STRLEN len, const U32 flags); 6887 # define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ 6888 assert(gv); assert(varname); assert(name) 6889 6890 # if !defined(PERL_NO_INLINE_FUNCTIONS) 6891 PERL_STATIC_INLINE GV * 6892 S_gv_fetchmeth_internal(pTHX_ HV *stash, SV *meth, const char *name, STRLEN len, I32 level, U32 flags); 6893 # define PERL_ARGS_ASSERT_GV_FETCHMETH_INTERNAL 6894 6895 PERL_STATIC_INLINE HV * 6896 S_gv_stashpvn_internal(pTHX_ const char *name, U32 namelen, I32 flags); 6897 # define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ 6898 assert(name) 6899 6900 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 6901 #endif /* defined(PERL_IN_GV_C) */ 6902 #if defined(PERL_IN_GV_C) || defined(PERL_IN_OP_C) || \ 6903 defined(PERL_IN_PAD_C) || defined(PERL_IN_SV_C) 6904 PERL_CALLCONV void 6905 Perl_sv_add_backref(pTHX_ SV * const tsv, SV * const sv) 6906 __attribute__visibility__("hidden"); 6907 # define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ 6908 assert(tsv); assert(sv) 6909 6910 #endif 6911 #if defined(PERL_IN_GV_C) || defined(PERL_IN_UNIVERSAL_C) 6912 PERL_CALLCONV HV * 6913 Perl_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char *name, U32 namelen, I32 flags) 6914 __attribute__visibility__("hidden"); 6915 6916 #endif 6917 #if defined(PERL_IN_HV_C) 6918 STATIC void 6919 S_clear_placeholders(pTHX_ HV *hv, U32 items); 6920 # define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ 6921 assert(hv) 6922 6923 STATIC void 6924 S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize); 6925 # define PERL_ARGS_ASSERT_HSPLIT \ 6926 assert(hv) 6927 6928 STATIC struct xpvhv_aux * 6929 S_hv_auxinit(pTHX_ HV *hv); 6930 # define PERL_ARGS_ASSERT_HV_AUXINIT \ 6931 assert(hv) 6932 6933 STATIC SV * 6934 S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); 6935 # define PERL_ARGS_ASSERT_HV_DELETE_COMMON 6936 6937 STATIC SV * 6938 S_hv_free_ent_ret(pTHX_ HE *entry); 6939 # define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ 6940 assert(entry) 6941 6942 STATIC void 6943 S_hv_free_entries(pTHX_ HV *hv); 6944 # define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ 6945 assert(hv) 6946 6947 STATIC void 6948 S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store); 6949 # define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ 6950 assert(hv); assert(needs_copy); assert(needs_store) 6951 6952 PERL_STATIC_NO_RET void 6953 S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) 6954 __attribute__noreturn__; 6955 # define PERL_ARGS_ASSERT_HV_NOTALLOWED \ 6956 assert(key); assert(msg) 6957 6958 STATIC SV * 6959 S_refcounted_he_value(pTHX_ const struct refcounted_he *he); 6960 # define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ 6961 assert(he) 6962 6963 STATIC HEK * 6964 S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) 6965 __attribute__malloc__ 6966 __attribute__warn_unused_result__; 6967 # define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ 6968 assert(str) 6969 6970 STATIC HEK * 6971 S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) 6972 __attribute__warn_unused_result__; 6973 # define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ 6974 assert(str) 6975 6976 STATIC void 6977 S_unshare_hek_or_pvn(pTHX_ const HEK *hek, const char *str, I32 len, U32 hash); 6978 # define PERL_ARGS_ASSERT_UNSHARE_HEK_OR_PVN 6979 6980 # if !defined(PURIFY) 6981 STATIC HE * 6982 S_new_he(pTHX) 6983 __attribute__warn_unused_result__; 6984 # define PERL_ARGS_ASSERT_NEW_HE 6985 6986 # endif 6987 #endif /* defined(PERL_IN_HV_C) */ 6988 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) 6989 PERL_CALLCONV void 6990 Perl_sv_kill_backrefs(pTHX_ SV * const sv, AV * const av) 6991 __attribute__visibility__("hidden"); 6992 # define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ 6993 assert(sv) 6994 6995 #endif 6996 #if defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) 6997 PERL_CALLCONV SV * 6998 Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) 6999 __attribute__visibility__("hidden"); 7000 # define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY \ 7001 assert(hv); assert(indexp) 7002 7003 #endif 7004 #if defined(PERL_IN_LOCALE_C) 7005 STATIC utf8ness_t 7006 S_get_locale_string_utf8ness_i(pTHX_ const char *string, const locale_utf8ness_t known_utf8, const char *locale, const locale_category_index cat_index); 7007 # define PERL_ARGS_ASSERT_GET_LOCALE_STRING_UTF8NESS_I 7008 7009 STATIC void 7010 S_ints_to_tm(pTHX_ struct tm *my_tm, const char *locale, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst); 7011 # define PERL_ARGS_ASSERT_INTS_TO_TM \ 7012 assert(my_tm); assert(locale) 7013 7014 STATIC bool 7015 S_is_locale_utf8(pTHX_ const char *locale); 7016 # define PERL_ARGS_ASSERT_IS_LOCALE_UTF8 \ 7017 assert(locale) 7018 7019 STATIC HV * 7020 S_my_localeconv(pTHX_ const int item); 7021 # define PERL_ARGS_ASSERT_MY_LOCALECONV 7022 7023 STATIC void 7024 S_populate_hash_from_C_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); 7025 # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_C_LOCALECONV \ 7026 assert(hv); assert(locale); assert(strings); assert(integers) 7027 7028 STATIC bool 7029 S_strftime8(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm, const utf8ness_t fmt_utf8ness, utf8ness_t *result_utf8ness, const bool called_externally); 7030 # define PERL_ARGS_ASSERT_STRFTIME8 \ 7031 assert(fmt); assert(sv); assert(locale); assert(mytm); assert(result_utf8ness) 7032 7033 STATIC bool 7034 S_strftime_tm(pTHX_ const char *fmt, SV *sv, const char *locale, const struct tm *mytm) 7035 __attribute__format__(__strftime__,pTHX_1,0); 7036 # define PERL_ARGS_ASSERT_STRFTIME_TM \ 7037 assert(fmt); assert(sv); assert(locale); assert(mytm) 7038 7039 STATIC SV * 7040 S_sv_strftime_common(pTHX_ SV *fmt, const char *locale, const struct tm *mytm); 7041 # define PERL_ARGS_ASSERT_SV_STRFTIME_COMMON \ 7042 assert(fmt); assert(locale); assert(mytm) 7043 7044 # if defined(HAS_MISSING_LANGINFO_ITEM_) || !defined(HAS_NL_LANGINFO) 7045 STATIC const char * 7046 S_emulate_langinfo(pTHX_ const PERL_INTMAX_T item, const char *locale, SV *sv, utf8ness_t *utf8ness); 7047 # define PERL_ARGS_ASSERT_EMULATE_LANGINFO \ 7048 assert(locale); assert(sv) 7049 7050 # endif 7051 # if defined(USE_LOCALE) 7052 STATIC const char * 7053 S_calculate_LC_ALL_string(pTHX_ const char **category_locales_list, const calc_LC_ALL_format format, const calc_LC_ALL_return returning, const line_t caller_line); 7054 # define PERL_ARGS_ASSERT_CALCULATE_LC_ALL_STRING 7055 7056 STATIC const char * 7057 S_external_call_langinfo(pTHX_ const nl_item item, SV *sv, utf8ness_t *utf8ness); 7058 # define PERL_ARGS_ASSERT_EXTERNAL_CALL_LANGINFO \ 7059 assert(sv) 7060 7061 STATIC locale_category_index 7062 S_get_category_index_helper(pTHX_ const int category, bool *success, const line_t caller_line) 7063 __attribute__warn_unused_result__; 7064 # define PERL_ARGS_ASSERT_GET_CATEGORY_INDEX_HELPER 7065 7066 STATIC const char * 7067 S_native_querylocale_i(pTHX_ const locale_category_index cat_index); 7068 # define PERL_ARGS_ASSERT_NATIVE_QUERYLOCALE_I 7069 7070 STATIC void 7071 S_new_LC_ALL(pTHX_ const char *lc_all, bool force); 7072 # define PERL_ARGS_ASSERT_NEW_LC_ALL \ 7073 assert(lc_all) 7074 7075 STATIC void 7076 S_output_check_environment_warning(pTHX_ const char * const language, const char * const lc_all, const char * const lang); 7077 # define PERL_ARGS_ASSERT_OUTPUT_CHECK_ENVIRONMENT_WARNING 7078 7079 STATIC parse_LC_ALL_string_return 7080 S_parse_LC_ALL_string(pTHX_ const char *string, const char **output, const parse_LC_ALL_STRING_action, bool always_use_full_array, const bool panic_on_error, const line_t caller_line); 7081 # define PERL_ARGS_ASSERT_PARSE_LC_ALL_STRING \ 7082 assert(string); assert(output) 7083 7084 STATIC void 7085 S_restore_toggled_locale_i(pTHX_ const locale_category_index cat_index, const char *original_locale, const line_t caller_line); 7086 # define PERL_ARGS_ASSERT_RESTORE_TOGGLED_LOCALE_I 7087 7088 STATIC const char * 7089 S_save_to_buffer(pTHX_ const char *string, char **buf, Size_t *buf_size); 7090 # define PERL_ARGS_ASSERT_SAVE_TO_BUFFER 7091 7092 STATIC void 7093 S_set_save_buffer_min_size(pTHX_ const Size_t min_len, char **buf, Size_t *buf_size); 7094 # define PERL_ARGS_ASSERT_SET_SAVE_BUFFER_MIN_SIZE 7095 7096 PERL_STATIC_NO_RET void 7097 S_setlocale_failure_panic_via_i(pTHX_ const locale_category_index cat_index, const char *current, const char *failed, const line_t proxy_caller_line, const line_t immediate_caller_line, const char *higher_caller_file, const line_t higher_caller_line) 7098 __attribute__noreturn__; 7099 # define PERL_ARGS_ASSERT_SETLOCALE_FAILURE_PANIC_VIA_I \ 7100 assert(failed); assert(higher_caller_file) 7101 7102 STATIC const char * 7103 S_toggle_locale_i(pTHX_ const locale_category_index cat_index, const char *new_locale, const line_t caller_line); 7104 # define PERL_ARGS_ASSERT_TOGGLE_LOCALE_I \ 7105 assert(new_locale) 7106 7107 # if defined(DEBUGGING) 7108 STATIC char * 7109 S_my_setlocale_debug_string_i(pTHX_ const locale_category_index cat_index, const char *locale, const char *retval, const line_t line) 7110 __attribute__warn_unused_result__; 7111 # define PERL_ARGS_ASSERT_MY_SETLOCALE_DEBUG_STRING_I 7112 7113 # endif 7114 # if defined(HAS_LOCALECONV) && \ 7115 ( defined(USE_LOCALE_MONETARY) || defined(USE_LOCALE_NUMERIC) ) 7116 STATIC void 7117 S_populate_hash_from_localeconv(pTHX_ HV *hv, const char *locale, const U32 which_mask, const lconv_offset_t *strings[2], const lconv_offset_t *integers[2]); 7118 # define PERL_ARGS_ASSERT_POPULATE_HASH_FROM_LOCALECONV \ 7119 assert(hv); assert(locale); assert(strings); assert(integers) 7120 7121 # endif 7122 # if defined(HAS_NL_LANGINFO) 7123 STATIC const char * 7124 S_langinfo_sv_i(pTHX_ const nl_item item, locale_category_index cat_index, const char *locale, SV *sv, utf8ness_t *utf8ness); 7125 # define PERL_ARGS_ASSERT_LANGINFO_SV_I \ 7126 assert(locale); assert(sv) 7127 7128 # endif 7129 # if defined(LC_ALL) 7130 STATIC void 7131 S_give_perl_locale_control(pTHX_ const char *lc_all_string, const line_t caller_line); 7132 # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ 7133 assert(lc_all_string) 7134 7135 # else 7136 STATIC void 7137 S_give_perl_locale_control(pTHX_ const char **curlocales, const line_t caller_line); 7138 # define PERL_ARGS_ASSERT_GIVE_PERL_LOCALE_CONTROL \ 7139 assert(curlocales) 7140 7141 # endif 7142 # if !defined(PERL_NO_INLINE_FUNCTIONS) 7143 PERL_STATIC_INLINE const char * 7144 S_mortalized_pv_copy(pTHX_ const char * const pv) 7145 __attribute__warn_unused_result__; 7146 # define PERL_ARGS_ASSERT_MORTALIZED_PV_COPY 7147 7148 # endif 7149 # if defined(USE_LOCALE_COLLATE) 7150 STATIC void 7151 S_new_collate(pTHX_ const char *newcoll, bool force); 7152 # define PERL_ARGS_ASSERT_NEW_COLLATE \ 7153 assert(newcoll) 7154 7155 # if defined(DEBUGGING) 7156 STATIC void 7157 S_print_collxfrm_input_and_return(pTHX_ const char *s, const char *e, const char *xbuf, const STRLEN xlen, const bool is_utf8); 7158 # define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ 7159 assert(s); assert(e) 7160 7161 # endif 7162 # endif /* defined(USE_LOCALE_COLLATE) */ 7163 # if defined(USE_LOCALE_CTYPE) 7164 STATIC bool 7165 S_is_codeset_name_UTF8(const char *name); 7166 # define PERL_ARGS_ASSERT_IS_CODESET_NAME_UTF8 \ 7167 assert(name) 7168 7169 STATIC void 7170 S_new_ctype(pTHX_ const char *newctype, bool force); 7171 # define PERL_ARGS_ASSERT_NEW_CTYPE \ 7172 assert(newctype) 7173 7174 # endif /* defined(USE_LOCALE_CTYPE) */ 7175 # if defined(USE_LOCALE_NUMERIC) 7176 STATIC void 7177 S_new_numeric(pTHX_ const char *newnum, bool force); 7178 # define PERL_ARGS_ASSERT_NEW_NUMERIC \ 7179 assert(newnum) 7180 7181 # endif 7182 # if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) || defined(DEBUGGING) 7183 STATIC const char * 7184 S_get_LC_ALL_display(pTHX); 7185 # define PERL_ARGS_ASSERT_GET_LC_ALL_DISPLAY 7186 7187 # endif 7188 # if defined(USE_POSIX_2008_LOCALE) 7189 STATIC bool 7190 S_bool_setlocale_2008_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); 7191 # define PERL_ARGS_ASSERT_BOOL_SETLOCALE_2008_I \ 7192 assert(new_locale) 7193 7194 STATIC const char * 7195 S_querylocale_2008_i(pTHX_ const locale_category_index index, const line_t line); 7196 # define PERL_ARGS_ASSERT_QUERYLOCALE_2008_I 7197 7198 STATIC locale_t 7199 S_use_curlocale_scratch(pTHX); 7200 # define PERL_ARGS_ASSERT_USE_CURLOCALE_SCRATCH 7201 7202 # if !defined(USE_QUERYLOCALE) 7203 STATIC void 7204 S_update_PL_curlocales_i(pTHX_ const locale_category_index index, const char *new_locale, const line_t caller_line); 7205 # define PERL_ARGS_ASSERT_UPDATE_PL_CURLOCALES_I \ 7206 assert(new_locale) 7207 7208 # endif 7209 # elif defined(USE_LOCALE_THREADS) && \ 7210 !defined(USE_THREAD_SAFE_LOCALE) && \ 7211 !defined(USE_THREAD_SAFE_LOCALE_EMULATION) /* && 7212 !defined(USE_POSIX_2008_LOCALE) */ 7213 STATIC bool 7214 S_less_dicey_bool_setlocale_r(pTHX_ const int cat, const char *locale); 7215 # define PERL_ARGS_ASSERT_LESS_DICEY_BOOL_SETLOCALE_R \ 7216 assert(locale) 7217 7218 STATIC const char * 7219 S_less_dicey_setlocale_r(pTHX_ const int category, const char *locale); 7220 # define PERL_ARGS_ASSERT_LESS_DICEY_SETLOCALE_R 7221 7222 # endif /* defined(USE_LOCALE_THREADS) && 7223 !defined(USE_POSIX_2008_LOCALE) && 7224 !defined(USE_THREAD_SAFE_LOCALE) && 7225 !defined(USE_THREAD_SAFE_LOCALE_EMULATION) */ 7226 # if defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) 7227 STATIC wchar_t * 7228 S_Win_byte_string_to_wstring(const UINT code_page, const char *byte_string); 7229 # define PERL_ARGS_ASSERT_WIN_BYTE_STRING_TO_WSTRING 7230 7231 STATIC char * 7232 S_Win_wstring_to_byte_string(const UINT code_page, const wchar_t *wstring); 7233 # define PERL_ARGS_ASSERT_WIN_WSTRING_TO_BYTE_STRING 7234 7235 STATIC const char * 7236 S_win32_setlocale(pTHX_ int category, const char *locale); 7237 # define PERL_ARGS_ASSERT_WIN32_SETLOCALE 7238 7239 STATIC const char * 7240 S_wrap_wsetlocale(pTHX_ const int category, const char *locale); 7241 # define PERL_ARGS_ASSERT_WRAP_WSETLOCALE 7242 7243 # endif /* defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) */ 7244 # if defined(WIN32) || defined(WIN32_USE_FAKE_OLD_MINGW_LOCALES) || \ 7245 ( defined(USE_POSIX_2008_LOCALE) && !defined(USE_QUERYLOCALE) ) 7246 STATIC const char * 7247 S_find_locale_from_environment(pTHX_ const locale_category_index index); 7248 # define PERL_ARGS_ASSERT_FIND_LOCALE_FROM_ENVIRONMENT 7249 7250 # endif 7251 # endif /* defined(USE_LOCALE) */ 7252 # if defined(USE_LOCALE) || defined(DEBUGGING) 7253 STATIC const char * 7254 S_get_displayable_string(pTHX_ const char * const s, const char * const e, const bool is_utf8); 7255 # define PERL_ARGS_ASSERT_GET_DISPLAYABLE_STRING \ 7256 assert(s); assert(e) 7257 7258 # endif 7259 #endif /* defined(PERL_IN_LOCALE_C) */ 7260 #if defined(PERL_IN_MALLOC_C) 7261 STATIC int 7262 S_adjust_size_and_find_bucket(size_t *nbytes_p); 7263 # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ 7264 assert(nbytes_p) 7265 7266 #endif 7267 #if defined(PERL_IN_MG_C) 7268 STATIC void 7269 S_fixup_errno_string(pTHX_ SV *sv); 7270 # define PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING \ 7271 assert(sv) 7272 7273 STATIC SV * 7274 S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags, int n, SV *val); 7275 # define PERL_ARGS_ASSERT_MAGIC_METHCALL1 \ 7276 assert(sv); assert(mg); assert(meth) 7277 7278 STATIC int 7279 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth); 7280 # define PERL_ARGS_ASSERT_MAGIC_METHPACK \ 7281 assert(sv); assert(mg); assert(meth) 7282 7283 STATIC void 7284 S_restore_magic(pTHX_ const void *p); 7285 # define PERL_ARGS_ASSERT_RESTORE_MAGIC 7286 7287 STATIC void 7288 S_save_magic_flags(pTHX_ SSize_t mgs_ix, SV *sv, U32 flags); 7289 # define PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS \ 7290 assert(sv) 7291 7292 STATIC void 7293 S_unwind_handler_stack(pTHX_ const void *p); 7294 # define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK 7295 7296 #endif /* defined(PERL_IN_MG_C) */ 7297 #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) 7298 PERL_CALLCONV bool 7299 Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) 7300 __attribute__visibility__("hidden"); 7301 # define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ 7302 assert(posp); assert(lenp) 7303 7304 #endif 7305 #if defined(PERL_IN_MRO_C) 7306 STATIC void 7307 S_mro_clean_isarev(pTHX_ HV * const isa, const char * const name, const STRLEN len, HV * const exceptions, U32 hash, U32 flags); 7308 # define PERL_ARGS_ASSERT_MRO_CLEAN_ISAREV \ 7309 assert(isa); assert(name) 7310 7311 STATIC void 7312 S_mro_gather_and_rename(pTHX_ HV * const stashes, HV * const seen_stashes, HV *stash, HV *oldstash, SV *namesv); 7313 # define PERL_ARGS_ASSERT_MRO_GATHER_AND_RENAME \ 7314 assert(stashes); assert(seen_stashes); assert(namesv) 7315 7316 STATIC AV * 7317 S_mro_get_linear_isa_dfs(pTHX_ HV *stash, U32 level); 7318 # define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ 7319 assert(stash) 7320 7321 #endif /* defined(PERL_IN_MRO_C) */ 7322 #if defined(PERL_IN_NUMERIC_C) 7323 STATIC void 7324 S_output_non_portable(pTHX_ const U8 shift); 7325 # define PERL_ARGS_ASSERT_OUTPUT_NON_PORTABLE 7326 7327 #endif 7328 #if defined(PERL_IN_OP_C) 7329 STATIC void 7330 S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs); 7331 # define PERL_ARGS_ASSERT_APPLY_ATTRS \ 7332 assert(stash); assert(target) 7333 7334 STATIC void 7335 S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp); 7336 # define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ 7337 assert(stash); assert(target); assert(imopsp) 7338 7339 STATIC I32 7340 S_assignment_type(pTHX_ const OP *o) 7341 __attribute__warn_unused_result__; 7342 # define PERL_ARGS_ASSERT_ASSIGNMENT_TYPE 7343 7344 STATIC void 7345 S_bad_type_gv(pTHX_ I32 n, GV *gv, const OP *kid, const char *t); 7346 # define PERL_ARGS_ASSERT_BAD_TYPE_GV \ 7347 assert(gv); assert(kid); assert(t) 7348 7349 STATIC void 7350 S_bad_type_pv(pTHX_ I32 n, const char *t, const OP *o, const OP *kid); 7351 # define PERL_ARGS_ASSERT_BAD_TYPE_PV \ 7352 assert(t); assert(o); assert(kid) 7353 7354 STATIC void 7355 S_clear_special_blocks(pTHX_ const char * const fullname, GV * const gv, CV * const cv); 7356 # define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \ 7357 assert(fullname); assert(gv); assert(cv) 7358 7359 STATIC void 7360 S_cop_free(pTHX_ COP *cop); 7361 # define PERL_ARGS_ASSERT_COP_FREE \ 7362 assert(cop) 7363 7364 STATIC OP * 7365 S_dup_attrlist(pTHX_ OP *o); 7366 # define PERL_ARGS_ASSERT_DUP_ATTRLIST \ 7367 assert(o) 7368 7369 STATIC void 7370 S_find_and_forget_pmops(pTHX_ OP *o); 7371 # define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ 7372 assert(o) 7373 7374 STATIC OP * 7375 S_fold_constants(pTHX_ OP * const o); 7376 # define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ 7377 assert(o) 7378 7379 STATIC OP * 7380 S_force_list(pTHX_ OP *arg, bool nullit); 7381 # define PERL_ARGS_ASSERT_FORCE_LIST 7382 7383 STATIC void 7384 S_forget_pmop(pTHX_ PMOP * const o); 7385 # define PERL_ARGS_ASSERT_FORGET_PMOP \ 7386 assert(o) 7387 7388 STATIC void 7389 S_gen_constant_list(pTHX_ OP *o); 7390 # define PERL_ARGS_ASSERT_GEN_CONSTANT_LIST 7391 7392 STATIC void 7393 S_inplace_aassign(pTHX_ OP *o); 7394 # define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ 7395 assert(o) 7396 7397 STATIC bool 7398 S_is_handle_constructor(const OP *o, I32 numargs) 7399 __attribute__warn_unused_result__; 7400 # define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ 7401 assert(o) 7402 7403 STATIC OP * 7404 S_listkids(pTHX_ OP *o); 7405 # define PERL_ARGS_ASSERT_LISTKIDS 7406 7407 STATIC bool 7408 S_looks_like_bool(pTHX_ const OP *o); 7409 # define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ 7410 assert(o) 7411 7412 STATIC OP * 7413 S_modkids(pTHX_ OP *o, I32 type); 7414 # define PERL_ARGS_ASSERT_MODKIDS 7415 7416 STATIC void 7417 S_move_proto_attr(pTHX_ OP **proto, OP **attrs, const GV *name, bool curstash); 7418 # define PERL_ARGS_ASSERT_MOVE_PROTO_ATTR \ 7419 assert(proto); assert(attrs); assert(name) 7420 7421 STATIC OP * 7422 S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp); 7423 # define PERL_ARGS_ASSERT_MY_KID \ 7424 assert(imopsp) 7425 7426 STATIC OP * 7427 S_newGIVWHENOP(pTHX_ OP *cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg); 7428 # define PERL_ARGS_ASSERT_NEWGIVWHENOP \ 7429 assert(block) 7430 7431 STATIC OP * 7432 S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) 7433 __attribute__warn_unused_result__; 7434 # define PERL_ARGS_ASSERT_NEW_LOGOP \ 7435 assert(firstp); assert(otherp) 7436 7437 STATIC OP * 7438 S_no_fh_allowed(pTHX_ OP *o) 7439 __attribute__warn_unused_result__; 7440 # define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ 7441 assert(o) 7442 7443 STATIC OP * 7444 S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl); 7445 # define PERL_ARGS_ASSERT_PMTRANS \ 7446 assert(o); assert(expr); assert(repl) 7447 7448 STATIC bool 7449 S_process_special_blocks(pTHX_ I32 floor, const char * const fullname, GV * const gv, CV * const cv); 7450 # define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ 7451 assert(fullname); assert(gv); assert(cv) 7452 7453 STATIC OP * 7454 S_ref_array_or_hash(pTHX_ OP *cond); 7455 # define PERL_ARGS_ASSERT_REF_ARRAY_OR_HASH 7456 7457 STATIC OP * 7458 S_refkids(pTHX_ OP *o, I32 type); 7459 # define PERL_ARGS_ASSERT_REFKIDS 7460 7461 STATIC bool 7462 S_scalar_mod_type(const OP *o, I32 type) 7463 __attribute__warn_unused_result__; 7464 # define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE 7465 7466 STATIC OP * 7467 S_scalarboolean(pTHX_ OP *o); 7468 # define PERL_ARGS_ASSERT_SCALARBOOLEAN \ 7469 assert(o) 7470 7471 STATIC OP * 7472 S_scalarkids(pTHX_ OP *o); 7473 # define PERL_ARGS_ASSERT_SCALARKIDS 7474 7475 STATIC OP * 7476 S_search_const(pTHX_ OP *o) 7477 __attribute__warn_unused_result__; 7478 # define PERL_ARGS_ASSERT_SEARCH_CONST \ 7479 assert(o) 7480 7481 STATIC void 7482 S_simplify_sort(pTHX_ OP *o); 7483 # define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ 7484 assert(o) 7485 7486 STATIC OP * 7487 S_too_few_arguments_pv(pTHX_ OP *o, const char *name, U32 flags) 7488 __attribute__warn_unused_result__; 7489 # define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS_PV \ 7490 assert(o); assert(name) 7491 7492 STATIC OP * 7493 S_too_many_arguments_pv(pTHX_ OP *o, const char *name, U32 flags); 7494 # define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ 7495 assert(o); assert(name) 7496 7497 STATIC OP * 7498 S_voidnonfinal(pTHX_ OP *o); 7499 # define PERL_ARGS_ASSERT_VOIDNONFINAL 7500 7501 # if !defined(PERL_NO_INLINE_FUNCTIONS) 7502 PERL_STATIC_INLINE bool 7503 S_is_standard_filehandle_name(const char *fhname); 7504 # define PERL_ARGS_ASSERT_IS_STANDARD_FILEHANDLE_NAME \ 7505 assert(fhname) 7506 7507 PERL_STATIC_INLINE OP * 7508 S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP *dynamic_meth, SV * const_meth); 7509 # define PERL_ARGS_ASSERT_NEWMETHOP_INTERNAL 7510 7511 PERL_STATIC_INLINE OP * 7512 S_op_integerize(pTHX_ OP *o); 7513 # define PERL_ARGS_ASSERT_OP_INTEGERIZE \ 7514 assert(o) 7515 7516 PERL_STATIC_INLINE OP * 7517 S_op_std_init(pTHX_ OP *o); 7518 # define PERL_ARGS_ASSERT_OP_STD_INIT \ 7519 assert(o) 7520 7521 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 7522 #endif /* defined(PERL_IN_OP_C) */ 7523 #if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) 7524 PERL_CALLCONV void 7525 Perl_check_hash_fields_and_hekify(pTHX_ UNOP *rop, SVOP *key_op, int real) 7526 __attribute__visibility__("hidden"); 7527 # define PERL_ARGS_ASSERT_CHECK_HASH_FIELDS_AND_HEKIFY 7528 7529 PERL_CALLCONV void 7530 Perl_no_bareword_allowed(pTHX_ OP *o) 7531 __attribute__visibility__("hidden"); 7532 # define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ 7533 assert(o) 7534 7535 PERL_CALLCONV void 7536 Perl_op_prune_chain_head(OP **op_p) 7537 __attribute__visibility__("hidden"); 7538 # define PERL_ARGS_ASSERT_OP_PRUNE_CHAIN_HEAD \ 7539 assert(op_p) 7540 7541 PERL_CALLCONV SV * 7542 Perl_op_varname(pTHX_ const OP *o) 7543 __attribute__visibility__("hidden"); 7544 # define PERL_ARGS_ASSERT_OP_VARNAME \ 7545 assert(o) 7546 7547 PERL_CALLCONV void 7548 Perl_warn_elem_scalar_context(pTHX_ const OP *o, SV *name, bool is_hash, bool is_slice) 7549 __attribute__visibility__("hidden"); 7550 # define PERL_ARGS_ASSERT_WARN_ELEM_SCALAR_CONTEXT \ 7551 assert(o); assert(name) 7552 7553 #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) */ 7554 #if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) 7555 7556 #endif 7557 #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) 7558 PERL_CALLCONV void 7559 Perl_report_redefined_cv(pTHX_ const SV *name, const CV *old_cv, SV * const *new_const_svp) 7560 __attribute__visibility__("hidden"); 7561 # define PERL_ARGS_ASSERT_REPORT_REDEFINED_CV \ 7562 assert(name); assert(old_cv) 7563 7564 PERL_CALLCONV SV * 7565 Perl_varname(pTHX_ const GV * const gv, const char gvtype, PADOFFSET targ, const SV * const keyname, SSize_t aindex, int subscript_type) 7566 __attribute__warn_unused_result__ 7567 __attribute__visibility__("hidden"); 7568 # define PERL_ARGS_ASSERT_VARNAME 7569 7570 #endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) */ 7571 #if defined(PERL_IN_PAD_C) 7572 STATIC PADOFFSET 7573 S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash, HV *ourstash); 7574 # define PERL_ARGS_ASSERT_PAD_ALLOC_NAME \ 7575 assert(name) 7576 7577 STATIC void 7578 S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash); 7579 # define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ 7580 assert(name) 7581 7582 STATIC PADOFFSET 7583 S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV *cv, U32 seq, int warn, SV **out_capture, PADNAME **out_name, int *out_flags); 7584 # define PERL_ARGS_ASSERT_PAD_FINDLEX \ 7585 assert(namepv); assert(cv); assert(out_name); assert(out_flags) 7586 7587 STATIC void 7588 S_pad_reset(pTHX); 7589 # define PERL_ARGS_ASSERT_PAD_RESET 7590 7591 # if defined(DEBUGGING) 7592 STATIC void 7593 S_cv_dump(pTHX_ const CV *cv, const char *title); 7594 # define PERL_ARGS_ASSERT_CV_DUMP \ 7595 assert(cv); assert(title) 7596 7597 # endif 7598 #endif /* defined(PERL_IN_PAD_C) */ 7599 #if defined(PERL_IN_PEEP_C) 7600 STATIC void 7601 S_finalize_op(pTHX_ OP *o); 7602 # define PERL_ARGS_ASSERT_FINALIZE_OP \ 7603 assert(o) 7604 7605 STATIC void 7606 S_optimize_op(pTHX_ OP *o); 7607 # define PERL_ARGS_ASSERT_OPTIMIZE_OP \ 7608 assert(o) 7609 7610 STATIC OP * 7611 S_traverse_op_tree(pTHX_ OP *top, OP *o); 7612 # define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ 7613 assert(top); assert(o) 7614 7615 #endif /* defined(PERL_IN_PEEP_C) */ 7616 #if defined(PERL_IN_PERL_C) 7617 STATIC void 7618 S_find_beginning(pTHX_ SV *linestr_sv, PerlIO *rsfp); 7619 # define PERL_ARGS_ASSERT_FIND_BEGINNING \ 7620 assert(linestr_sv); assert(rsfp) 7621 7622 STATIC void 7623 S_forbid_setid(pTHX_ const char flag, const bool suidscript); 7624 # define PERL_ARGS_ASSERT_FORBID_SETID 7625 7626 STATIC void 7627 S_incpush(pTHX_ const char * const dir, STRLEN len, U32 flags); 7628 # define PERL_ARGS_ASSERT_INCPUSH \ 7629 assert(dir) 7630 7631 STATIC void 7632 S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags); 7633 # define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ 7634 assert(p) 7635 7636 STATIC void 7637 S_init_ids(pTHX); 7638 # define PERL_ARGS_ASSERT_INIT_IDS 7639 7640 STATIC void 7641 S_init_interp(pTHX); 7642 # define PERL_ARGS_ASSERT_INIT_INTERP 7643 7644 STATIC void 7645 S_init_main_stash(pTHX); 7646 # define PERL_ARGS_ASSERT_INIT_MAIN_STASH 7647 7648 STATIC void 7649 S_init_perllib(pTHX); 7650 # define PERL_ARGS_ASSERT_INIT_PERLLIB 7651 7652 STATIC void 7653 S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env); 7654 # define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ 7655 assert(argv) 7656 7657 STATIC void 7658 S_init_predump_symbols(pTHX); 7659 # define PERL_ARGS_ASSERT_INIT_PREDUMP_SYMBOLS 7660 7661 STATIC SV * 7662 S_mayberelocate(pTHX_ const char * const dir, STRLEN len, U32 flags); 7663 # define PERL_ARGS_ASSERT_MAYBERELOCATE \ 7664 assert(dir) 7665 7666 PERL_STATIC_NO_RET void 7667 S_minus_v(pTHX) 7668 __attribute__noreturn__; 7669 # define PERL_ARGS_ASSERT_MINUS_V 7670 7671 PERL_STATIC_NO_RET void 7672 S_my_exit_jump(pTHX) 7673 __attribute__noreturn__; 7674 # define PERL_ARGS_ASSERT_MY_EXIT_JUMP 7675 7676 STATIC void 7677 S_nuke_stacks(pTHX); 7678 # define PERL_ARGS_ASSERT_NUKE_STACKS 7679 7680 STATIC PerlIO * 7681 S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript); 7682 # define PERL_ARGS_ASSERT_OPEN_SCRIPT \ 7683 assert(scriptname); assert(suidscript) 7684 7685 STATIC void * 7686 S_parse_body(pTHX_ char **env, XSINIT_t xsinit); 7687 # define PERL_ARGS_ASSERT_PARSE_BODY 7688 7689 PERL_STATIC_NO_RET void 7690 S_run_body(pTHX_ I32 oldscope) 7691 __attribute__noreturn__; 7692 # define PERL_ARGS_ASSERT_RUN_BODY 7693 7694 PERL_STATIC_NO_RET void 7695 S_usage(pTHX) 7696 __attribute__noreturn__; 7697 # define PERL_ARGS_ASSERT_USAGE 7698 7699 # if !defined(PERL_IS_MINIPERL) 7700 STATIC SV * 7701 S_incpush_if_exists(pTHX_ AV * const av, SV *dir, SV * const stem); 7702 # define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ 7703 assert(av); assert(dir); assert(stem) 7704 7705 # endif 7706 # if !defined(SETUID_SCRIPTS_ARE_SECURE_NOW) 7707 STATIC void 7708 S_validate_suid(pTHX_ PerlIO *rsfp); 7709 # define PERL_ARGS_ASSERT_VALIDATE_SUID \ 7710 assert(rsfp) 7711 7712 # endif 7713 #endif /* defined(PERL_IN_PERL_C) */ 7714 #if defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || \ 7715 defined(PERL_IN_UTF8_C) 7716 PERL_CALLCONV bool 7717 Perl__invlistEQ(pTHX_ SV * const a, SV * const b, const bool complement_b); 7718 # define PERL_ARGS_ASSERT__INVLISTEQ \ 7719 assert(a); assert(b) 7720 7721 PERL_CALLCONV SV * 7722 Perl__new_invlist_C_array(pTHX_ const UV * const list) 7723 __attribute__warn_unused_result__; 7724 # define PERL_ARGS_ASSERT__NEW_INVLIST_C_ARRAY \ 7725 assert(list) 7726 7727 #endif /* defined(PERL_IN_PERL_C) || defined(PERL_IN_REGCOMP_ANY) || 7728 defined(PERL_IN_UTF8_C) */ 7729 #if defined(PERL_IN_PP_C) 7730 STATIC size_t 7731 S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping); 7732 # define PERL_ARGS_ASSERT_DO_CHOMP \ 7733 assert(retval); assert(sv) 7734 7735 STATIC OP * 7736 S_do_delete_local(pTHX); 7737 # define PERL_ARGS_ASSERT_DO_DELETE_LOCAL 7738 7739 STATIC SV * 7740 S_refto(pTHX_ SV *sv) 7741 __attribute__warn_unused_result__; 7742 # define PERL_ARGS_ASSERT_REFTO \ 7743 assert(sv) 7744 7745 #endif /* defined(PERL_IN_PP_C) */ 7746 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) 7747 7748 PERL_CALLCONV GV * 7749 Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) 7750 __attribute__warn_unused_result__; 7751 # define PERL_ARGS_ASSERT_SOFTREF2XV \ 7752 assert(sv); assert(what) 7753 7754 #endif 7755 #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) 7756 PERL_CALLCONV UV 7757 Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) 7758 __attribute__visibility__("hidden"); 7759 # define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ 7760 assert(p); assert(lenp) 7761 7762 #endif 7763 #if defined(PERL_IN_PP_CTL_C) 7764 STATIC PerlIO * 7765 S_check_type_and_open(pTHX_ SV *name) 7766 __attribute__warn_unused_result__; 7767 # define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ 7768 assert(name) 7769 7770 STATIC void 7771 S_destroy_matcher(pTHX_ PMOP *matcher); 7772 # define PERL_ARGS_ASSERT_DESTROY_MATCHER \ 7773 assert(matcher) 7774 7775 STATIC OP * 7776 S_do_smartmatch(pTHX_ HV *seen_this, HV *seen_other, const bool copied); 7777 # define PERL_ARGS_ASSERT_DO_SMARTMATCH 7778 7779 STATIC OP * 7780 S_docatch(pTHX_ Perl_ppaddr_t firstpp) 7781 __attribute__warn_unused_result__; 7782 # define PERL_ARGS_ASSERT_DOCATCH 7783 7784 STATIC bool 7785 S_doeval_compile(pTHX_ U8 gimme, CV *outside, U32 seq, HV *hh); 7786 # define PERL_ARGS_ASSERT_DOEVAL_COMPILE 7787 7788 STATIC OP * 7789 S_dofindlabel(pTHX_ OP *o, const char *label, STRLEN len, U32 flags, OP **opstack, OP **oplimit) 7790 __attribute__warn_unused_result__; 7791 # define PERL_ARGS_ASSERT_DOFINDLABEL \ 7792 assert(o); assert(label); assert(opstack); assert(oplimit) 7793 7794 STATIC MAGIC * 7795 S_doparseform(pTHX_ SV *sv); 7796 # define PERL_ARGS_ASSERT_DOPARSEFORM \ 7797 assert(sv) 7798 7799 STATIC I32 7800 S_dopoptoeval(pTHX_ I32 startingblock) 7801 __attribute__warn_unused_result__; 7802 # define PERL_ARGS_ASSERT_DOPOPTOEVAL 7803 7804 STATIC I32 7805 S_dopoptogivenfor(pTHX_ I32 startingblock) 7806 __attribute__warn_unused_result__; 7807 # define PERL_ARGS_ASSERT_DOPOPTOGIVENFOR 7808 7809 STATIC I32 7810 S_dopoptolabel(pTHX_ const char *label, STRLEN len, U32 flags) 7811 __attribute__warn_unused_result__; 7812 # define PERL_ARGS_ASSERT_DOPOPTOLABEL \ 7813 assert(label) 7814 7815 STATIC I32 7816 S_dopoptoloop(pTHX_ I32 startingblock) 7817 __attribute__warn_unused_result__; 7818 # define PERL_ARGS_ASSERT_DOPOPTOLOOP 7819 7820 STATIC I32 7821 S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock) 7822 __attribute__warn_unused_result__; 7823 # define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ 7824 assert(cxstk) 7825 7826 STATIC I32 7827 S_dopoptowhen(pTHX_ I32 startingblock) 7828 __attribute__warn_unused_result__; 7829 # define PERL_ARGS_ASSERT_DOPOPTOWHEN 7830 7831 STATIC PMOP * 7832 S_make_matcher(pTHX_ REGEXP *re) 7833 __attribute__warn_unused_result__; 7834 # define PERL_ARGS_ASSERT_MAKE_MATCHER \ 7835 assert(re) 7836 7837 STATIC bool 7838 S_matcher_matches_sv(pTHX_ PMOP *matcher, SV *sv) 7839 __attribute__warn_unused_result__; 7840 # define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ 7841 assert(matcher); assert(sv) 7842 7843 STATIC bool 7844 S_num_overflow(NV value, I32 fldsize, I32 frcsize) 7845 __attribute__warn_unused_result__; 7846 # define PERL_ARGS_ASSERT_NUM_OVERFLOW 7847 7848 STATIC I32 7849 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) 7850 __attribute__warn_unused_result__; 7851 # define PERL_ARGS_ASSERT_RUN_USER_FILTER \ 7852 assert(buf_sv) 7853 7854 STATIC void 7855 S_rxres_free(pTHX_ void **rsp); 7856 # define PERL_ARGS_ASSERT_RXRES_FREE \ 7857 assert(rsp) 7858 7859 STATIC void 7860 S_rxres_restore(pTHX_ void **rsp, REGEXP *rx); 7861 # define PERL_ARGS_ASSERT_RXRES_RESTORE \ 7862 assert(rsp); assert(rx) 7863 7864 STATIC void 7865 S_save_lines(pTHX_ AV *array, SV *sv); 7866 # define PERL_ARGS_ASSERT_SAVE_LINES \ 7867 assert(sv) 7868 7869 # if !defined(PERL_DISABLE_PMC) 7870 STATIC PerlIO * 7871 S_doopen_pm(pTHX_ SV *name) 7872 __attribute__warn_unused_result__; 7873 # define PERL_ARGS_ASSERT_DOOPEN_PM \ 7874 assert(name) 7875 7876 # endif 7877 # if !defined(PERL_NO_INLINE_FUNCTIONS) 7878 PERL_STATIC_INLINE bool 7879 S_path_is_searchable(const char *name) 7880 __attribute__warn_unused_result__; 7881 # define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ 7882 assert(name) 7883 7884 # endif 7885 #endif /* defined(PERL_IN_PP_CTL_C) */ 7886 #if defined(PERL_IN_PP_CTL_C) || defined(PERL_IN_UTIL_C) 7887 PERL_CALLCONV bool 7888 Perl_invoke_exception_hook(pTHX_ SV *ex, bool warn) 7889 __attribute__visibility__("hidden"); 7890 # define PERL_ARGS_ASSERT_INVOKE_EXCEPTION_HOOK 7891 7892 #endif 7893 #if defined(PERL_IN_PP_HOT_C) 7894 STATIC void 7895 S_do_oddball(pTHX_ SV **oddkey, SV **firstkey); 7896 # define PERL_ARGS_ASSERT_DO_ODDBALL \ 7897 assert(oddkey); assert(firstkey) 7898 7899 # if !defined(PERL_NO_INLINE_FUNCTIONS) 7900 PERL_STATIC_INLINE HV * 7901 S_opmethod_stash(pTHX_ SV *meth); 7902 # define PERL_ARGS_ASSERT_OPMETHOD_STASH \ 7903 assert(meth) 7904 7905 PERL_STATIC_FORCE_INLINE bool 7906 S_should_we_output_Debug_r(pTHX_ regexp *prog) 7907 __attribute__warn_unused_result__ 7908 __attribute__always_inline__; 7909 # define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R \ 7910 assert(prog) 7911 7912 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 7913 #endif /* defined(PERL_IN_PP_HOT_C) */ 7914 #if defined(PERL_IN_PP_PACK_C) 7915 STATIC int 7916 S_div128(pTHX_ SV *pnum, bool *done); 7917 # define PERL_ARGS_ASSERT_DIV128 \ 7918 assert(pnum); assert(done) 7919 7920 STATIC char 7921 S_first_symbol(const char *pat, const char *patend); 7922 # define PERL_ARGS_ASSERT_FIRST_SYMBOL \ 7923 assert(pat); assert(patend) 7924 7925 STATIC const char * 7926 S_get_num(pTHX_ const char *patptr, SSize_t *lenptr) 7927 __attribute__warn_unused_result__; 7928 # define PERL_ARGS_ASSERT_GET_NUM \ 7929 assert(patptr); assert(lenptr) 7930 7931 STATIC const char * 7932 S_group_end(pTHX_ const char *patptr, const char *patend, char ender); 7933 # define PERL_ARGS_ASSERT_GROUP_END \ 7934 assert(patptr); assert(patend) 7935 7936 STATIC SV * 7937 S_is_an_int(pTHX_ const char *s, STRLEN l) 7938 __attribute__warn_unused_result__; 7939 # define PERL_ARGS_ASSERT_IS_AN_INT \ 7940 assert(s) 7941 7942 STATIC SSize_t 7943 S_measure_struct(pTHX_ struct tempsym *symptr); 7944 # define PERL_ARGS_ASSERT_MEASURE_STRUCT \ 7945 assert(symptr) 7946 7947 STATIC SV * 7948 S_mul128(pTHX_ SV *sv, U8 m); 7949 # define PERL_ARGS_ASSERT_MUL128 \ 7950 assert(sv) 7951 7952 STATIC char * 7953 S_my_bytes_to_utf8(const U8 *start, STRLEN len, char *dest, const bool needs_swap) 7954 __attribute__warn_unused_result__; 7955 # define PERL_ARGS_ASSERT_MY_BYTES_TO_UTF8 \ 7956 assert(start); assert(dest) 7957 7958 STATIC bool 7959 S_need_utf8(const char *pat, const char *patend); 7960 # define PERL_ARGS_ASSERT_NEED_UTF8 \ 7961 assert(pat); assert(patend) 7962 7963 STATIC bool 7964 S_next_symbol(pTHX_ struct tempsym *symptr); 7965 # define PERL_ARGS_ASSERT_NEXT_SYMBOL \ 7966 assert(symptr) 7967 7968 STATIC SV ** 7969 S_pack_rec(pTHX_ SV *cat, struct tempsym *symptr, SV **beglist, SV **endlist); 7970 # define PERL_ARGS_ASSERT_PACK_REC \ 7971 assert(cat); assert(symptr); assert(beglist); assert(endlist) 7972 7973 STATIC char * 7974 S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) 7975 __attribute__warn_unused_result__; 7976 # define PERL_ARGS_ASSERT_SV_EXP_GROW \ 7977 assert(sv) 7978 7979 STATIC SSize_t 7980 S_unpack_rec(pTHX_ struct tempsym *symptr, const char *s, const char *strbeg, const char *strend, const char **new_s); 7981 # define PERL_ARGS_ASSERT_UNPACK_REC \ 7982 assert(symptr); assert(s); assert(strbeg); assert(strend) 7983 7984 #endif /* defined(PERL_IN_PP_PACK_C) */ 7985 #if defined(PERL_IN_PP_SORT_C) 7986 STATIC I32 7987 S_sortcv(pTHX_ SV * const a, SV * const b); 7988 # define PERL_ARGS_ASSERT_SORTCV \ 7989 assert(a); assert(b) 7990 7991 STATIC I32 7992 S_sortcv_stacked(pTHX_ SV * const a, SV * const b); 7993 # define PERL_ARGS_ASSERT_SORTCV_STACKED \ 7994 assert(a); assert(b) 7995 7996 STATIC I32 7997 S_sortcv_xsub(pTHX_ SV * const a, SV * const b); 7998 # define PERL_ARGS_ASSERT_SORTCV_XSUB \ 7999 assert(a); assert(b) 8000 8001 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8002 PERL_STATIC_INLINE I32 8003 S_amagic_cmp(pTHX_ SV * const str1, SV * const str2); 8004 # define PERL_ARGS_ASSERT_AMAGIC_CMP \ 8005 assert(str1); assert(str2) 8006 8007 PERL_STATIC_INLINE I32 8008 S_amagic_cmp_desc(pTHX_ SV * const str1, SV * const str2); 8009 # define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC \ 8010 assert(str1); assert(str2) 8011 8012 PERL_STATIC_INLINE I32 8013 S_amagic_i_ncmp(pTHX_ SV * const a, SV * const b); 8014 # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ 8015 assert(a); assert(b) 8016 8017 PERL_STATIC_INLINE I32 8018 S_amagic_i_ncmp_desc(pTHX_ SV * const a, SV * const b); 8019 # define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC \ 8020 assert(a); assert(b) 8021 8022 PERL_STATIC_INLINE I32 8023 S_amagic_ncmp(pTHX_ SV * const a, SV * const b); 8024 # define PERL_ARGS_ASSERT_AMAGIC_NCMP \ 8025 assert(a); assert(b) 8026 8027 PERL_STATIC_INLINE I32 8028 S_amagic_ncmp_desc(pTHX_ SV * const a, SV * const b); 8029 # define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC \ 8030 assert(a); assert(b) 8031 8032 PERL_STATIC_INLINE I32 8033 S_cmp_desc(pTHX_ SV * const str1, SV * const str2); 8034 # define PERL_ARGS_ASSERT_CMP_DESC \ 8035 assert(str1); assert(str2) 8036 8037 PERL_STATIC_FORCE_INLINE void 8038 S_sortsv_flags_impl(pTHX_ SV **array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) 8039 __attribute__always_inline__; 8040 # define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL \ 8041 assert(cmp) 8042 8043 PERL_STATIC_INLINE I32 8044 S_sv_i_ncmp(pTHX_ SV * const a, SV * const b); 8045 # define PERL_ARGS_ASSERT_SV_I_NCMP \ 8046 assert(a); assert(b) 8047 8048 PERL_STATIC_INLINE I32 8049 S_sv_i_ncmp_desc(pTHX_ SV * const a, SV * const b); 8050 # define PERL_ARGS_ASSERT_SV_I_NCMP_DESC \ 8051 assert(a); assert(b) 8052 8053 PERL_STATIC_INLINE I32 8054 S_sv_ncmp(pTHX_ SV * const a, SV * const b); 8055 # define PERL_ARGS_ASSERT_SV_NCMP \ 8056 assert(a); assert(b) 8057 8058 PERL_STATIC_INLINE I32 8059 S_sv_ncmp_desc(pTHX_ SV * const a, SV * const b); 8060 # define PERL_ARGS_ASSERT_SV_NCMP_DESC \ 8061 assert(a); assert(b) 8062 8063 # if defined(USE_LOCALE_COLLATE) 8064 PERL_STATIC_INLINE I32 8065 S_amagic_cmp_locale(pTHX_ SV * const str1, SV * const str2); 8066 # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ 8067 assert(str1); assert(str2) 8068 8069 PERL_STATIC_INLINE I32 8070 S_amagic_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); 8071 # define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC \ 8072 assert(str1); assert(str2) 8073 8074 PERL_STATIC_INLINE I32 8075 S_cmp_locale_desc(pTHX_ SV * const str1, SV * const str2); 8076 # define PERL_ARGS_ASSERT_CMP_LOCALE_DESC \ 8077 assert(str1); assert(str2) 8078 8079 # endif /* defined(USE_LOCALE_COLLATE) */ 8080 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8081 #endif /* defined(PERL_IN_PP_SORT_C) */ 8082 #if defined(PERL_IN_PP_SYS_C) 8083 STATIC OP * 8084 S_doform(pTHX_ CV *cv, GV *gv, OP *retop); 8085 # define PERL_ARGS_ASSERT_DOFORM \ 8086 assert(cv); assert(gv) 8087 8088 STATIC SV * 8089 S_space_join_names_mortal(pTHX_ char * const *array); 8090 # define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL 8091 8092 # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) 8093 STATIC int 8094 S_dooneliner(pTHX_ const char *cmd, const char *filename) 8095 __attribute__warn_unused_result__; 8096 # define PERL_ARGS_ASSERT_DOONELINER \ 8097 assert(cmd); assert(filename) 8098 8099 # endif 8100 #endif /* defined(PERL_IN_PP_SYS_C) */ 8101 #if defined(PERL_IN_REGCOMP_ANY) 8102 PERL_CALLCONV void 8103 Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV **invlist) 8104 __attribute__visibility__("hidden"); 8105 # define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ 8106 assert(pRExC_state); assert(invlist) 8107 8108 PERL_CALLCONV regnode * 8109 Perl_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth) 8110 __attribute__visibility__("hidden"); 8111 # define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \ 8112 assert(pRExC_state); assert(source) 8113 8114 PERL_CALLCONV SV * 8115 Perl_get_ANYOFHbbm_contents(pTHX_ const regnode *n) 8116 __attribute__warn_unused_result__ 8117 __attribute__visibility__("hidden"); 8118 # define PERL_ARGS_ASSERT_GET_ANYOFHBBM_CONTENTS \ 8119 assert(n) 8120 8121 PERL_CALLCONV SV * 8122 Perl_get_ANYOFM_contents(pTHX_ const regnode *n) 8123 __attribute__warn_unused_result__ 8124 __attribute__visibility__("hidden"); 8125 # define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS \ 8126 assert(n) 8127 8128 PERL_CALLCONV U32 8129 Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_subtract, bool *unfolded_multi_char, U32 flags, regnode *val, U32 depth) 8130 __attribute__visibility__("hidden"); 8131 # define PERL_ARGS_ASSERT_JOIN_EXACT \ 8132 assert(pRExC_state); assert(scan); assert(min_subtract); assert(unfolded_multi_char) 8133 8134 PERL_CALLCONV I32 8135 Perl_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth) 8136 __attribute__visibility__("hidden"); 8137 # define PERL_ARGS_ASSERT_MAKE_TRIE \ 8138 assert(pRExC_state); assert(startbranch); assert(first); assert(last); \ 8139 assert(tail) 8140 8141 PERL_CALLCONV void 8142 Perl_populate_anyof_bitmap_from_invlist(pTHX_ regnode *node, SV **invlist_ptr) 8143 __attribute__visibility__("hidden"); 8144 # define PERL_ARGS_ASSERT_POPULATE_ANYOF_BITMAP_FROM_INVLIST \ 8145 assert(node); assert(invlist_ptr) 8146 8147 PERL_CALLCONV U32 8148 Perl_reg_add_data(RExC_state_t * const pRExC_state, const char * const s, const U32 n) 8149 __attribute__warn_unused_result__ 8150 __attribute__visibility__("hidden"); 8151 # define PERL_ARGS_ASSERT_REG_ADD_DATA \ 8152 assert(pRExC_state); assert(s) 8153 8154 PERL_CALLCONV void 8155 Perl_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) 8156 __attribute__visibility__("hidden"); 8157 # define PERL_ARGS_ASSERT_SCAN_COMMIT \ 8158 assert(pRExC_state); assert(data); assert(minlenp) 8159 8160 PERL_CALLCONV void 8161 Perl_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) 8162 __attribute__visibility__("hidden"); 8163 # define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ 8164 assert(pRExC_state); assert(node) 8165 8166 PERL_CALLCONV void 8167 Perl_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc) 8168 __attribute__visibility__("hidden"); 8169 # define PERL_ARGS_ASSERT_SSC_INIT \ 8170 assert(pRExC_state); assert(ssc) 8171 8172 PERL_CALLCONV SSize_t 8173 Perl_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok) 8174 __attribute__visibility__("hidden"); 8175 # define PERL_ARGS_ASSERT_STUDY_CHUNK \ 8176 assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); \ 8177 assert(last) 8178 8179 # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) 8180 STATIC void 8181 S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 depth); 8182 # define PERL_ARGS_ASSERT_DUMP_TRIE \ 8183 assert(trie); assert(revcharmap) 8184 8185 STATIC void 8186 S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); 8187 # define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ 8188 assert(trie); assert(revcharmap) 8189 8190 STATIC void 8191 S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); 8192 # define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ 8193 assert(trie); assert(revcharmap) 8194 8195 # endif /* defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) */ 8196 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8197 PERL_STATIC_INLINE SV * 8198 S_invlist_contents(pTHX_ SV * const invlist, const bool traditional_style) 8199 __attribute__warn_unused_result__; 8200 # define PERL_ARGS_ASSERT_INVLIST_CONTENTS \ 8201 assert(invlist) 8202 8203 PERL_STATIC_INLINE UV 8204 S_invlist_highest_range_start(SV * const invlist) 8205 __attribute__warn_unused_result__; 8206 # define PERL_ARGS_ASSERT_INVLIST_HIGHEST_RANGE_START \ 8207 assert(invlist) 8208 8209 PERL_STATIC_INLINE bool 8210 S_invlist_is_iterating(const SV * const invlist) 8211 __attribute__warn_unused_result__; 8212 # define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ 8213 assert(invlist) 8214 8215 PERL_STATIC_INLINE UV 8216 S_invlist_lowest(SV * const invlist) 8217 __attribute__warn_unused_result__; 8218 # define PERL_ARGS_ASSERT_INVLIST_LOWEST \ 8219 assert(invlist) 8220 8221 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8222 #endif /* defined(PERL_IN_REGCOMP_ANY) */ 8223 #if defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_SV_C) 8224 PERL_CALLCONV SV * 8225 Perl_invlist_clone(pTHX_ SV * const invlist, SV *newlist); 8226 # define PERL_ARGS_ASSERT_INVLIST_CLONE \ 8227 assert(invlist) 8228 8229 #endif 8230 #if defined(PERL_IN_REGCOMP_C) 8231 STATIC AV * 8232 S_add_multi_match(pTHX_ AV *multi_char_matches, SV *multi_string, const STRLEN cp_count); 8233 # define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ 8234 assert(multi_string) 8235 8236 STATIC void 8237 S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size); 8238 # define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE \ 8239 assert(pRExC_state) 8240 8241 STATIC REGEXP * 8242 S_compile_wildcard(pTHX_ const char *subpattern, const STRLEN len, const bool ignore_case) 8243 __attribute__warn_unused_result__; 8244 # define PERL_ARGS_ASSERT_COMPILE_WILDCARD \ 8245 assert(subpattern) 8246 8247 STATIC U8 8248 S_compute_EXACTish(RExC_state_t *pRExC_state); 8249 # define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ 8250 assert(pRExC_state) 8251 8252 STATIC int 8253 S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance) 8254 __attribute__warn_unused_result__; 8255 # define PERL_ARGS_ASSERT_EDIT_DISTANCE \ 8256 assert(src); assert(tgt) 8257 8258 STATIC I32 8259 S_execute_wildcard(pTHX_ REGEXP * const prog, char *stringarg, char *strend, char *strbeg, SSize_t minend, SV *screamer, U32 nosave); 8260 # define PERL_ARGS_ASSERT_EXECUTE_WILDCARD \ 8261 assert(prog); assert(stringarg); assert(strend); assert(strbeg); \ 8262 assert(screamer) 8263 8264 STATIC U32 8265 S_get_quantifier_value(pTHX_ RExC_state_t *pRExC_state, const char *start, const char *end); 8266 # define PERL_ARGS_ASSERT_GET_QUANTIFIER_VALUE \ 8267 assert(pRExC_state); assert(start); assert(end) 8268 8269 STATIC bool 8270 S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset *nodep, UV *code_point_p, int *cp_count, I32 *flagp, const bool strict, const U32 depth); 8271 # define PERL_ARGS_ASSERT_GROK_BSLASH_N \ 8272 assert(pRExC_state); assert(flagp) 8273 8274 STATIC regnode_offset 8275 S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char *backref_parse_start, char ch); 8276 # define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF \ 8277 assert(pRExC_state); assert(flagp); assert(backref_parse_start) 8278 8279 STATIC bool 8280 S_handle_names_wildcard(pTHX_ const char *wname, const STRLEN wname_len, SV **prop_definition, AV **strings); 8281 # define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \ 8282 assert(wname); assert(prop_definition); assert(strings) 8283 8284 STATIC int 8285 S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char * const s, char **updated_parse_ptr, AV **posix_warnings, const bool check_only); 8286 # define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \ 8287 assert(pRExC_state); assert(s) 8288 8289 STATIC regnode_offset 8290 S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV **return_invlist, I32 *flagp, U32 depth); 8291 # define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ 8292 assert(pRExC_state); assert(flagp) 8293 8294 STATIC SV * 8295 S_handle_user_defined_property(pTHX_ const char *name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV *contents, bool *user_defined_ptr, SV *msg, const STRLEN level); 8296 # define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \ 8297 assert(name); assert(contents); assert(user_defined_ptr); assert(msg) 8298 8299 STATIC bool 8300 S_is_ssc_worth_it(const RExC_state_t *pRExC_state, const regnode_ssc *ssc); 8301 # define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT \ 8302 assert(pRExC_state); assert(ssc) 8303 8304 STATIC void 8305 S_nextchar(pTHX_ RExC_state_t *pRExC_state); 8306 # define PERL_ARGS_ASSERT_NEXTCHAR \ 8307 assert(pRExC_state) 8308 8309 STATIC U8 8310 S_optimize_regclass(pTHX_ RExC_state_t *pRExC_state, SV *cp_list, SV *only_utf8_locale_list, SV *upper_latin1_only_utf8_matches, const U32 has_runtime_dependency, const U32 posixl, U8 *anyof_flags, bool *invert, regnode_offset *ret, I32 *flagp); 8311 # define PERL_ARGS_ASSERT_OPTIMIZE_REGCLASS \ 8312 assert(pRExC_state); assert(anyof_flags); assert(invert); assert(ret); \ 8313 assert(flagp) 8314 8315 STATIC void 8316 S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV *posix_warnings); 8317 # define PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS \ 8318 assert(pRExC_state); assert(posix_warnings) 8319 8320 STATIC void 8321 S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state); 8322 # define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ 8323 assert(pRExC_state) 8324 8325 STATIC SV * 8326 S_parse_uniprop_string(pTHX_ const char * const name, Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, AV **strings, bool *user_defined_ptr, SV *msg, const STRLEN level); 8327 # define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING \ 8328 assert(name); assert(user_defined_ptr); assert(msg) 8329 8330 PERL_STATIC_NO_RET void 8331 S_re_croak(pTHX_ bool utf8, const char *pat, ...) 8332 __attribute__noreturn__ 8333 __attribute__format__(__printf__,pTHX_2,pTHX_3); 8334 # define PERL_ARGS_ASSERT_RE_CROAK \ 8335 assert(pat) 8336 8337 STATIC regnode_offset 8338 S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); 8339 # define PERL_ARGS_ASSERT_REG \ 8340 assert(pRExC_state); assert(flagp) 8341 8342 STATIC regnode_offset 8343 S_reg1node(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg); 8344 # define PERL_ARGS_ASSERT_REG1NODE \ 8345 assert(pRExC_state) 8346 8347 STATIC regnode_offset 8348 S_reg2node(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2); 8349 # define PERL_ARGS_ASSERT_REG2NODE \ 8350 assert(pRExC_state) 8351 8352 STATIC regnode_offset 8353 S_reg_la_NOTHING(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type); 8354 # define PERL_ARGS_ASSERT_REG_LA_NOTHING \ 8355 assert(pRExC_state); assert(type) 8356 8357 STATIC regnode_offset 8358 S_reg_la_OPFAIL(pTHX_ RExC_state_t *pRExC_state, U32 flags, const char *type); 8359 # define PERL_ARGS_ASSERT_REG_LA_OPFAIL \ 8360 assert(pRExC_state); assert(type) 8361 8362 STATIC regnode_offset 8363 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); 8364 # define PERL_ARGS_ASSERT_REG_NODE \ 8365 assert(pRExC_state) 8366 8367 STATIC SV * 8368 S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags); 8369 # define PERL_ARGS_ASSERT_REG_SCAN_NAME \ 8370 assert(pRExC_state) 8371 8372 STATIC regnode_offset 8373 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); 8374 # define PERL_ARGS_ASSERT_REGATOM \ 8375 assert(pRExC_state); assert(flagp) 8376 8377 STATIC regnode_offset 8378 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth); 8379 # define PERL_ARGS_ASSERT_REGBRANCH \ 8380 assert(pRExC_state); assert(flagp) 8381 8382 STATIC regnode_offset 8383 S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV **ret_invlist); 8384 # define PERL_ARGS_ASSERT_REGCLASS \ 8385 assert(pRExC_state); assert(flagp) 8386 8387 STATIC unsigned int 8388 S_regex_set_precedence(const U8 my_operator) 8389 __attribute__warn_unused_result__; 8390 # define PERL_ARGS_ASSERT_REGEX_SET_PRECEDENCE 8391 8392 STATIC void 8393 S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth); 8394 # define PERL_ARGS_ASSERT_REGINSERT \ 8395 assert(pRExC_state) 8396 8397 STATIC regnode_offset 8398 S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const STRLEN extra_len); 8399 # define PERL_ARGS_ASSERT_REGNODE_GUTS \ 8400 assert(pRExC_state) 8401 8402 STATIC regnode_offset 8403 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); 8404 # define PERL_ARGS_ASSERT_REGPIECE \ 8405 assert(pRExC_state); assert(flagp) 8406 8407 STATIC regnode_offset 8408 S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV *arg); 8409 # define PERL_ARGS_ASSERT_REGPNODE \ 8410 assert(pRExC_state); assert(arg) 8411 8412 STATIC bool 8413 S_regtail(pTHX_ RExC_state_t *pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth) 8414 __attribute__warn_unused_result__; 8415 # define PERL_ARGS_ASSERT_REGTAIL \ 8416 assert(pRExC_state); assert(p); assert(val) 8417 8418 STATIC void 8419 S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx); 8420 # define PERL_ARGS_ASSERT_SET_REGEX_PV \ 8421 assert(pRExC_state); assert(Rx) 8422 8423 STATIC void 8424 S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char **p, const bool force_to_xmod); 8425 # define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT \ 8426 assert(pRExC_state); assert(p) 8427 8428 STATIC void 8429 S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc); 8430 # define PERL_ARGS_ASSERT_SSC_FINALIZE \ 8431 assert(pRExC_state); assert(ssc) 8432 8433 # if defined(DEBUGGING) 8434 STATIC regnode_offset 8435 S_regnode_guts_debug(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len); 8436 # define PERL_ARGS_ASSERT_REGNODE_GUTS_DEBUG \ 8437 assert(pRExC_state) 8438 8439 STATIC bool 8440 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) 8441 __attribute__warn_unused_result__; 8442 # define PERL_ARGS_ASSERT_REGTAIL_STUDY \ 8443 assert(pRExC_state); assert(p); assert(val) 8444 8445 # if defined(ENABLE_REGEX_SETS_DEBUGGING) 8446 STATIC void 8447 S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV *stack, const IV fence, AV *fence_stack); 8448 # define PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES \ 8449 assert(pRExC_state); assert(stack); assert(fence_stack) 8450 8451 # endif 8452 # endif /* defined(DEBUGGING) */ 8453 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8454 PERL_STATIC_INLINE Size_t 8455 S_find_first_differing_byte_pos(const U8 *s1, const U8 *s2, const Size_t max); 8456 # define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \ 8457 assert(s1); assert(s2) 8458 8459 PERL_STATIC_INLINE char * 8460 S_reg_skipcomment(RExC_state_t *pRExC_state, char *p); 8461 # define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ 8462 assert(pRExC_state); assert(p) 8463 8464 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8465 #endif /* defined(PERL_IN_REGCOMP_C) */ 8466 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C) 8467 PERL_CALLCONV void 8468 Perl_populate_bitmap_from_invlist(pTHX_ SV *invlist, const UV offset, const U8 *bitmap, const Size_t len) 8469 __attribute__visibility__("hidden"); 8470 # define PERL_ARGS_ASSERT_POPULATE_BITMAP_FROM_INVLIST \ 8471 assert(invlist); assert(bitmap) 8472 8473 PERL_CALLCONV void 8474 Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_len, SV **invlist, const UV offset) 8475 __attribute__visibility__("hidden"); 8476 # define PERL_ARGS_ASSERT_POPULATE_INVLIST_FROM_BITMAP \ 8477 assert(bitmap); assert(invlist) 8478 8479 #endif /* defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGCOMP_INVLIST_C) */ 8480 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ 8481 defined(PERL_IN_TOKE_C) 8482 PERL_CALLCONV bool 8483 Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV cp) 8484 __attribute__warn_unused_result__ 8485 __attribute__visibility__("hidden"); 8486 # define PERL_ARGS_ASSERT_IS_GRAPHEME \ 8487 assert(strbeg); assert(s); assert(strend) 8488 8489 #endif 8490 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ 8491 defined(PERL_IN_UTF8_C) 8492 PERL_CALLCONV UV 8493 Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); 8494 # define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ 8495 assert(p); assert(lenp) 8496 8497 #endif 8498 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) 8499 PERL_CALLCONV bool 8500 Perl_regcurly(const char *s, const char *e, const char *result[5]) 8501 __attribute__warn_unused_result__; 8502 # define PERL_ARGS_ASSERT_REGCURLY \ 8503 assert(s); assert(e) 8504 8505 #endif 8506 #if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) 8507 STATIC U8 8508 S_put_charclass_bitmap_innards(pTHX_ SV *sv, char *bitmap, SV *nonbitmap_invlist, SV *only_utf8_locale_invlist, const regnode * const node, const U8 flags, const bool force_as_is_display); 8509 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \ 8510 assert(sv) 8511 8512 STATIC SV * 8513 S_put_charclass_bitmap_innards_common(pTHX_ SV *invlist, SV *posixes, SV *only_utf8, SV *not_utf8, SV *only_utf8_locale, const bool invert); 8514 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON \ 8515 assert(invlist) 8516 8517 STATIC void 8518 S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV *invlist); 8519 # define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST \ 8520 assert(sv); assert(invlist) 8521 8522 STATIC void 8523 S_put_code_point(pTHX_ SV *sv, UV c); 8524 # define PERL_ARGS_ASSERT_PUT_CODE_POINT \ 8525 assert(sv) 8526 8527 STATIC void 8528 S_put_range(pTHX_ SV *sv, UV start, const UV end, const bool allow_literals); 8529 # define PERL_ARGS_ASSERT_PUT_RANGE \ 8530 assert(sv) 8531 8532 STATIC void 8533 S_regdump_extflags(pTHX_ const char *lead, const U32 flags); 8534 # define PERL_ARGS_ASSERT_REGDUMP_EXTFLAGS 8535 8536 STATIC void 8537 S_regdump_intflags(pTHX_ const char *lead, const U32 flags); 8538 # define PERL_ARGS_ASSERT_REGDUMP_INTFLAGS 8539 8540 #endif /* defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) */ 8541 #if defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) 8542 STATIC void 8543 S__append_range_to_invlist(pTHX_ SV * const invlist, const UV start, const UV end); 8544 # define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ 8545 assert(invlist) 8546 8547 STATIC void 8548 S_initialize_invlist_guts(pTHX_ SV *invlist, const Size_t initial_size); 8549 # define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ 8550 assert(invlist) 8551 8552 STATIC void 8553 S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); 8554 # define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC \ 8555 assert(dest); assert(src) 8556 8557 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8558 PERL_STATIC_INLINE UV * 8559 S__invlist_array_init(SV * const invlist, const bool will_have_0) 8560 __attribute__warn_unused_result__; 8561 # define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ 8562 assert(invlist) 8563 8564 PERL_STATIC_INLINE IV * 8565 S_get_invlist_previous_index_addr(SV *invlist) 8566 __attribute__warn_unused_result__; 8567 # define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ 8568 assert(invlist) 8569 8570 PERL_STATIC_INLINE void 8571 S_invlist_clear(pTHX_ SV *invlist); 8572 # define PERL_ARGS_ASSERT_INVLIST_CLEAR \ 8573 assert(invlist) 8574 8575 PERL_STATIC_INLINE UV 8576 S_invlist_max(const SV * const invlist) 8577 __attribute__warn_unused_result__; 8578 # define PERL_ARGS_ASSERT_INVLIST_MAX \ 8579 assert(invlist) 8580 8581 PERL_STATIC_INLINE IV 8582 S_invlist_previous_index(SV * const invlist) 8583 __attribute__warn_unused_result__; 8584 # define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ 8585 assert(invlist) 8586 8587 PERL_STATIC_INLINE void 8588 S_invlist_set_previous_index(SV * const invlist, const IV index); 8589 # define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ 8590 assert(invlist) 8591 8592 PERL_STATIC_INLINE void 8593 S_invlist_trim(SV *invlist); 8594 # define PERL_ARGS_ASSERT_INVLIST_TRIM \ 8595 assert(invlist) 8596 8597 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8598 #endif /* defined(PERL_IN_REGCOMP_INVLIST_C) && !defined(PERL_EXT_RE_BUILD) */ 8599 #if defined(PERL_IN_REGCOMP_STUDY_C) 8600 STATIC SV * 8601 S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass * const node); 8602 # define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ 8603 assert(pRExC_state); assert(node) 8604 8605 STATIC SV * 8606 S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) 8607 __attribute__warn_unused_result__; 8608 # define PERL_ARGS_ASSERT_MAKE_EXACTF_INVLIST \ 8609 assert(pRExC_state); assert(node) 8610 8611 STATIC void 8612 S_rck_elide_nothing(pTHX_ regnode *node); 8613 # define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING \ 8614 assert(node) 8615 8616 STATIC void 8617 S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end); 8618 # define PERL_ARGS_ASSERT_SSC_ADD_RANGE \ 8619 assert(ssc) 8620 8621 STATIC void 8622 S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with); 8623 # define PERL_ARGS_ASSERT_SSC_AND \ 8624 assert(pRExC_state); assert(ssc); assert(and_with) 8625 8626 STATIC void 8627 S_ssc_anything(pTHX_ regnode_ssc *ssc); 8628 # define PERL_ARGS_ASSERT_SSC_ANYTHING \ 8629 assert(ssc) 8630 8631 STATIC void 8632 S_ssc_clear_locale(regnode_ssc *ssc); 8633 # define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ 8634 assert(ssc) 8635 8636 STATIC void 8637 S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp); 8638 # define PERL_ARGS_ASSERT_SSC_CP_AND \ 8639 assert(ssc) 8640 8641 STATIC void 8642 S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd); 8643 # define PERL_ARGS_ASSERT_SSC_INTERSECTION \ 8644 assert(ssc); assert(invlist) 8645 8646 STATIC int 8647 S_ssc_is_anything(const regnode_ssc *ssc) 8648 __attribute__warn_unused_result__; 8649 # define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ 8650 assert(ssc) 8651 8652 STATIC int 8653 S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) 8654 __attribute__warn_unused_result__; 8655 # define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ 8656 assert(pRExC_state); assert(ssc) 8657 8658 STATIC void 8659 S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with); 8660 # define PERL_ARGS_ASSERT_SSC_OR \ 8661 assert(pRExC_state); assert(ssc); assert(or_with) 8662 8663 STATIC void 8664 S_ssc_union(pTHX_ regnode_ssc *ssc, SV * const invlist, const bool invert_2nd); 8665 # define PERL_ARGS_ASSERT_SSC_UNION \ 8666 assert(ssc); assert(invlist) 8667 8668 STATIC void 8669 S_unwind_scan_frames(pTHX_ const void *p); 8670 # define PERL_ARGS_ASSERT_UNWIND_SCAN_FRAMES \ 8671 assert(p) 8672 8673 #endif /* defined(PERL_IN_REGCOMP_STUDY_C) */ 8674 #if defined(PERL_IN_REGEXEC_C) 8675 STATIC LB_enum 8676 S_advance_one_LB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) 8677 __attribute__warn_unused_result__; 8678 # define PERL_ARGS_ASSERT_ADVANCE_ONE_LB \ 8679 assert(curpos); assert(strend) 8680 8681 STATIC SB_enum 8682 S_advance_one_SB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target) 8683 __attribute__warn_unused_result__; 8684 # define PERL_ARGS_ASSERT_ADVANCE_ONE_SB \ 8685 assert(curpos); assert(strend) 8686 8687 STATIC WB_enum 8688 S_advance_one_WB(pTHX_ U8 **curpos, const U8 * const strend, const bool utf8_target, const bool skip_Extend_Format) 8689 __attribute__warn_unused_result__; 8690 # define PERL_ARGS_ASSERT_ADVANCE_ONE_WB \ 8691 assert(curpos); assert(strend) 8692 8693 STATIC GCB_enum 8694 S_backup_one_GCB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) 8695 __attribute__warn_unused_result__; 8696 # define PERL_ARGS_ASSERT_BACKUP_ONE_GCB \ 8697 assert(strbeg); assert(curpos) 8698 8699 STATIC LB_enum 8700 S_backup_one_LB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) 8701 __attribute__warn_unused_result__; 8702 # define PERL_ARGS_ASSERT_BACKUP_ONE_LB \ 8703 assert(strbeg); assert(curpos) 8704 8705 STATIC SB_enum 8706 S_backup_one_SB(pTHX_ const U8 * const strbeg, U8 **curpos, const bool utf8_target) 8707 __attribute__warn_unused_result__; 8708 # define PERL_ARGS_ASSERT_BACKUP_ONE_SB \ 8709 assert(strbeg); assert(curpos) 8710 8711 STATIC WB_enum 8712 S_backup_one_WB(pTHX_ WB_enum *previous, const U8 * const strbeg, U8 **curpos, const bool utf8_target) 8713 __attribute__warn_unused_result__; 8714 # define PERL_ARGS_ASSERT_BACKUP_ONE_WB \ 8715 assert(previous); assert(strbeg); assert(curpos) 8716 8717 STATIC char * 8718 S_find_byclass(pTHX_ regexp *prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) 8719 __attribute__warn_unused_result__; 8720 # define PERL_ARGS_ASSERT_FIND_BYCLASS \ 8721 assert(prog); assert(c); assert(s); assert(strend) 8722 8723 STATIC U8 * 8724 S_find_next_masked(U8 *s, const U8 *send, const U8 byte, const U8 mask) 8725 __attribute__warn_unused_result__; 8726 # define PERL_ARGS_ASSERT_FIND_NEXT_MASKED \ 8727 assert(s); assert(send) 8728 8729 STATIC U8 * 8730 S_find_span_end(U8 *s, const U8 *send, const U8 span_byte) 8731 __attribute__warn_unused_result__; 8732 # define PERL_ARGS_ASSERT_FIND_SPAN_END \ 8733 assert(s); assert(send) 8734 8735 STATIC U8 * 8736 S_find_span_end_mask(U8 *s, const U8 *send, const U8 span_byte, const U8 mask) 8737 __attribute__warn_unused_result__; 8738 # define PERL_ARGS_ASSERT_FIND_SPAN_END_MASK \ 8739 assert(s); assert(send) 8740 8741 STATIC bool 8742 S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) 8743 __attribute__warn_unused_result__; 8744 # define PERL_ARGS_ASSERT_ISFOO_LC 8745 8746 STATIC bool 8747 S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8 *character, const U8 *e) 8748 __attribute__warn_unused_result__; 8749 # define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ 8750 assert(character); assert(e) 8751 8752 STATIC bool 8753 S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target) 8754 __attribute__warn_unused_result__; 8755 # define PERL_ARGS_ASSERT_ISGCB \ 8756 assert(strbeg); assert(curpos) 8757 8758 STATIC bool 8759 S_isLB(pTHX_ LB_enum before, LB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 8760 __attribute__warn_unused_result__; 8761 # define PERL_ARGS_ASSERT_ISLB \ 8762 assert(strbeg); assert(curpos); assert(strend) 8763 8764 STATIC bool 8765 S_isSB(pTHX_ SB_enum before, SB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 8766 __attribute__warn_unused_result__; 8767 # define PERL_ARGS_ASSERT_ISSB \ 8768 assert(strbeg); assert(curpos); assert(strend) 8769 8770 STATIC bool 8771 S_isWB(pTHX_ WB_enum previous, WB_enum before, WB_enum after, const U8 * const strbeg, const U8 * const curpos, const U8 * const strend, const bool utf8_target) 8772 __attribute__warn_unused_result__; 8773 # define PERL_ARGS_ASSERT_ISWB \ 8774 assert(strbeg); assert(curpos); assert(strend) 8775 8776 STATIC I32 8777 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) 8778 __attribute__warn_unused_result__; 8779 # define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ 8780 assert(rex); assert(scan) 8781 8782 STATIC void 8783 S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p comma_pDEPTH); 8784 # define PERL_ARGS_ASSERT_REGCP_RESTORE \ 8785 assert(rex); assert(maxopenparen_p) 8786 8787 STATIC void 8788 S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p comma_pDEPTH); 8789 # define PERL_ARGS_ASSERT_REGCPPOP \ 8790 assert(rex); assert(maxopenparen_p) 8791 8792 STATIC CHECKPOINT 8793 S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen comma_pDEPTH); 8794 # define PERL_ARGS_ASSERT_REGCPPUSH \ 8795 assert(rex) 8796 8797 STATIC U8 * 8798 S_reghop3(U8 *s, SSize_t off, const U8 *lim) 8799 __attribute__warn_unused_result__; 8800 # define PERL_ARGS_ASSERT_REGHOP3 \ 8801 assert(s); assert(lim) 8802 8803 STATIC U8 * 8804 S_reghop4(U8 *s, SSize_t off, const U8 *llim, const U8 *rlim) 8805 __attribute__warn_unused_result__; 8806 # define PERL_ARGS_ASSERT_REGHOP4 \ 8807 assert(s); assert(llim); assert(rlim) 8808 8809 STATIC U8 * 8810 S_reghopmaybe3(U8 *s, SSize_t off, const U8 * const lim) 8811 __attribute__warn_unused_result__; 8812 # define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ 8813 assert(s); assert(lim) 8814 8815 STATIC bool 8816 S_reginclass(pTHX_ regexp * const prog, const regnode * const n, const U8 * const p, const U8 * const p_end, bool const utf8_target) 8817 __attribute__warn_unused_result__; 8818 # define PERL_ARGS_ASSERT_REGINCLASS \ 8819 assert(n); assert(p); assert(p_end) 8820 8821 STATIC SSize_t 8822 S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode *prog) 8823 __attribute__warn_unused_result__; 8824 # define PERL_ARGS_ASSERT_REGMATCH \ 8825 assert(reginfo); assert(startpos); assert(prog) 8826 8827 STATIC I32 8828 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info * const reginfo, I32 max comma_pDEPTH) 8829 __attribute__warn_unused_result__; 8830 # define PERL_ARGS_ASSERT_REGREPEAT \ 8831 assert(prog); assert(startposp); assert(p); assert(loceol); assert(reginfo); \ 8832 assert(max) 8833 8834 STATIC bool 8835 S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) 8836 __attribute__warn_unused_result__; 8837 # define PERL_ARGS_ASSERT_REGTRY \ 8838 assert(reginfo); assert(startposp) 8839 8840 STATIC bool 8841 S_to_byte_substr(pTHX_ regexp *prog); 8842 # define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ 8843 assert(prog) 8844 8845 STATIC void 8846 S_to_utf8_substr(pTHX_ regexp *prog); 8847 # define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ 8848 assert(prog) 8849 8850 # if defined(DEBUGGING) 8851 STATIC void 8852 S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb); 8853 # define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ 8854 assert(prog); assert(start); assert(end); assert(blurb) 8855 8856 STATIC void 8857 S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth); 8858 # define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ 8859 assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); \ 8860 assert(loc_reg_starttry) 8861 8862 PERL_CALLCONV int 8863 Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...) 8864 __attribute__visibility__("hidden"); 8865 # define PERL_ARGS_ASSERT_RE_EXEC_INDENTF \ 8866 assert(fmt) 8867 8868 # endif /* defined(DEBUGGING) */ 8869 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8870 PERL_STATIC_INLINE void 8871 S_capture_clear(pTHX_ regexp *rex, U16 from_ix, U16 to_ix, const char *str comma_pDEPTH); 8872 # define PERL_ARGS_ASSERT_CAPTURE_CLEAR \ 8873 assert(rex); assert(str) 8874 8875 PERL_STATIC_INLINE I32 8876 S_foldEQ_latin1_s2_folded(pTHX_ const char *a, const char *b, I32 len); 8877 # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1_S2_FOLDED \ 8878 assert(a); assert(b) 8879 8880 PERL_STATIC_INLINE void 8881 S_unwind_paren(pTHX_ regexp *rex, U32 lp, U32 lcp comma_pDEPTH); 8882 # define PERL_ARGS_ASSERT_UNWIND_PAREN \ 8883 assert(rex) 8884 8885 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8886 #endif /* defined(PERL_IN_REGEXEC_C) */ 8887 #if defined(PERL_IN_REGEX_ENGINE) 8888 8889 # if defined(DEBUGGING) 8890 PERL_CALLCONV void 8891 Perl_debug_peep(pTHX_ const char *str, const RExC_state_t *pRExC_state, regnode *scan, U32 depth, U32 flags) 8892 __attribute__visibility__("hidden"); 8893 # define PERL_ARGS_ASSERT_DEBUG_PEEP \ 8894 assert(str); assert(pRExC_state) 8895 8896 PERL_CALLCONV void 8897 Perl_debug_show_study_flags(pTHX_ U32 flags, const char *open_str, const char *close_str) 8898 __attribute__visibility__("hidden"); 8899 # define PERL_ARGS_ASSERT_DEBUG_SHOW_STUDY_FLAGS \ 8900 assert(open_str); assert(close_str) 8901 8902 PERL_CALLCONV void 8903 Perl_debug_studydata(pTHX_ const char *where, scan_data_t *data, U32 depth, int is_inf, SSize_t min, SSize_t stopmin, SSize_t delta) 8904 __attribute__visibility__("hidden"); 8905 # define PERL_ARGS_ASSERT_DEBUG_STUDYDATA \ 8906 assert(where) 8907 8908 PERL_CALLCONV const regnode * 8909 Perl_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV *sv, I32 indent, U32 depth) 8910 __attribute__visibility__("hidden"); 8911 # define PERL_ARGS_ASSERT_DUMPUNTIL \ 8912 assert(r); assert(start); assert(node); assert(sv) 8913 8914 PERL_CALLCONV int 8915 Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...) 8916 __attribute__visibility__("hidden"); 8917 # define PERL_ARGS_ASSERT_RE_INDENTF \ 8918 assert(fmt) 8919 8920 PERL_CALLCONV int 8921 Perl_re_printf(pTHX_ const char *fmt, ...) 8922 __attribute__visibility__("hidden") 8923 __attribute__format__(__printf__,pTHX_1,pTHX_2); 8924 # define PERL_ARGS_ASSERT_RE_PRINTF \ 8925 assert(fmt) 8926 8927 PERL_CALLCONV void 8928 Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state) 8929 __attribute__visibility__("hidden"); 8930 # define PERL_ARGS_ASSERT_REGPROP \ 8931 assert(sv); assert(o) 8932 8933 # endif /* defined(DEBUGGING) */ 8934 # if defined(PERL_EXT_RE_BUILD) 8935 PERL_CALLCONV SV * 8936 Perl_get_re_gclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) 8937 __attribute__visibility__("hidden"); 8938 # define PERL_ARGS_ASSERT_GET_RE_GCLASS_AUX_DATA \ 8939 assert(node) 8940 8941 # else 8942 PERL_CALLCONV SV * 8943 Perl_get_regclass_aux_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist) 8944 __attribute__visibility__("hidden"); 8945 # define PERL_ARGS_ASSERT_GET_REGCLASS_AUX_DATA \ 8946 assert(node) 8947 8948 # endif 8949 # if !defined(PERL_NO_INLINE_FUNCTIONS) 8950 PERL_STATIC_INLINE bool 8951 Perl_check_regnode_after(pTHX_ const regnode *p, const STRLEN extra) 8952 __attribute__warn_unused_result__; 8953 # define PERL_ARGS_ASSERT_CHECK_REGNODE_AFTER 8954 8955 PERL_STATIC_INLINE regnode * 8956 Perl_regnext(pTHX_ const regnode *p) 8957 __attribute__warn_unused_result__; 8958 # define PERL_ARGS_ASSERT_REGNEXT 8959 8960 PERL_STATIC_INLINE regnode * 8961 Perl_regnode_after(pTHX_ const regnode *p, bool varies) 8962 __attribute__warn_unused_result__; 8963 # define PERL_ARGS_ASSERT_REGNODE_AFTER 8964 8965 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 8966 #endif /* defined(PERL_IN_REGEX_ENGINE) */ 8967 #if defined(PERL_IN_SCOPE_C) 8968 STATIC void 8969 S_save_pushptri32ptr(pTHX_ void * const ptr1, const I32 i, void * const ptr2, const int type); 8970 # define PERL_ARGS_ASSERT_SAVE_PUSHPTRI32PTR 8971 8972 STATIC SV * 8973 S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); 8974 # define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ 8975 assert(sptr) 8976 8977 #endif /* defined(PERL_IN_SCOPE_C) */ 8978 #if defined(PERL_IN_SV_C) 8979 STATIC char * 8980 S_F0convert(NV nv, char * const endbuf, STRLEN * const len); 8981 # define PERL_ARGS_ASSERT_F0CONVERT \ 8982 assert(endbuf); assert(len) 8983 8984 STATIC void 8985 S_anonymise_cv_maybe(pTHX_ GV *gv, CV *cv); 8986 # define PERL_ARGS_ASSERT_ANONYMISE_CV_MAYBE \ 8987 assert(gv); assert(cv) 8988 8989 STATIC void 8990 S_assert_uft8_cache_coherent(pTHX_ const char * const func, STRLEN from_cache, STRLEN real, SV * const sv); 8991 # define PERL_ARGS_ASSERT_ASSERT_UFT8_CACHE_COHERENT \ 8992 assert(func); assert(sv) 8993 8994 STATIC bool 8995 S_curse(pTHX_ SV * const sv, const bool check_refcnt); 8996 # define PERL_ARGS_ASSERT_CURSE \ 8997 assert(sv) 8998 8999 STATIC STRLEN 9000 S_expect_number(pTHX_ const char ** const pattern) 9001 __attribute__warn_unused_result__; 9002 # define PERL_ARGS_ASSERT_EXPECT_NUMBER \ 9003 assert(pattern) 9004 9005 STATIC SSize_t 9006 S_find_array_subscript(pTHX_ const AV * const av, const SV * const val); 9007 # define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ 9008 assert(val) 9009 9010 STATIC SV * 9011 S_find_hash_subscript(pTHX_ const HV * const hv, const SV * const val); 9012 # define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ 9013 assert(val) 9014 9015 STATIC SV * 9016 S_find_uninit_var(pTHX_ const OP * const obase, const SV * const uninit_sv, bool match, const char **desc_p); 9017 # define PERL_ARGS_ASSERT_FIND_UNINIT_VAR \ 9018 assert(desc_p) 9019 9020 STATIC bool 9021 S_glob_2number(pTHX_ GV * const gv); 9022 # define PERL_ARGS_ASSERT_GLOB_2NUMBER \ 9023 assert(gv) 9024 9025 STATIC void 9026 S_glob_assign_glob(pTHX_ SV * const dsv, SV * const ssv, const int dtype); 9027 # define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ 9028 assert(dsv); assert(ssv) 9029 9030 PERL_CALLCONV SV * 9031 Perl_more_sv(pTHX); 9032 # define PERL_ARGS_ASSERT_MORE_SV 9033 9034 STATIC void 9035 S_not_a_number(pTHX_ SV * const sv); 9036 # define PERL_ARGS_ASSERT_NOT_A_NUMBER \ 9037 assert(sv) 9038 9039 STATIC void 9040 S_not_incrementable(pTHX_ SV * const sv); 9041 # define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ 9042 assert(sv) 9043 9044 STATIC PTR_TBL_ENT_t * 9045 S_ptr_table_find(PTR_TBL_t * const tbl, const void * const sv) 9046 __attribute__warn_unused_result__; 9047 # define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ 9048 assert(tbl) 9049 9050 STATIC bool 9051 S_sv_2iuv_common(pTHX_ SV * const sv); 9052 # define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ 9053 assert(sv) 9054 9055 STATIC void 9056 S_sv_add_arena(pTHX_ char * const ptr, const U32 size, const U32 flags); 9057 # define PERL_ARGS_ASSERT_SV_ADD_ARENA \ 9058 assert(ptr) 9059 9060 STATIC const char * 9061 S_sv_display(pTHX_ SV * const sv, char *tmpbuf, STRLEN tmpbuf_size); 9062 # define PERL_ARGS_ASSERT_SV_DISPLAY \ 9063 assert(sv); assert(tmpbuf) 9064 9065 STATIC STRLEN 9066 S_sv_pos_b2u_midway(pTHX_ const U8 * const s, const U8 * const target, const U8 *end, STRLEN endu); 9067 # define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ 9068 assert(s); assert(target); assert(end) 9069 9070 STATIC STRLEN 9071 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); 9072 # define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ 9073 assert(sv); assert(mgp); assert(start); assert(send) 9074 9075 STATIC STRLEN 9076 S_sv_pos_u2b_forwards(const U8 * const start, const U8 * const send, STRLEN * const uoffset, bool * const at_end, bool *canonical_position); 9077 # define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ 9078 assert(start); assert(send); assert(uoffset); assert(at_end); assert(canonical_position) 9079 9080 STATIC STRLEN 9081 S_sv_pos_u2b_midway(const U8 * const start, const U8 *send, STRLEN uoffset, const STRLEN uend); 9082 # define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ 9083 assert(start); assert(send) 9084 9085 STATIC void 9086 S_utf8_mg_len_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN ulen); 9087 # define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ 9088 assert(sv); assert(mgp) 9089 9090 STATIC void 9091 S_utf8_mg_pos_cache_update(pTHX_ SV * const sv, MAGIC ** const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen); 9092 # define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ 9093 assert(sv); assert(mgp) 9094 9095 STATIC SSize_t 9096 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask); 9097 # define PERL_ARGS_ASSERT_VISIT \ 9098 assert(f) 9099 9100 # if defined(DEBUGGING) 9101 STATIC void 9102 S_del_sv(pTHX_ SV *p); 9103 # define PERL_ARGS_ASSERT_DEL_SV \ 9104 assert(p) 9105 9106 PERL_CALLCONV void 9107 Perl_sv_mark_arenas(pTHX) 9108 __attribute__visibility__("hidden"); 9109 # define PERL_ARGS_ASSERT_SV_MARK_ARENAS 9110 9111 PERL_CALLCONV void 9112 Perl_sv_sweep_arenas(pTHX) 9113 __attribute__visibility__("hidden"); 9114 # define PERL_ARGS_ASSERT_SV_SWEEP_ARENAS 9115 9116 # endif /* defined(DEBUGGING) */ 9117 # if !defined(NV_PRESERVES_UV) 9118 # if defined(DEBUGGING) 9119 STATIC int 9120 S_sv_2iuv_non_preserve(pTHX_ SV * const sv, I32 numtype); 9121 # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 9122 assert(sv) 9123 9124 # else 9125 STATIC int 9126 S_sv_2iuv_non_preserve(pTHX_ SV * const sv); 9127 # define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 9128 assert(sv) 9129 9130 # endif 9131 # endif /* !defined(NV_PRESERVES_UV) */ 9132 # if defined(PERL_DEBUG_READONLY_COW) 9133 STATIC void 9134 S_sv_buf_to_rw(pTHX_ SV *sv); 9135 # define PERL_ARGS_ASSERT_SV_BUF_TO_RW \ 9136 assert(sv) 9137 9138 # endif 9139 # if !defined(PERL_NO_INLINE_FUNCTIONS) 9140 PERL_STATIC_INLINE void 9141 S_sv_unglob(pTHX_ SV * const sv, U32 flags); 9142 # define PERL_ARGS_ASSERT_SV_UNGLOB \ 9143 assert(sv) 9144 9145 PERL_STATIC_INLINE char * 9146 S_uiv_2buf(char * const buf, const IV iv, UV uv, const int is_uv, char ** const peob) 9147 __attribute__warn_unused_result__; 9148 # define PERL_ARGS_ASSERT_UIV_2BUF \ 9149 assert(buf); assert(peob) 9150 9151 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 9152 # if defined(USE_ITHREADS) 9153 STATIC SV * 9154 S_sv_dup_common(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) 9155 __attribute__warn_unused_result__; 9156 # define PERL_ARGS_ASSERT_SV_DUP_COMMON \ 9157 assert(ssv); assert(param) 9158 9159 STATIC void 9160 S_sv_dup_hvaux(pTHX_ const SV * const ssv, SV *dsv, CLONE_PARAMS * const param); 9161 # define PERL_ARGS_ASSERT_SV_DUP_HVAUX \ 9162 assert(ssv); assert(dsv); assert(param) 9163 9164 STATIC SV ** 9165 S_sv_dup_inc_multiple(pTHX_ SV * const *source, SV **dest, SSize_t items, CLONE_PARAMS * const param); 9166 # define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ 9167 assert(source); assert(dest); assert(param) 9168 9169 STATIC void 9170 S_unreferenced_to_tmp_stack(pTHX_ AV * const unreferenced); 9171 # define PERL_ARGS_ASSERT_UNREFERENCED_TO_TMP_STACK \ 9172 assert(unreferenced) 9173 9174 # endif /* defined(USE_ITHREADS) */ 9175 #endif /* defined(PERL_IN_SV_C) */ 9176 #if defined(PERL_IN_TOKE_C) 9177 STATIC int 9178 S_ao(pTHX_ int toketype); 9179 # define PERL_ARGS_ASSERT_AO 9180 9181 STATIC void 9182 S_check_uni(pTHX); 9183 # define PERL_ARGS_ASSERT_CHECK_UNI 9184 9185 STATIC void 9186 S_checkcomma(pTHX_ const char *s, const char *name, const char *what); 9187 # define PERL_ARGS_ASSERT_CHECKCOMMA \ 9188 assert(s); assert(name); assert(what) 9189 9190 STATIC char * 9191 S_filter_gets(pTHX_ SV *sv, STRLEN append) 9192 __attribute__warn_unused_result__; 9193 # define PERL_ARGS_ASSERT_FILTER_GETS \ 9194 assert(sv) 9195 9196 STATIC HV * 9197 S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) 9198 __attribute__warn_unused_result__; 9199 # define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ 9200 assert(pkgname) 9201 9202 STATIC void 9203 S_force_ident(pTHX_ const char *s, int kind); 9204 # define PERL_ARGS_ASSERT_FORCE_IDENT \ 9205 assert(s) 9206 9207 STATIC void 9208 S_force_ident_maybe_lex(pTHX_ char pit); 9209 # define PERL_ARGS_ASSERT_FORCE_IDENT_MAYBE_LEX 9210 9211 STATIC void 9212 S_force_next(pTHX_ I32 type); 9213 # define PERL_ARGS_ASSERT_FORCE_NEXT 9214 9215 STATIC char * 9216 S_force_strict_version(pTHX_ char *s); 9217 # define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ 9218 assert(s) 9219 9220 STATIC char * 9221 S_force_version(pTHX_ char *s, int guessing); 9222 # define PERL_ARGS_ASSERT_FORCE_VERSION \ 9223 assert(s) 9224 9225 STATIC char * 9226 S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack); 9227 # define PERL_ARGS_ASSERT_FORCE_WORD \ 9228 assert(start) 9229 9230 STATIC SV * 9231 S_get_and_check_backslash_N_name_wrapper(pTHX_ const char *s, const char * const e) 9232 __attribute__warn_unused_result__; 9233 # define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \ 9234 assert(s); assert(e) 9235 9236 STATIC void 9237 S_incline(pTHX_ const char *s, const char *end); 9238 # define PERL_ARGS_ASSERT_INCLINE \ 9239 assert(s); assert(end) 9240 9241 STATIC int 9242 S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv); 9243 # define PERL_ARGS_ASSERT_INTUIT_METHOD \ 9244 assert(s) 9245 9246 STATIC int 9247 S_intuit_more(pTHX_ char *s, char *e); 9248 # define PERL_ARGS_ASSERT_INTUIT_MORE \ 9249 assert(s); assert(e) 9250 9251 STATIC I32 9252 S_lop(pTHX_ I32 f, U8 x, char *s); 9253 # define PERL_ARGS_ASSERT_LOP \ 9254 assert(s) 9255 9256 PERL_STATIC_NO_RET void 9257 S_missingterm(pTHX_ char *s, STRLEN len) 9258 __attribute__noreturn__; 9259 # define PERL_ARGS_ASSERT_MISSINGTERM 9260 9261 STATIC SV * 9262 S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char **error_msg); 9263 # define PERL_ARGS_ASSERT_NEW_CONSTANT \ 9264 assert(key); assert(sv) 9265 9266 STATIC void 9267 S_no_op(pTHX_ const char * const what, char *s); 9268 # define PERL_ARGS_ASSERT_NO_OP \ 9269 assert(what) 9270 9271 STATIC void 9272 S_parse_ident(pTHX_ char **s, char **d, char * const e, int allow_package, bool is_utf8, bool check_dollar, bool tick_warn); 9273 # define PERL_ARGS_ASSERT_PARSE_IDENT \ 9274 assert(s); assert(d); assert(e) 9275 9276 STATIC int 9277 S_pending_ident(pTHX); 9278 # define PERL_ARGS_ASSERT_PENDING_IDENT 9279 9280 STATIC char * 9281 S_scan_const(pTHX_ char *start) 9282 __attribute__warn_unused_result__; 9283 # define PERL_ARGS_ASSERT_SCAN_CONST \ 9284 assert(start) 9285 9286 STATIC char * 9287 S_scan_formline(pTHX_ char *s) 9288 __attribute__warn_unused_result__; 9289 # define PERL_ARGS_ASSERT_SCAN_FORMLINE \ 9290 assert(s) 9291 9292 STATIC char * 9293 S_scan_heredoc(pTHX_ char *s) 9294 __attribute__warn_unused_result__; 9295 # define PERL_ARGS_ASSERT_SCAN_HEREDOC \ 9296 assert(s) 9297 9298 STATIC char * 9299 S_scan_ident(pTHX_ char *s, char *dest, STRLEN destlen, I32 ck_uni); 9300 # define PERL_ARGS_ASSERT_SCAN_IDENT \ 9301 assert(s); assert(dest) 9302 9303 STATIC char * 9304 S_scan_inputsymbol(pTHX_ char *start) 9305 __attribute__warn_unused_result__; 9306 # define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ 9307 assert(start) 9308 9309 STATIC char * 9310 S_scan_pat(pTHX_ char *start, I32 type) 9311 __attribute__warn_unused_result__; 9312 # define PERL_ARGS_ASSERT_SCAN_PAT \ 9313 assert(start) 9314 9315 STATIC char * 9316 S_scan_subst(pTHX_ char *start) 9317 __attribute__warn_unused_result__; 9318 # define PERL_ARGS_ASSERT_SCAN_SUBST \ 9319 assert(start) 9320 9321 STATIC char * 9322 S_scan_trans(pTHX_ char *start) 9323 __attribute__warn_unused_result__; 9324 # define PERL_ARGS_ASSERT_SCAN_TRANS \ 9325 assert(start) 9326 9327 STATIC I32 9328 S_sublex_done(pTHX) 9329 __attribute__warn_unused_result__; 9330 # define PERL_ARGS_ASSERT_SUBLEX_DONE 9331 9332 STATIC I32 9333 S_sublex_push(pTHX) 9334 __attribute__warn_unused_result__; 9335 # define PERL_ARGS_ASSERT_SUBLEX_PUSH 9336 9337 STATIC I32 9338 S_sublex_start(pTHX) 9339 __attribute__warn_unused_result__; 9340 # define PERL_ARGS_ASSERT_SUBLEX_START 9341 9342 STATIC char * 9343 S_swallow_bom(pTHX_ U8 *s) 9344 __attribute__warn_unused_result__; 9345 # define PERL_ARGS_ASSERT_SWALLOW_BOM \ 9346 assert(s) 9347 9348 STATIC char * 9349 S_tokenize_use(pTHX_ int is_use, char *s) 9350 __attribute__warn_unused_result__; 9351 # define PERL_ARGS_ASSERT_TOKENIZE_USE \ 9352 assert(s) 9353 9354 STATIC SV * 9355 S_tokeq(pTHX_ SV *sv); 9356 # define PERL_ARGS_ASSERT_TOKEQ \ 9357 assert(sv) 9358 9359 STATIC void 9360 S_update_debugger_info(pTHX_ SV *orig_sv, const char * const buf, STRLEN len); 9361 # define PERL_ARGS_ASSERT_UPDATE_DEBUGGER_INFO 9362 9363 STATIC int 9364 S_yywarn(pTHX_ const char * const s, U32 flags); 9365 # define PERL_ARGS_ASSERT_YYWARN \ 9366 assert(s) 9367 9368 # if defined(DEBUGGING) 9369 STATIC void 9370 S_printbuf(pTHX_ const char * const fmt, const char * const s) 9371 __attribute__format__(__printf__,pTHX_1,0); 9372 # define PERL_ARGS_ASSERT_PRINTBUF \ 9373 assert(fmt); assert(s) 9374 9375 STATIC int 9376 S_tokereport(pTHX_ I32 rv, const YYSTYPE *lvalp); 9377 # define PERL_ARGS_ASSERT_TOKEREPORT \ 9378 assert(lvalp) 9379 9380 # endif /* defined(DEBUGGING) */ 9381 # if defined(PERL_CR_FILTER) 9382 STATIC I32 9383 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); 9384 # define PERL_ARGS_ASSERT_CR_TEXTFILTER 9385 9386 STATIC void 9387 S_strip_return(pTHX_ SV *sv); 9388 # define PERL_ARGS_ASSERT_STRIP_RETURN \ 9389 assert(sv) 9390 9391 # endif /* defined(PERL_CR_FILTER) */ 9392 # if !defined(PERL_NO_UTF16_FILTER) 9393 STATIC U8 * 9394 S_add_utf16_textfilter(pTHX_ U8 * const s, bool reversed); 9395 # define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ 9396 assert(s) 9397 9398 STATIC I32 9399 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen); 9400 # define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ 9401 assert(sv) 9402 9403 # endif /* !defined(PERL_NO_UTF16_FILTER) */ 9404 #endif /* defined(PERL_IN_TOKE_C) */ 9405 #if defined(PERL_IN_UNIVERSAL_C) 9406 STATIC bool 9407 S_isa_lookup(pTHX_ HV *stash, SV *namesv, const char *name, STRLEN len, U32 flags); 9408 9409 STATIC bool 9410 S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN len, U32 flags); 9411 9412 #endif 9413 #if defined(PERL_IN_UTF8_C) 9414 STATIC UV 9415 S__to_utf8_case(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); 9416 # define PERL_ARGS_ASSERT__TO_UTF8_CASE \ 9417 assert(ustrp); assert(lenp); assert(invlist); assert(invmap); assert(normal) 9418 9419 STATIC UV 9420 S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp) 9421 __attribute__warn_unused_result__; 9422 # define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ 9423 assert(p); assert(ustrp); assert(lenp) 9424 9425 STATIC HV * 9426 S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) 9427 __attribute__warn_unused_result__; 9428 # define PERL_ARGS_ASSERT_NEW_MSG_HV \ 9429 assert(message) 9430 9431 STATIC UV 9432 S_to_case_cp_list(pTHX_ const UV original, const U32 ** const remaining_list, Size_t *remaining_count, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); 9433 # define PERL_ARGS_ASSERT_TO_CASE_CP_LIST \ 9434 assert(invlist); assert(invmap); assert(normal) 9435 9436 STATIC U8 9437 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) 9438 __attribute__warn_unused_result__; 9439 # define PERL_ARGS_ASSERT_TO_LOWER_LATIN1 9440 9441 STATIC UV 9442 S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); 9443 # define PERL_ARGS_ASSERT_TURKIC_FC \ 9444 assert(p); assert(e); assert(ustrp); assert(lenp) 9445 9446 STATIC UV 9447 S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8 *ustrp, STRLEN *lenp); 9448 # define PERL_ARGS_ASSERT_TURKIC_LC \ 9449 assert(p0); assert(e); assert(ustrp); assert(lenp) 9450 9451 STATIC UV 9452 S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); 9453 # define PERL_ARGS_ASSERT_TURKIC_UC \ 9454 assert(p); assert(e); assert(ustrp); assert(lenp) 9455 9456 STATIC char * 9457 S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) 9458 __attribute__warn_unused_result__; 9459 # define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ 9460 assert(s) 9461 9462 # if 0 9463 STATIC void 9464 S_warn_on_first_deprecated_use(pTHX_ U32 category, const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line); 9465 # define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \ 9466 assert(name); assert(alternative); assert(file) 9467 9468 # endif 9469 # if !defined(PERL_NO_INLINE_FUNCTIONS) 9470 PERL_STATIC_INLINE int 9471 S_does_utf8_overflow(const U8 * const s, const U8 *e, const bool consider_overlongs) 9472 __attribute__warn_unused_result__; 9473 # define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW \ 9474 assert(s); assert(e) 9475 9476 PERL_STATIC_INLINE int 9477 S_isFF_overlong(const U8 * const s, const STRLEN len) 9478 __attribute__warn_unused_result__; 9479 # define PERL_ARGS_ASSERT_ISFF_OVERLONG \ 9480 assert(s) 9481 9482 PERL_STATIC_INLINE bool 9483 S_is_utf8_common(pTHX_ const U8 * const p, const U8 * const e, SV * const invlist) 9484 __attribute__warn_unused_result__; 9485 # define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ 9486 assert(p); assert(e) 9487 9488 PERL_STATIC_INLINE int 9489 S_is_utf8_overlong(const U8 * const s, const STRLEN len) 9490 __attribute__warn_unused_result__; 9491 # define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG \ 9492 assert(s) 9493 9494 # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 9495 #endif /* defined(PERL_IN_UTF8_C) */ 9496 #if defined(PERL_IN_UTIL_C) 9497 STATIC bool 9498 S_ckwarn_common(pTHX_ U32 w); 9499 # define PERL_ARGS_ASSERT_CKWARN_COMMON 9500 9501 STATIC SV * 9502 S_mess_alloc(pTHX); 9503 # define PERL_ARGS_ASSERT_MESS_ALLOC 9504 9505 STATIC SV * 9506 S_with_queued_errors(pTHX_ SV *ex); 9507 # define PERL_ARGS_ASSERT_WITH_QUEUED_ERRORS \ 9508 assert(ex) 9509 9510 STATIC void 9511 S_xs_version_bootcheck(pTHX_ SSize_t items, SSize_t ax, const char *xs_p, STRLEN xs_len); 9512 # define PERL_ARGS_ASSERT_XS_VERSION_BOOTCHECK \ 9513 assert(xs_p) 9514 9515 # if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) 9516 STATIC void 9517 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); 9518 # define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ 9519 assert(type_name); assert(filename); assert(funcname) 9520 9521 # endif 9522 # if !defined(PERL_NO_INLINE_FUNCTIONS) 9523 PERL_STATIC_INLINE U32 9524 S_ptr_hash(PTRV u); 9525 # define PERL_ARGS_ASSERT_PTR_HASH 9526 9527 # endif 9528 # if defined(PERL_USES_PL_PIDSTATUS) 9529 STATIC void 9530 S_pidgone(pTHX_ Pid_t pid, int status); 9531 # define PERL_ARGS_ASSERT_PIDGONE 9532 9533 # endif 9534 #endif /* defined(PERL_IN_UTIL_C) */ 9535 #if defined(PERL_MEM_LOG) 9536 PERL_CALLCONV Malloc_t 9537 Perl_mem_log_alloc(const UV nconst, UV typesize, const char *type_name, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); 9538 # define PERL_ARGS_ASSERT_MEM_LOG_ALLOC \ 9539 assert(type_name); assert(filename); assert(funcname) 9540 9541 PERL_CALLCONV void 9542 Perl_mem_log_del_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); 9543 # define PERL_ARGS_ASSERT_MEM_LOG_DEL_SV \ 9544 assert(sv); assert(filename); assert(funcname) 9545 9546 PERL_CALLCONV Malloc_t 9547 Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname); 9548 # define PERL_ARGS_ASSERT_MEM_LOG_FREE \ 9549 assert(filename); assert(funcname) 9550 9551 PERL_CALLCONV void 9552 Perl_mem_log_new_sv(const SV *sv, const char *filename, int linenumber, const char *funcname); 9553 # define PERL_ARGS_ASSERT_MEM_LOG_NEW_SV \ 9554 assert(sv); assert(filename); assert(funcname) 9555 9556 PERL_CALLCONV Malloc_t 9557 Perl_mem_log_realloc(const UV n, const UV typesize, const char *type_name, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname); 9558 # define PERL_ARGS_ASSERT_MEM_LOG_REALLOC \ 9559 assert(type_name); assert(filename); assert(funcname) 9560 9561 #endif /* defined(PERL_MEM_LOG) */ 9562 #if !defined(PERL_NO_INLINE_FUNCTIONS) 9563 PERL_STATIC_INLINE I32 * 9564 Perl_CvDEPTH(const CV * const sv); 9565 # define PERL_ARGS_ASSERT_CVDEPTH \ 9566 assert(sv) 9567 9568 PERL_STATIC_INLINE GV * 9569 Perl_CvGV(pTHX_ CV *sv); 9570 # define PERL_ARGS_ASSERT_CVGV \ 9571 assert(sv) 9572 9573 PERL_STATIC_INLINE Stack_off_t 9574 Perl_POPMARK(pTHX); 9575 # define PERL_ARGS_ASSERT_POPMARK 9576 9577 PERL_STATIC_INLINE struct regexp * 9578 Perl_ReANY(const REGEXP * const re); 9579 # define PERL_ARGS_ASSERT_REANY \ 9580 assert(re) 9581 9582 PERL_STATIC_INLINE void 9583 Perl_SvAMAGIC_off(SV *sv); 9584 # define PERL_ARGS_ASSERT_SVAMAGIC_OFF \ 9585 assert(sv) 9586 9587 PERL_STATIC_INLINE void 9588 Perl_SvAMAGIC_on(SV *sv); 9589 # define PERL_ARGS_ASSERT_SVAMAGIC_ON \ 9590 assert(sv) 9591 9592 PERL_STATIC_INLINE void 9593 Perl_SvGETMAGIC(pTHX_ SV *sv); 9594 # define PERL_ARGS_ASSERT_SVGETMAGIC \ 9595 assert(sv) 9596 9597 PERL_STATIC_INLINE IV 9598 Perl_SvIV(pTHX_ SV *sv); 9599 # define PERL_ARGS_ASSERT_SVIV \ 9600 assert(sv) 9601 9602 PERL_STATIC_INLINE IV 9603 Perl_SvIV_nomg(pTHX_ SV *sv); 9604 # define PERL_ARGS_ASSERT_SVIV_NOMG \ 9605 assert(sv) 9606 9607 PERL_STATIC_INLINE NV 9608 Perl_SvNV(pTHX_ SV *sv); 9609 # define PERL_ARGS_ASSERT_SVNV \ 9610 assert(sv) 9611 9612 PERL_STATIC_INLINE NV 9613 Perl_SvNV_nomg(pTHX_ SV *sv); 9614 # define PERL_ARGS_ASSERT_SVNV_NOMG \ 9615 assert(sv) 9616 9617 PERL_STATIC_FORCE_INLINE bool 9618 Perl_SvPVXtrue(pTHX_ SV *sv) 9619 __attribute__always_inline__; 9620 # define PERL_ARGS_ASSERT_SVPVXTRUE \ 9621 assert(sv) 9622 9623 PERL_STATIC_INLINE void 9624 Perl_SvREFCNT_dec(pTHX_ SV *sv); 9625 # define PERL_ARGS_ASSERT_SVREFCNT_DEC 9626 9627 PERL_STATIC_INLINE void 9628 Perl_SvREFCNT_dec_NN(pTHX_ SV *sv); 9629 # define PERL_ARGS_ASSERT_SVREFCNT_DEC_NN \ 9630 assert(sv) 9631 9632 PERL_STATIC_INLINE SV * 9633 Perl_SvREFCNT_dec_ret_NULL(pTHX_ SV *sv); 9634 # define PERL_ARGS_ASSERT_SVREFCNT_DEC_RET_NULL 9635 9636 PERL_STATIC_INLINE SV * 9637 Perl_SvREFCNT_inc(SV *sv); 9638 # define PERL_ARGS_ASSERT_SVREFCNT_INC 9639 9640 PERL_STATIC_INLINE SV * 9641 Perl_SvREFCNT_inc_NN(SV *sv); 9642 # define PERL_ARGS_ASSERT_SVREFCNT_INC_NN \ 9643 assert(sv) 9644 9645 PERL_STATIC_INLINE void 9646 Perl_SvREFCNT_inc_void(SV *sv); 9647 # define PERL_ARGS_ASSERT_SVREFCNT_INC_VOID 9648 9649 PERL_STATIC_INLINE bool 9650 Perl_SvTRUE(pTHX_ SV *sv); 9651 # define PERL_ARGS_ASSERT_SVTRUE 9652 9653 PERL_STATIC_INLINE bool 9654 Perl_SvTRUE_NN(pTHX_ SV *sv); 9655 # define PERL_ARGS_ASSERT_SVTRUE_NN \ 9656 assert(sv) 9657 9658 PERL_STATIC_INLINE bool 9659 Perl_SvTRUE_common(pTHX_ SV *sv, const bool sv_2bool_is_fallback); 9660 # define PERL_ARGS_ASSERT_SVTRUE_COMMON \ 9661 assert(sv) 9662 9663 PERL_STATIC_INLINE bool 9664 Perl_SvTRUE_nomg(pTHX_ SV *sv); 9665 # define PERL_ARGS_ASSERT_SVTRUE_NOMG 9666 9667 PERL_STATIC_INLINE UV 9668 Perl_SvUV(pTHX_ SV *sv); 9669 # define PERL_ARGS_ASSERT_SVUV \ 9670 assert(sv) 9671 9672 PERL_STATIC_INLINE UV 9673 Perl_SvUV_nomg(pTHX_ SV *sv); 9674 # define PERL_ARGS_ASSERT_SVUV_NOMG \ 9675 assert(sv) 9676 9677 PERL_STATIC_INLINE Stack_off_t 9678 Perl_TOPMARK(pTHX); 9679 # define PERL_ARGS_ASSERT_TOPMARK 9680 9681 PERL_STATIC_INLINE void 9682 Perl_append_utf8_from_native_byte(const U8 byte, U8 **dest); 9683 # define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ 9684 assert(dest) 9685 9686 PERL_STATIC_INLINE Size_t 9687 Perl_av_count(pTHX_ AV *av) 9688 __attribute__warn_unused_result__; 9689 # define PERL_ARGS_ASSERT_AV_COUNT \ 9690 assert(av) 9691 9692 PERL_STATIC_INLINE SV ** 9693 Perl_av_fetch_simple(pTHX_ AV *av, SSize_t key, I32 lval) 9694 __attribute__warn_unused_result__; 9695 # define PERL_ARGS_ASSERT_AV_FETCH_SIMPLE \ 9696 assert(av) 9697 9698 PERL_STATIC_INLINE AV * 9699 Perl_av_new_alloc(pTHX_ SSize_t size, bool zeroflag) 9700 __attribute__warn_unused_result__; 9701 # define PERL_ARGS_ASSERT_AV_NEW_ALLOC 9702 9703 PERL_STATIC_INLINE void 9704 Perl_av_push_simple(pTHX_ AV *av, SV *val); 9705 # define PERL_ARGS_ASSERT_AV_PUSH_SIMPLE \ 9706 assert(av); assert(val) 9707 9708 PERL_STATIC_INLINE void 9709 Perl_av_remove_offset(pTHX_ AV *av); 9710 # define PERL_ARGS_ASSERT_AV_REMOVE_OFFSET \ 9711 assert(av) 9712 9713 PERL_STATIC_INLINE SV ** 9714 Perl_av_store_simple(pTHX_ AV *av, SSize_t key, SV *val); 9715 # define PERL_ARGS_ASSERT_AV_STORE_SIMPLE \ 9716 assert(av) 9717 9718 PERL_STATIC_INLINE void 9719 Perl_clear_defarray_simple(pTHX_ AV *av); 9720 # define PERL_ARGS_ASSERT_CLEAR_DEFARRAY_SIMPLE \ 9721 assert(av) 9722 9723 PERL_STATIC_INLINE I32 9724 Perl_foldEQ(pTHX_ const char *a, const char *b, I32 len); 9725 # define PERL_ARGS_ASSERT_FOLDEQ \ 9726 assert(a); assert(b) 9727 9728 PERL_STATIC_INLINE I32 9729 Perl_foldEQ_latin1(pTHX_ const char *a, const char *b, I32 len); 9730 # define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ 9731 assert(a); assert(b) 9732 9733 PERL_STATIC_INLINE I32 9734 Perl_foldEQ_locale(pTHX_ const char *a, const char *b, I32 len); 9735 # define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ 9736 assert(a); assert(b) 9737 9738 PERL_STATIC_INLINE MGVTBL * 9739 Perl_get_vtbl(pTHX_ int vtbl_id) 9740 __attribute__warn_unused_result__; 9741 # define PERL_ARGS_ASSERT_GET_VTBL 9742 9743 PERL_STATIC_INLINE Size_t 9744 Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) 9745 __attribute__warn_unused_result__; 9746 # define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ 9747 assert(s0); assert(e) 9748 9749 PERL_STATIC_INLINE Size_t 9750 Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) 9751 __attribute__warn_unused_result__; 9752 # define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ 9753 assert(s0); assert(e) 9754 9755 PERL_STATIC_INLINE Size_t 9756 Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) 9757 __attribute__warn_unused_result__; 9758 # define PERL_ARGS_ASSERT_ISUTF8_CHAR \ 9759 assert(s0); assert(e) 9760 9761 PERL_STATIC_INLINE Size_t 9762 Perl_isUTF8_CHAR_flags(const U8 * const s0, const U8 * const e, const U32 flags) 9763 __attribute__warn_unused_result__; 9764 # define PERL_ARGS_ASSERT_ISUTF8_CHAR_FLAGS \ 9765 assert(s0); assert(e) 9766 9767 PERL_STATIC_INLINE bool 9768 Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 9769 # define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ 9770 assert(s) 9771 9772 PERL_STATIC_INLINE bool 9773 Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) 9774 __attribute__warn_unused_result__; 9775 # define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ 9776 assert(pv); assert(what); assert(op_name) 9777 9778 PERL_STATIC_INLINE bool 9779 Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 9780 # define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ 9781 assert(s) 9782 9783 PERL_STATIC_INLINE bool 9784 Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); 9785 # define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ 9786 assert(s) 9787 9788 PERL_STATIC_INLINE bool 9789 Perl_is_utf8_invariant_string_loc(const U8 * const s, STRLEN len, const U8 **ep) 9790 __attribute__warn_unused_result__; 9791 # define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ 9792 assert(s) 9793 9794 PERL_STATIC_INLINE bool 9795 Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) 9796 __attribute__warn_unused_result__; 9797 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ 9798 assert(s) 9799 9800 PERL_STATIC_INLINE bool 9801 Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el); 9802 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ 9803 assert(s) 9804 9805 PERL_STATIC_INLINE bool 9806 Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); 9807 # define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ 9808 assert(s) 9809 9810 PERL_STATIC_INLINE bool 9811 Perl_is_utf8_valid_partial_char_flags(const U8 * const s0, const U8 * const e, const U32 flags) 9812 __attribute__warn_unused_result__; 9813 # define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ 9814 assert(s0); assert(e) 9815 9816 PERL_STATIC_INLINE unsigned 9817 Perl_lsbit_pos32(U32 word) 9818 __attribute__warn_unused_result__; 9819 # define PERL_ARGS_ASSERT_LSBIT_POS32 9820 9821 PERL_STATIC_INLINE char * 9822 Perl_mortal_getenv(const char *str) 9823 __attribute__warn_unused_result__; 9824 # define PERL_ARGS_ASSERT_MORTAL_GETENV \ 9825 assert(str) 9826 9827 PERL_STATIC_INLINE unsigned 9828 Perl_msbit_pos32(U32 word) 9829 __attribute__warn_unused_result__; 9830 # define PERL_ARGS_ASSERT_MSBIT_POS32 9831 9832 PERL_STATIC_INLINE OP * 9833 Perl_newPADxVOP(pTHX_ I32 type, I32 flags, PADOFFSET padix) 9834 __attribute__warn_unused_result__; 9835 # define PERL_ARGS_ASSERT_NEWPADXVOP 9836 9837 PERL_STATIC_INLINE SV * 9838 Perl_newRV_noinc(pTHX_ SV * const tmpRef) 9839 __attribute__warn_unused_result__; 9840 # define PERL_ARGS_ASSERT_NEWRV_NOINC \ 9841 assert(tmpRef) 9842 9843 PERL_STATIC_INLINE SV * 9844 Perl_newSV_type(pTHX_ const svtype type) 9845 __attribute__warn_unused_result__; 9846 # define PERL_ARGS_ASSERT_NEWSV_TYPE 9847 9848 PERL_STATIC_FORCE_INLINE SV * 9849 Perl_newSV_type_mortal(pTHX_ const svtype type) 9850 __attribute__warn_unused_result__ 9851 __attribute__always_inline__; 9852 # define PERL_ARGS_ASSERT_NEWSV_TYPE_MORTAL 9853 9854 PERL_STATIC_INLINE void 9855 Perl_pop_stackinfo(pTHX); 9856 # define PERL_ARGS_ASSERT_POP_STACKINFO 9857 9858 PERL_STATIC_INLINE void 9859 Perl_push_stackinfo(pTHX_ I32 type, UV flags); 9860 # define PERL_ARGS_ASSERT_PUSH_STACKINFO 9861 9862 PERL_STATIC_INLINE void 9863 Perl_rpp_context(pTHX_ SV **mark, U8 gimme, SSize_t extra); 9864 # define PERL_ARGS_ASSERT_RPP_CONTEXT \ 9865 assert(mark) 9866 9867 PERL_STATIC_INLINE void 9868 Perl_rpp_extend(pTHX_ SSize_t n); 9869 # define PERL_ARGS_ASSERT_RPP_EXTEND 9870 9871 PERL_STATIC_INLINE void 9872 Perl_rpp_invoke_xs(pTHX_ CV *cv); 9873 # define PERL_ARGS_ASSERT_RPP_INVOKE_XS \ 9874 assert(cv) 9875 9876 PERL_STATIC_INLINE bool 9877 Perl_rpp_is_lone(pTHX_ SV *sv); 9878 # define PERL_ARGS_ASSERT_RPP_IS_LONE \ 9879 assert(sv) 9880 9881 PERL_STATIC_INLINE SV * 9882 Perl_rpp_pop_1_norc(pTHX); 9883 # define PERL_ARGS_ASSERT_RPP_POP_1_NORC 9884 9885 PERL_STATIC_INLINE void 9886 Perl_rpp_popfree_1(pTHX); 9887 # define PERL_ARGS_ASSERT_RPP_POPFREE_1 9888 9889 PERL_STATIC_INLINE void 9890 Perl_rpp_popfree_1_NN(pTHX); 9891 # define PERL_ARGS_ASSERT_RPP_POPFREE_1_NN 9892 9893 PERL_STATIC_INLINE void 9894 Perl_rpp_popfree_2(pTHX); 9895 # define PERL_ARGS_ASSERT_RPP_POPFREE_2 9896 9897 PERL_STATIC_INLINE void 9898 Perl_rpp_popfree_2_NN(pTHX); 9899 # define PERL_ARGS_ASSERT_RPP_POPFREE_2_NN 9900 9901 PERL_STATIC_INLINE void 9902 Perl_rpp_popfree_to(pTHX_ SV **sp); 9903 # define PERL_ARGS_ASSERT_RPP_POPFREE_TO \ 9904 assert(sp) 9905 9906 PERL_STATIC_INLINE void 9907 Perl_rpp_popfree_to_NN(pTHX_ SV **sp); 9908 # define PERL_ARGS_ASSERT_RPP_POPFREE_TO_NN \ 9909 assert(sp) 9910 9911 PERL_STATIC_INLINE void 9912 Perl_rpp_push_1(pTHX_ SV *sv); 9913 # define PERL_ARGS_ASSERT_RPP_PUSH_1 \ 9914 assert(sv) 9915 9916 PERL_STATIC_INLINE void 9917 Perl_rpp_push_1_norc(pTHX_ SV *sv); 9918 # define PERL_ARGS_ASSERT_RPP_PUSH_1_NORC \ 9919 assert(sv) 9920 9921 PERL_STATIC_INLINE void 9922 Perl_rpp_push_2(pTHX_ SV *sv1, SV *sv2); 9923 # define PERL_ARGS_ASSERT_RPP_PUSH_2 \ 9924 assert(sv1); assert(sv2) 9925 9926 PERL_STATIC_INLINE void 9927 Perl_rpp_push_IMM(pTHX_ SV *sv); 9928 # define PERL_ARGS_ASSERT_RPP_PUSH_IMM \ 9929 assert(sv) 9930 9931 PERL_STATIC_INLINE void 9932 Perl_rpp_replace_1_1(pTHX_ SV *sv); 9933 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1 \ 9934 assert(sv) 9935 9936 PERL_STATIC_INLINE void 9937 Perl_rpp_replace_1_1_NN(pTHX_ SV *sv); 9938 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_1_NN \ 9939 assert(sv) 9940 9941 PERL_STATIC_INLINE void 9942 Perl_rpp_replace_1_IMM_NN(pTHX_ SV *sv); 9943 # define PERL_ARGS_ASSERT_RPP_REPLACE_1_IMM_NN \ 9944 assert(sv) 9945 9946 PERL_STATIC_INLINE void 9947 Perl_rpp_replace_2_1(pTHX_ SV *sv); 9948 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1 \ 9949 assert(sv) 9950 9951 PERL_STATIC_INLINE void 9952 Perl_rpp_replace_2_1_COMMON(pTHX_ SV *sv); 9953 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_COMMON \ 9954 assert(sv) 9955 9956 PERL_STATIC_INLINE void 9957 Perl_rpp_replace_2_1_NN(pTHX_ SV *sv); 9958 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_1_NN \ 9959 assert(sv) 9960 9961 PERL_STATIC_INLINE void 9962 Perl_rpp_replace_2_IMM_NN(pTHX_ SV *sv); 9963 # define PERL_ARGS_ASSERT_RPP_REPLACE_2_IMM_NN \ 9964 assert(sv) 9965 9966 PERL_STATIC_INLINE void 9967 Perl_rpp_replace_at(pTHX_ SV **sp, SV *sv); 9968 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT \ 9969 assert(sp); assert(sv) 9970 9971 PERL_STATIC_INLINE void 9972 Perl_rpp_replace_at_NN(pTHX_ SV **sp, SV *sv); 9973 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NN \ 9974 assert(sp); assert(sv) 9975 9976 PERL_STATIC_INLINE void 9977 Perl_rpp_replace_at_norc(pTHX_ SV **sp, SV *sv); 9978 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC \ 9979 assert(sp); assert(sv) 9980 9981 PERL_STATIC_INLINE void 9982 Perl_rpp_replace_at_norc_NN(pTHX_ SV **sp, SV *sv); 9983 # define PERL_ARGS_ASSERT_RPP_REPLACE_AT_NORC_NN \ 9984 assert(sp); assert(sv) 9985 9986 PERL_STATIC_INLINE bool 9987 Perl_rpp_stack_is_rc(pTHX); 9988 # define PERL_ARGS_ASSERT_RPP_STACK_IS_RC 9989 9990 PERL_STATIC_INLINE bool 9991 Perl_rpp_try_AMAGIC_1(pTHX_ int method, int flags); 9992 # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_1 9993 9994 PERL_STATIC_INLINE bool 9995 Perl_rpp_try_AMAGIC_2(pTHX_ int method, int flags); 9996 # define PERL_ARGS_ASSERT_RPP_TRY_AMAGIC_2 9997 9998 PERL_STATIC_INLINE void 9999 Perl_rpp_xpush_1(pTHX_ SV *sv); 10000 # define PERL_ARGS_ASSERT_RPP_XPUSH_1 \ 10001 assert(sv) 10002 10003 PERL_STATIC_INLINE void 10004 Perl_rpp_xpush_2(pTHX_ SV *sv1, SV *sv2); 10005 # define PERL_ARGS_ASSERT_RPP_XPUSH_2 \ 10006 assert(sv1); assert(sv2) 10007 10008 PERL_STATIC_INLINE void 10009 Perl_rpp_xpush_IMM(pTHX_ SV *sv); 10010 # define PERL_ARGS_ASSERT_RPP_XPUSH_IMM \ 10011 assert(sv) 10012 10013 PERL_STATIC_INLINE char * 10014 Perl_savepv(pTHX_ const char *pv) 10015 __attribute__malloc__ 10016 __attribute__warn_unused_result__; 10017 # define PERL_ARGS_ASSERT_SAVEPV 10018 10019 PERL_STATIC_INLINE char * 10020 Perl_savepvn(pTHX_ const char *pv, Size_t len) 10021 __attribute__malloc__ 10022 __attribute__warn_unused_result__; 10023 # define PERL_ARGS_ASSERT_SAVEPVN 10024 10025 PERL_STATIC_INLINE char * 10026 Perl_savesharedsvpv(pTHX_ SV *sv) 10027 __attribute__malloc__ 10028 __attribute__warn_unused_result__; 10029 # define PERL_ARGS_ASSERT_SAVESHAREDSVPV \ 10030 assert(sv) 10031 10032 PERL_STATIC_INLINE char * 10033 Perl_savesvpv(pTHX_ SV *sv) 10034 __attribute__malloc__ 10035 __attribute__warn_unused_result__; 10036 # define PERL_ARGS_ASSERT_SAVESVPV \ 10037 assert(sv) 10038 10039 PERL_STATIC_INLINE unsigned 10040 Perl_single_1bit_pos32(U32 word) 10041 __attribute__warn_unused_result__; 10042 # define PERL_ARGS_ASSERT_SINGLE_1BIT_POS32 10043 10044 PERL_STATIC_INLINE bool 10045 Perl_sv_only_taint_gmagic(SV *sv); 10046 # define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ 10047 assert(sv) 10048 10049 PERL_STATIC_INLINE char * 10050 Perl_sv_pvbyten_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); 10051 # define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE_WRAPPER \ 10052 assert(sv) 10053 10054 PERL_STATIC_INLINE char * 10055 Perl_sv_pvutf8n_force_wrapper(pTHX_ SV * const sv, STRLEN * const lp, const U32 dummy); 10056 # define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE_WRAPPER \ 10057 assert(sv) 10058 10059 PERL_STATIC_INLINE char * 10060 Perl_sv_setpv_freshbuf(pTHX_ SV * const sv); 10061 # define PERL_ARGS_ASSERT_SV_SETPV_FRESHBUF \ 10062 assert(sv) 10063 10064 PERL_STATIC_INLINE void 10065 Perl_switch_argstack(pTHX_ AV *to); 10066 # define PERL_ARGS_ASSERT_SWITCH_ARGSTACK \ 10067 assert(to) 10068 10069 PERL_STATIC_INLINE IV 10070 Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) 10071 __attribute__warn_unused_result__; 10072 # define PERL_ARGS_ASSERT_UTF8_DISTANCE \ 10073 assert(a); assert(b) 10074 10075 PERL_STATIC_INLINE U8 * 10076 Perl_utf8_hop(const U8 *s, SSize_t off) 10077 __attribute__warn_unused_result__; 10078 # define PERL_ARGS_ASSERT_UTF8_HOP \ 10079 assert(s) 10080 10081 PERL_STATIC_INLINE U8 * 10082 Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 *start) 10083 __attribute__warn_unused_result__; 10084 # define PERL_ARGS_ASSERT_UTF8_HOP_BACK \ 10085 assert(s); assert(start) 10086 10087 PERL_STATIC_INLINE U8 * 10088 Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 *end) 10089 __attribute__warn_unused_result__; 10090 # define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD \ 10091 assert(s); assert(end) 10092 10093 PERL_STATIC_INLINE U8 * 10094 Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 *start, const U8 *end) 10095 __attribute__warn_unused_result__; 10096 # define PERL_ARGS_ASSERT_UTF8_HOP_SAFE \ 10097 assert(s); assert(start); assert(end) 10098 10099 PERL_STATIC_INLINE UV 10100 Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); 10101 # define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER \ 10102 assert(s); assert(send) 10103 10104 PERL_STATIC_INLINE UV 10105 Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors, AV **msgs); 10106 # define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ 10107 assert(s) 10108 10109 PERL_STATIC_INLINE UV 10110 Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) 10111 __attribute__warn_unused_result__; 10112 # define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ 10113 assert(s) 10114 10115 PERL_STATIC_INLINE void 10116 Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx); 10117 # define PERL_ARGS_ASSERT_CX_POPBLOCK \ 10118 assert(cx) 10119 10120 PERL_STATIC_INLINE void 10121 Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx); 10122 # define PERL_ARGS_ASSERT_CX_POPEVAL \ 10123 assert(cx) 10124 10125 PERL_STATIC_INLINE void 10126 Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx); 10127 # define PERL_ARGS_ASSERT_CX_POPFORMAT \ 10128 assert(cx) 10129 10130 PERL_STATIC_INLINE void 10131 Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx); 10132 # define PERL_ARGS_ASSERT_CX_POPGIVEN \ 10133 assert(cx) 10134 10135 PERL_STATIC_INLINE void 10136 Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx); 10137 # define PERL_ARGS_ASSERT_CX_POPLOOP \ 10138 assert(cx) 10139 10140 PERL_STATIC_INLINE void 10141 Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx); 10142 # define PERL_ARGS_ASSERT_CX_POPSUB \ 10143 assert(cx) 10144 10145 PERL_STATIC_INLINE void 10146 Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); 10147 # define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ 10148 assert(cx) 10149 10150 PERL_STATIC_INLINE void 10151 Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); 10152 # define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ 10153 assert(cx) 10154 10155 PERL_STATIC_INLINE void 10156 Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx); 10157 # define PERL_ARGS_ASSERT_CX_POPWHEN \ 10158 assert(cx) 10159 10160 PERL_STATIC_INLINE PERL_CONTEXT * 10161 Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV **sp, I32 saveix); 10162 # define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ 10163 assert(sp) 10164 10165 PERL_STATIC_INLINE void 10166 Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); 10167 # define PERL_ARGS_ASSERT_CX_PUSHEVAL \ 10168 assert(cx) 10169 10170 PERL_STATIC_INLINE void 10171 Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); 10172 # define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ 10173 assert(cx); assert(cv) 10174 10175 PERL_STATIC_INLINE void 10176 Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); 10177 # define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ 10178 assert(cx) 10179 10180 PERL_STATIC_INLINE void 10181 Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); 10182 # define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ 10183 assert(cx); assert(itervarp) 10184 10185 PERL_STATIC_INLINE void 10186 Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); 10187 # define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ 10188 assert(cx) 10189 10190 PERL_STATIC_INLINE void 10191 Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); 10192 # define PERL_ARGS_ASSERT_CX_PUSHSUB \ 10193 assert(cx); assert(cv) 10194 10195 PERL_STATIC_INLINE void 10196 Perl_cx_pushtry(pTHX_ PERL_CONTEXT *cx, OP *retop); 10197 # define PERL_ARGS_ASSERT_CX_PUSHTRY \ 10198 assert(cx) 10199 10200 PERL_STATIC_INLINE void 10201 Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); 10202 # define PERL_ARGS_ASSERT_CX_PUSHWHEN \ 10203 assert(cx) 10204 10205 PERL_STATIC_INLINE void 10206 Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx); 10207 # define PERL_ARGS_ASSERT_CX_TOPBLOCK \ 10208 assert(cx) 10209 10210 PERL_STATIC_INLINE U8 10211 Perl_gimme_V(pTHX); 10212 # define PERL_ARGS_ASSERT_GIMME_V 10213 10214 # if !defined(HAS_STRLCAT) 10215 PERL_STATIC_INLINE Size_t 10216 Perl_my_strlcat(char *dst, const char *src, Size_t size); 10217 # define PERL_ARGS_ASSERT_MY_STRLCAT 10218 10219 # endif 10220 # if !defined(HAS_STRNLEN) 10221 PERL_STATIC_INLINE Size_t 10222 Perl_my_strnlen(const char *str, Size_t maxlen); 10223 # define PERL_ARGS_ASSERT_MY_STRNLEN \ 10224 assert(str) 10225 10226 # endif 10227 # if defined(PERL_CORE) || defined(PERL_EXT) 10228 PERL_STATIC_INLINE bool 10229 Perl_is_utf8_non_invariant_string(const U8 * const s, STRLEN len) 10230 __attribute__warn_unused_result__; 10231 # define PERL_ARGS_ASSERT_IS_UTF8_NON_INVARIANT_STRING \ 10232 assert(s) 10233 10234 PERL_STATIC_INLINE STRLEN 10235 S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp); 10236 # define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ 10237 assert(sv); assert(pv) 10238 10239 PERL_STATIC_INLINE Size_t 10240 S_variant_under_utf8_count(const U8 * const s, const U8 * const e) 10241 __attribute__warn_unused_result__; 10242 # define PERL_ARGS_ASSERT_VARIANT_UNDER_UTF8_COUNT \ 10243 assert(s); assert(e) 10244 10245 # if !defined(HAS_MEMRCHR) 10246 PERL_STATIC_INLINE void * 10247 S_my_memrchr(const char *s, const char c, const STRLEN len); 10248 # define PERL_ARGS_ASSERT_MY_MEMRCHR \ 10249 assert(s) 10250 10251 # endif 10252 # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ 10253 # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ 10254 defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ 10255 defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || \ 10256 defined(PERL_IN_UTF8_C) 10257 PERL_STATIC_INLINE bool 10258 S__invlist_contains_cp(SV * const invlist, const UV cp) 10259 __attribute__warn_unused_result__; 10260 # define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ 10261 assert(invlist) 10262 10263 PERL_STATIC_INLINE UV 10264 S__invlist_len(SV * const invlist) 10265 __attribute__warn_unused_result__; 10266 # define PERL_ARGS_ASSERT__INVLIST_LEN \ 10267 assert(invlist) 10268 10269 PERL_STATIC_INLINE bool * 10270 S_get_invlist_offset_addr(SV *invlist) 10271 __attribute__warn_unused_result__; 10272 # define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ 10273 assert(invlist) 10274 10275 PERL_STATIC_INLINE UV * 10276 S_invlist_array(SV * const invlist) 10277 __attribute__warn_unused_result__; 10278 # define PERL_ARGS_ASSERT_INVLIST_ARRAY \ 10279 assert(invlist) 10280 10281 PERL_STATIC_INLINE bool 10282 S_is_invlist(const SV * const invlist) 10283 __attribute__warn_unused_result__; 10284 # define PERL_ARGS_ASSERT_IS_INVLIST 10285 10286 # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || 10287 defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || 10288 defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || 10289 defined(PERL_IN_UTF8_C) */ 10290 # if defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || \ 10291 defined(PERL_IN_REGCOMP_ANY) 10292 PERL_STATIC_INLINE SV * 10293 S_add_cp_to_invlist(pTHX_ SV *invlist, const UV cp) 10294 __attribute__warn_unused_result__; 10295 # define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST 10296 10297 PERL_STATIC_INLINE void 10298 S_invlist_extend(pTHX_ SV * const invlist, const UV len); 10299 # define PERL_ARGS_ASSERT_INVLIST_EXTEND \ 10300 assert(invlist) 10301 10302 PERL_STATIC_INLINE UV 10303 S_invlist_highest(SV * const invlist) 10304 __attribute__warn_unused_result__; 10305 # define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ 10306 assert(invlist) 10307 10308 PERL_STATIC_INLINE void 10309 S_invlist_set_len(pTHX_ SV * const invlist, const UV len, const bool offset); 10310 # define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ 10311 assert(invlist) 10312 10313 # endif /* defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || 10314 defined(PERL_IN_REGCOMP_ANY) */ 10315 # if defined(PERL_IN_OP_C) || defined(PERL_IN_PAD_C) 10316 PERL_STATIC_INLINE bool 10317 S_PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq); 10318 # define PERL_ARGS_ASSERT_PADNAMEIN_SCOPE \ 10319 assert(pn) 10320 10321 # endif 10322 # if defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) 10323 PERL_STATIC_INLINE STRLEN * 10324 S_get_invlist_iter_addr(SV *invlist) 10325 __attribute__warn_unused_result__; 10326 # define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ 10327 assert(invlist) 10328 10329 PERL_STATIC_INLINE void 10330 S_invlist_iterfinish(SV *invlist); 10331 # define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ 10332 assert(invlist) 10333 10334 PERL_STATIC_INLINE void 10335 S_invlist_iterinit(SV *invlist); 10336 # define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ 10337 assert(invlist) 10338 10339 PERL_STATIC_INLINE bool 10340 S_invlist_iternext(SV *invlist, UV *start, UV *end) 10341 __attribute__warn_unused_result__; 10342 # define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ 10343 assert(invlist); assert(start); assert(end) 10344 10345 # endif /* defined(PERL_IN_OP_C) || defined(PERL_IN_REGCOMP_ANY) */ 10346 # if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) 10347 PERL_STATIC_INLINE bool 10348 S_lossless_NV_to_IV(const NV nv, IV *ivp) 10349 __attribute__warn_unused_result__; 10350 # define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV \ 10351 assert(ivp) 10352 10353 # endif 10354 # if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_ANY) || \ 10355 defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) 10356 PERL_STATIC_INLINE const char * 10357 S_get_regex_charset_name(const U32 flags, STRLEN * const lenp); 10358 # define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ 10359 assert(lenp) 10360 10361 # endif 10362 # if defined(U64TYPE) 10363 PERL_STATIC_INLINE unsigned 10364 Perl_lsbit_pos64(U64 word) 10365 __attribute__warn_unused_result__; 10366 # define PERL_ARGS_ASSERT_LSBIT_POS64 10367 10368 PERL_STATIC_INLINE unsigned 10369 Perl_msbit_pos64(U64 word) 10370 __attribute__warn_unused_result__; 10371 # define PERL_ARGS_ASSERT_MSBIT_POS64 10372 10373 PERL_STATIC_INLINE unsigned 10374 Perl_single_1bit_pos64(U64 word) 10375 __attribute__warn_unused_result__; 10376 # define PERL_ARGS_ASSERT_SINGLE_1BIT_POS64 10377 10378 # endif /* defined(U64TYPE) */ 10379 # if defined(USE_ITHREADS) 10380 PERL_STATIC_INLINE AV * 10381 Perl_cop_file_avn(pTHX_ const COP *cop); 10382 # define PERL_ARGS_ASSERT_COP_FILE_AVN \ 10383 assert(cop) 10384 10385 # if !defined(PERL_IMPLICIT_SYS) 10386 PERL_STATIC_INLINE bool 10387 S_PerlEnv_putenv(pTHX_ char *str); 10388 # define PERL_ARGS_ASSERT_PERLENV_PUTENV \ 10389 assert(str) 10390 10391 # endif 10392 # endif /* defined(USE_ITHREADS) */ 10393 # if !defined(WIN32) 10394 PERL_STATIC_INLINE void * 10395 Perl_get_context(void) 10396 __attribute__warn_unused_result__; 10397 # define PERL_ARGS_ASSERT_GET_CONTEXT 10398 10399 # endif 10400 #endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ 10401 #if defined(PERL_RC_STACK) 10402 PERL_CALLCONV OP * 10403 Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists); 10404 # define PERL_ARGS_ASSERT_PP_WRAP \ 10405 assert(real_pp_fn) 10406 10407 PERL_CALLCONV int 10408 Perl_runops_wrap(pTHX); 10409 # define PERL_ARGS_ASSERT_RUNOPS_WRAP 10410 10411 PERL_CALLCONV void 10412 Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv); 10413 # define PERL_ARGS_ASSERT_XS_WRAP \ 10414 assert(xsub); assert(cv) 10415 10416 #endif /* defined(PERL_RC_STACK) */ 10417 #if defined(PERL_USE_3ARG_SIGHANDLER) 10418 PERL_CALLCONV Signal_t 10419 Perl_csighandler(int sig, Siginfo_t *info, void *uap); 10420 # define PERL_ARGS_ASSERT_CSIGHANDLER 10421 10422 PERL_CALLCONV Signal_t 10423 Perl_sighandler(int sig, Siginfo_t *info, void *uap) 10424 __attribute__visibility__("hidden"); 10425 # define PERL_ARGS_ASSERT_SIGHANDLER 10426 10427 #else /* if !defined(PERL_USE_3ARG_SIGHANDLER) */ 10428 PERL_CALLCONV Signal_t 10429 Perl_csighandler(int sig); 10430 # define PERL_ARGS_ASSERT_CSIGHANDLER 10431 10432 PERL_CALLCONV Signal_t 10433 Perl_sighandler(int sig) 10434 __attribute__visibility__("hidden"); 10435 # define PERL_ARGS_ASSERT_SIGHANDLER 10436 10437 #endif /* !defined(PERL_USE_3ARG_SIGHANDLER) */ 10438 #if defined(U64TYPE) 10439 10440 #endif 10441 #if defined(UNLINK_ALL_VERSIONS) 10442 PERL_CALLCONV I32 10443 Perl_unlnk(pTHX_ const char *f); 10444 # define PERL_ARGS_ASSERT_UNLNK \ 10445 assert(f) 10446 10447 #endif 10448 #if defined(USE_C_BACKTRACE) 10449 PERL_CALLCONV bool 10450 Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); 10451 # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ 10452 assert(fp) 10453 10454 /* PERL_CALLCONV void 10455 free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ 10456 10457 PERL_CALLCONV Perl_c_backtrace * 10458 Perl_get_c_backtrace(pTHX_ int max_depth, int skip) 10459 __attribute__visibility__("hidden"); 10460 # define PERL_ARGS_ASSERT_GET_C_BACKTRACE 10461 10462 PERL_CALLCONV SV * 10463 Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); 10464 # define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP 10465 10466 #endif /* defined(USE_C_BACKTRACE) */ 10467 #if defined(USE_DTRACE) 10468 PERL_CALLCONV void 10469 Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); 10470 # define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL \ 10471 assert(cv) 10472 10473 PERL_CALLCONV void 10474 Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading); 10475 # define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD \ 10476 assert(name) 10477 10478 PERL_CALLCONV void 10479 Perl_dtrace_probe_op(pTHX_ const OP *op); 10480 # define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ 10481 assert(op) 10482 10483 PERL_CALLCONV void 10484 Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); 10485 # define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE 10486 10487 #endif /* defined(USE_DTRACE) */ 10488 #if defined(USE_ITHREADS) 10489 PERL_CALLCONV PADOFFSET 10490 Perl_alloccopstash(pTHX_ HV *hv); 10491 # define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ 10492 assert(hv) 10493 10494 PERL_CALLCONV void * 10495 Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) 10496 __attribute__warn_unused_result__; 10497 # define PERL_ARGS_ASSERT_ANY_DUP \ 10498 assert(proto_perl) 10499 10500 PERL_CALLCONV void 10501 Perl_clone_params_del(CLONE_PARAMS *param); 10502 # define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ 10503 assert(param) 10504 10505 PERL_CALLCONV CLONE_PARAMS * 10506 Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to) 10507 __attribute__warn_unused_result__; 10508 # define PERL_ARGS_ASSERT_CLONE_PARAMS_NEW \ 10509 assert(from); assert(to) 10510 10511 PERL_CALLCONV PERL_CONTEXT * 10512 Perl_cx_dup(pTHX_ PERL_CONTEXT *cx, I32 ix, I32 max, CLONE_PARAMS *param) 10513 __attribute__warn_unused_result__; 10514 # define PERL_ARGS_ASSERT_CX_DUP \ 10515 assert(param) 10516 10517 PERL_CALLCONV DIR * 10518 Perl_dirp_dup(pTHX_ DIR * const dp, CLONE_PARAMS * const param) 10519 __attribute__warn_unused_result__; 10520 # define PERL_ARGS_ASSERT_DIRP_DUP \ 10521 assert(param) 10522 10523 PERL_CALLCONV PerlIO * 10524 Perl_fp_dup(pTHX_ PerlIO * const fp, const char type, CLONE_PARAMS * const param); 10525 # define PERL_ARGS_ASSERT_FP_DUP \ 10526 assert(param) 10527 10528 PERL_CALLCONV GP * 10529 Perl_gp_dup(pTHX_ GP * const gp, CLONE_PARAMS * const param) 10530 __attribute__warn_unused_result__; 10531 # define PERL_ARGS_ASSERT_GP_DUP \ 10532 assert(param) 10533 10534 PERL_CALLCONV HE * 10535 Perl_he_dup(pTHX_ const HE *e, bool shared, CLONE_PARAMS *param) 10536 __attribute__warn_unused_result__; 10537 # define PERL_ARGS_ASSERT_HE_DUP \ 10538 assert(param) 10539 10540 PERL_CALLCONV HEK * 10541 Perl_hek_dup(pTHX_ HEK *e, CLONE_PARAMS *param) 10542 __attribute__warn_unused_result__; 10543 # define PERL_ARGS_ASSERT_HEK_DUP \ 10544 assert(param) 10545 10546 PERL_CALLCONV MAGIC * 10547 Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS * const param) 10548 __attribute__warn_unused_result__; 10549 # define PERL_ARGS_ASSERT_MG_DUP \ 10550 assert(param) 10551 10552 PERL_CALLCONV struct mro_meta * 10553 Perl_mro_meta_dup(pTHX_ struct mro_meta *smeta, CLONE_PARAMS *param) 10554 __attribute__visibility__("hidden"); 10555 # define PERL_ARGS_ASSERT_MRO_META_DUP \ 10556 assert(smeta); assert(param) 10557 10558 PERL_CALLCONV OP * 10559 Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv) 10560 __attribute__warn_unused_result__; 10561 # define PERL_ARGS_ASSERT_NEWPADOP \ 10562 assert(sv) 10563 10564 PERL_CALLCONV PADLIST * 10565 Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param) 10566 __attribute__warn_unused_result__ 10567 __attribute__visibility__("hidden"); 10568 # define PERL_ARGS_ASSERT_PADLIST_DUP \ 10569 assert(srcpad); assert(param) 10570 10571 PERL_CALLCONV PADNAME * 10572 Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param) 10573 __attribute__warn_unused_result__ 10574 __attribute__visibility__("hidden"); 10575 # define PERL_ARGS_ASSERT_PADNAME_DUP \ 10576 assert(src); assert(param) 10577 10578 PERL_CALLCONV PADNAMELIST * 10579 Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param) 10580 __attribute__warn_unused_result__ 10581 __attribute__visibility__("hidden"); 10582 # define PERL_ARGS_ASSERT_PADNAMELIST_DUP \ 10583 assert(srcpad); assert(param) 10584 10585 PERL_CALLCONV yy_parser * 10586 Perl_parser_dup(pTHX_ const yy_parser * const proto, CLONE_PARAMS * const param); 10587 # define PERL_ARGS_ASSERT_PARSER_DUP \ 10588 assert(param) 10589 10590 PERL_CALLCONV PerlInterpreter * 10591 perl_clone(PerlInterpreter *proto_perl, UV flags); 10592 # define PERL_ARGS_ASSERT_PERL_CLONE \ 10593 assert(proto_perl) 10594 10595 PERL_CALLCONV void 10596 Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS *param); 10597 # define PERL_ARGS_ASSERT_RE_DUP_GUTS \ 10598 assert(sstr); assert(dstr); assert(param) 10599 10600 PERL_CALLCONV void * 10601 Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS *param); 10602 # define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ 10603 assert(r); assert(param) 10604 10605 PERL_CALLCONV void 10606 Perl_rvpv_dup(pTHX_ SV * const dsv, const SV * const ssv, CLONE_PARAMS * const param); 10607 # define PERL_ARGS_ASSERT_RVPV_DUP \ 10608 assert(dsv); assert(ssv); assert(param) 10609 10610 PERL_CALLCONV PERL_SI * 10611 Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS *param) 10612 __attribute__warn_unused_result__; 10613 # define PERL_ARGS_ASSERT_SI_DUP \ 10614 assert(param) 10615 10616 PERL_CALLCONV ANY * 10617 Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS *param) 10618 __attribute__warn_unused_result__; 10619 # define PERL_ARGS_ASSERT_SS_DUP \ 10620 assert(proto_perl); assert(param) 10621 10622 PERL_CALLCONV SV * 10623 Perl_sv_dup(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) 10624 __attribute__warn_unused_result__; 10625 # define PERL_ARGS_ASSERT_SV_DUP \ 10626 assert(param) 10627 10628 PERL_CALLCONV SV * 10629 Perl_sv_dup_inc(pTHX_ const SV * const ssv, CLONE_PARAMS * const param) 10630 __attribute__warn_unused_result__; 10631 # define PERL_ARGS_ASSERT_SV_DUP_INC \ 10632 assert(param) 10633 10634 # if defined(PERL_IN_OP_C) || defined(PERL_IN_PEEP_C) 10635 PERL_CALLCONV void 10636 Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) 10637 __attribute__visibility__("hidden"); 10638 # define PERL_ARGS_ASSERT_OP_RELOCATE_SV \ 10639 assert(svp); assert(targp) 10640 10641 # endif 10642 #else /* if !defined(USE_ITHREADS) */ 10643 /* PERL_CALLCONV void 10644 CopFILEGV_set(pTHX_ COP *c, GV *gv); */ 10645 10646 #endif 10647 #if defined(USE_LOCALE_COLLATE) 10648 PERL_CALLCONV int 10649 Perl_magic_freecollxfrm(pTHX_ SV *sv, MAGIC *mg) 10650 __attribute__visibility__("hidden"); 10651 # define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM \ 10652 assert(sv); assert(mg) 10653 10654 PERL_CALLCONV int 10655 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) 10656 __attribute__visibility__("hidden"); 10657 # define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ 10658 assert(sv); assert(mg) 10659 10660 PERL_CALLCONV SV * 10661 Perl_strxfrm(pTHX_ SV *src); 10662 # define PERL_ARGS_ASSERT_STRXFRM \ 10663 assert(src) 10664 10665 PERL_CALLCONV char * 10666 Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); 10667 # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ 10668 assert(sv); assert(nxp) 10669 10670 # if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ 10671 defined(PERL_IN_SV_C) 10672 PERL_CALLCONV char * 10673 Perl_mem_collxfrm_(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen, bool utf8) 10674 __attribute__visibility__("hidden"); 10675 # define PERL_ARGS_ASSERT_MEM_COLLXFRM_ \ 10676 assert(input_string); assert(xlen) 10677 10678 # endif 10679 #endif /* defined(USE_LOCALE_COLLATE) */ 10680 #if defined(USE_LOCALE_CTYPE) 10681 PERL_CALLCONV void 10682 Perl_warn_problematic_locale(void); 10683 # define PERL_ARGS_ASSERT_WARN_PROBLEMATIC_LOCALE 10684 10685 #endif 10686 #if defined(USE_PERLIO) 10687 PERL_CALLCONV void 10688 Perl_PerlIO_clearerr(pTHX_ PerlIO *f); 10689 # define PERL_ARGS_ASSERT_PERLIO_CLEARERR 10690 10691 PERL_CALLCONV int 10692 Perl_PerlIO_close(pTHX_ PerlIO *f); 10693 # define PERL_ARGS_ASSERT_PERLIO_CLOSE 10694 10695 PERL_CALLCONV int 10696 Perl_PerlIO_eof(pTHX_ PerlIO *f); 10697 # define PERL_ARGS_ASSERT_PERLIO_EOF 10698 10699 PERL_CALLCONV int 10700 Perl_PerlIO_error(pTHX_ PerlIO *f); 10701 # define PERL_ARGS_ASSERT_PERLIO_ERROR 10702 10703 PERL_CALLCONV int 10704 Perl_PerlIO_fileno(pTHX_ PerlIO *f); 10705 # define PERL_ARGS_ASSERT_PERLIO_FILENO 10706 10707 PERL_CALLCONV int 10708 Perl_PerlIO_fill(pTHX_ PerlIO *f); 10709 # define PERL_ARGS_ASSERT_PERLIO_FILL 10710 10711 PERL_CALLCONV int 10712 Perl_PerlIO_flush(pTHX_ PerlIO *f); 10713 # define PERL_ARGS_ASSERT_PERLIO_FLUSH 10714 10715 PERL_CALLCONV STDCHAR * 10716 Perl_PerlIO_get_base(pTHX_ PerlIO *f); 10717 # define PERL_ARGS_ASSERT_PERLIO_GET_BASE 10718 10719 PERL_CALLCONV SSize_t 10720 Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) 10721 __attribute__warn_unused_result__; 10722 # define PERL_ARGS_ASSERT_PERLIO_GET_BUFSIZ 10723 10724 PERL_CALLCONV SSize_t 10725 Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) 10726 __attribute__warn_unused_result__; 10727 # define PERL_ARGS_ASSERT_PERLIO_GET_CNT 10728 10729 PERL_CALLCONV STDCHAR * 10730 Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); 10731 # define PERL_ARGS_ASSERT_PERLIO_GET_PTR 10732 10733 PERL_CALLCONV SSize_t 10734 Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count); 10735 # define PERL_ARGS_ASSERT_PERLIO_READ \ 10736 assert(vbuf) 10737 10738 PERL_CALLCONV void 10739 Perl_PerlIO_restore_errno(pTHX_ PerlIO *f); 10740 # define PERL_ARGS_ASSERT_PERLIO_RESTORE_ERRNO 10741 10742 PERL_CALLCONV void 10743 Perl_PerlIO_save_errno(pTHX_ PerlIO *f); 10744 # define PERL_ARGS_ASSERT_PERLIO_SAVE_ERRNO 10745 10746 PERL_CALLCONV int 10747 Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); 10748 # define PERL_ARGS_ASSERT_PERLIO_SEEK 10749 10750 PERL_CALLCONV void 10751 Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, SSize_t cnt); 10752 # define PERL_ARGS_ASSERT_PERLIO_SET_CNT 10753 10754 PERL_CALLCONV void 10755 Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, SSize_t cnt); 10756 # define PERL_ARGS_ASSERT_PERLIO_SET_PTRCNT 10757 10758 PERL_CALLCONV void 10759 Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); 10760 # define PERL_ARGS_ASSERT_PERLIO_SETLINEBUF 10761 10762 PERL_CALLCONV PerlIO * 10763 Perl_PerlIO_stderr(pTHX) 10764 __attribute__warn_unused_result__; 10765 # define PERL_ARGS_ASSERT_PERLIO_STDERR 10766 10767 PERL_CALLCONV PerlIO * 10768 Perl_PerlIO_stdin(pTHX) 10769 __attribute__warn_unused_result__; 10770 # define PERL_ARGS_ASSERT_PERLIO_STDIN 10771 10772 PERL_CALLCONV PerlIO * 10773 Perl_PerlIO_stdout(pTHX) 10774 __attribute__warn_unused_result__; 10775 # define PERL_ARGS_ASSERT_PERLIO_STDOUT 10776 10777 PERL_CALLCONV Off_t 10778 Perl_PerlIO_tell(pTHX_ PerlIO *f); 10779 # define PERL_ARGS_ASSERT_PERLIO_TELL 10780 10781 PERL_CALLCONV SSize_t 10782 Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count); 10783 # define PERL_ARGS_ASSERT_PERLIO_UNREAD \ 10784 assert(vbuf) 10785 10786 PERL_CALLCONV SSize_t 10787 Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count); 10788 # define PERL_ARGS_ASSERT_PERLIO_WRITE \ 10789 assert(vbuf) 10790 10791 #endif /* defined(USE_PERLIO) */ 10792 #if defined(USE_PERL_SWITCH_LOCALE_CONTEXT) 10793 PERL_CALLCONV void 10794 Perl_switch_locale_context(pTHX); 10795 # define PERL_ARGS_ASSERT_SWITCH_LOCALE_CONTEXT 10796 10797 #endif 10798 #if defined(USE_QUADMATH) 10799 PERL_CALLCONV bool 10800 Perl_quadmath_format_needed(const char *format) 10801 __attribute__visibility__("hidden"); 10802 # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_NEEDED \ 10803 assert(format) 10804 10805 PERL_CALLCONV bool 10806 Perl_quadmath_format_valid(const char *format) 10807 __attribute__visibility__("hidden"); 10808 # define PERL_ARGS_ASSERT_QUADMATH_FORMAT_VALID \ 10809 assert(format) 10810 10811 #endif /* defined(USE_QUADMATH) */ 10812 #if defined(USE_THREADS) 10813 PERL_CALLCONV void 10814 Perl_thread_locale_init(pTHX); 10815 # define PERL_ARGS_ASSERT_THREAD_LOCALE_INIT 10816 10817 PERL_CALLCONV void 10818 Perl_thread_locale_term(pTHX); 10819 # define PERL_ARGS_ASSERT_THREAD_LOCALE_TERM 10820 10821 #endif 10822 #if defined(VMS) || defined(WIN32) 10823 PERL_CALLCONV int 10824 Perl_do_aspawn(pTHX_ SV *really, SV **mark, SV **sp); 10825 # define PERL_ARGS_ASSERT_DO_ASPAWN \ 10826 assert(mark); assert(sp) 10827 10828 PERL_CALLCONV int 10829 Perl_do_spawn(pTHX_ char *cmd); 10830 # define PERL_ARGS_ASSERT_DO_SPAWN \ 10831 assert(cmd) 10832 10833 PERL_CALLCONV int 10834 Perl_do_spawn_nowait(pTHX_ char *cmd); 10835 # define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ 10836 assert(cmd) 10837 10838 #endif /* defined(VMS) || defined(WIN32) */ 10839 #if defined(WIN32) 10840 PERL_CALLCONV void * 10841 Perl_get_context(void) 10842 __attribute__warn_unused_result__; 10843 # define PERL_ARGS_ASSERT_GET_CONTEXT 10844 10845 PERL_CALLCONV bool 10846 Perl_get_win32_message_utf8ness(pTHX_ const char *string) 10847 __attribute__visibility__("hidden"); 10848 # define PERL_ARGS_ASSERT_GET_WIN32_MESSAGE_UTF8NESS 10849 10850 PERL_CALLCONV_NO_RET void 10851 win32_croak_not_implemented(const char *fname) 10852 __attribute__noreturn__; 10853 # define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \ 10854 assert(fname) 10855 10856 #else /* if !defined(WIN32) */ 10857 PERL_CALLCONV bool 10858 Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) 10859 __attribute__visibility__("hidden"); 10860 # define PERL_ARGS_ASSERT_DO_EXEC3 \ 10861 assert(incmd) 10862 10863 #endif 10864 10865 #ifdef PERL_CORE 10866 # include "pp_proto.h" 10867 #endif 10868 END_EXTERN_C 10869 10870 /* ex: set ro ft=c: */ 10871